diff --git a/pandas/core/algorithms.py b/pandas/core/algorithms.py
index 88bc497f9f22d3..eef2fde4386d87 100644
--- a/pandas/core/algorithms.py
+++ b/pandas/core/algorithms.py
@@ -154,7 +154,7 @@ def _reconstruct_data(values, dtype, original):
     """
     from pandas import Index
     if is_extension_array_dtype(dtype):
-        pass
+        values = dtype.array_type._from_sequence(values)
     elif is_datetime64tz_dtype(dtype) or is_period_dtype(dtype):
         values = Index(original)._shallow_copy(values, name=None)
     elif is_bool_dtype(dtype):
@@ -705,7 +705,7 @@ def value_counts(values, sort=True, ascending=False, normalize=False,
 
     else:
 
-        if is_categorical_dtype(values) or is_sparse(values):
+        if is_extension_array_dtype(values) or is_sparse(values):
 
             # handle Categorical and sparse,
             result = Series(values)._values.value_counts(dropna=dropna)
diff --git a/pandas/core/arrays/base.py b/pandas/core/arrays/base.py
index 1922801c30719e..1f25765addb0f8 100644
--- a/pandas/core/arrays/base.py
+++ b/pandas/core/arrays/base.py
@@ -82,7 +82,7 @@ class ExtensionArray(object):
     # Constructors
     # ------------------------------------------------------------------------
     @classmethod
-    def _from_sequence(cls, scalars):
+    def _from_sequence(cls, scalars, copy=False):
         """Construct a new ExtensionArray from a sequence of scalars.
 
         Parameters
@@ -90,6 +90,8 @@ def _from_sequence(cls, scalars):
         scalars : Sequence
             Each element will be an instance of the scalar type for this
             array, ``cls.dtype.type``.
+        copy : boolean, default True
+            if True, copy the underlying data
         Returns
         -------
         ExtensionArray
@@ -567,6 +569,34 @@ def copy(self, deep=False):
         """
         raise AbstractMethodError(self)
 
+    def append(self, other):
+        """
+        Append a collection of Arrays together
+
+        Parameters
+        ----------
+        other : ExtenionArray or list/tuple of ExtenionArrays
+
+        Returns
+        -------
+        appended : ExtensionArray
+        """
+
+        to_concat = [self]
+        cls = self.__class__
+
+        if isinstance(other, (list, tuple)):
+            to_concat = to_concat + list(other)
+        else:
+            to_concat.append(other)
+
+        for obj in to_concat:
+            if not isinstance(obj, cls):
+                raise TypeError('all inputs must be of type {}'.format(
+                    cls.__name__))
+
+        return cls._concat_same_type(to_concat)
+
     # ------------------------------------------------------------------------
     # Block-related methods
     # ------------------------------------------------------------------------
diff --git a/pandas/core/arrays/categorical.py b/pandas/core/arrays/categorical.py
index f91782459df674..239c197c9d1b33 100644
--- a/pandas/core/arrays/categorical.py
+++ b/pandas/core/arrays/categorical.py
@@ -2343,6 +2343,10 @@ def isin(self, values):
         return algorithms.isin(self.codes, code_values)
 
 
+# inform the Dtype about us
+CategoricalDtype.array_type = Categorical
+
+
 # The Series.cat accessor
 
 
diff --git a/pandas/core/arrays/integer.py b/pandas/core/arrays/integer.py
new file mode 100644
index 00000000000000..d1a3d3ace373d2
--- /dev/null
+++ b/pandas/core/arrays/integer.py
@@ -0,0 +1,341 @@
+import sys
+import numpy as np
+
+from pandas import isna, notna
+from pandas.api.types import is_integer, is_scalar
+from pandas.core.arrays import ExtensionArray
+from pandas.core.dtypes.base import ExtensionDtype
+
+
+# available dtypes
+_integer_dtypes = ['int8', 'int16', 'int32', 'int64']
+_integer_formatter = lambda x: x.capitalize()
+_unsigned_dtypes = ['uint8', 'uint16', 'uint32', 'uint64']
+_unsigned_formatter = lambda x: "{}{}".format(x[0].upper(), x[1:].capitalize())
+
+
+class IntegerDtype(ExtensionDtype):
+    type = None
+    na_value = np.nan
+    kind = 'i'
+    is_integer = True
+    is_signed_integer = True
+    is_unsigned_integer = False
+
+    @classmethod
+    def construct_from_string(cls, string):
+        if string == cls.name:
+            return cls()
+        else:
+            raise TypeError("Cannot construct a '{}' from "
+                            "'{}'".format(cls, string))
+
+
+class UnsignedIntegerDtype(IntegerDtype):
+    kind = 'u'
+    is_signed_integer = False
+    is_unsigned_integer = True
+
+
+def coerce_to_array(values, dtype, mask=None, copy=False):
+    """
+    Coerce the input values array to numpy arrays with a mask
+
+    Parameters
+    ----------
+    values : 1D list-like
+    dtype : integer dtype
+    mask : boolean 1D array, optional
+    copy : boolean, default False
+        if True, copy the input
+
+    Returns
+    -------
+    tuple of (values, mask)
+    """
+    values = np.array(values, copy=copy)
+    if mask is None:
+        mask = isna(values)
+    else:
+        assert len(mask) == len(values)
+
+    assert values.ndim == 1
+    assert mask.ndim == 1
+
+    if mask.any():
+        # we copy as need to coerce here
+        values = values.copy()
+        values[mask] = 0
+
+        values = values.astype(dtype.type)
+
+    else:
+        values = values.astype(dtype.type, copy=False)
+    return values, mask
+
+
+class IntegerArray(ExtensionArray):
+    """
+    We represent an IntegerArray with 2 numpy arrays
+    - data: contains a numpy integer array of the appropriate dtype
+    - mask: a boolean array holding a mask on the data, False is missing
+    """
+
+    dtype = None
+
+    def __init__(self, values, mask=None, copy=False):
+        self.data, self.mask = coerce_to_array(
+            values, dtype=self.dtype, mask=mask, copy=copy)
+
+    @classmethod
+    def _from_sequence(cls, scalars, mask=None, copy=False):
+        return cls(scalars, mask=mask, copy=copy)
+
+    @classmethod
+    def _from_factorized(cls, values, original):
+        return cls(values)
+
+    def __getitem__(self, item):
+        if is_integer(item):
+            if self.mask[item]:
+                return self.dtype.na_value
+            return self.data[item]
+        return type(self)(self.data[item], mask=self.mask[item])
+
+    def _coerce_to_ndarray(self):
+        """ coerce to an ndarary, preserving my scalar types """
+
+        # TODO(jreback) make this better
+        data = self.data.astype(object)
+        data[self.mask] = self._na_value
+        return data
+
+    def __array__(self, dtype=None):
+        """
+        the array interface, return my values
+        We return an object array here to preserve our scalar values
+        """
+        return self._coerce_to_ndarray()
+
+    def __iter__(self):
+        """Iterate over elements of the array.
+
+        """
+        # This needs to be implemented so that pandas recognizes extension
+        # arrays as list-like. The default implementation makes successive
+        # calls to ``__getitem__``, which may be slower than necessary.
+        for i in range(len(self)):
+            if self.mask[i]:
+                yield self.dtype.na_value
+            else:
+                yield self.data[i]
+
+    def _formatting_values(self):
+        # type: () -> np.ndarray
+        return self._coerce_to_ndarray()
+
+    def take(self, indexer, allow_fill=False, fill_value=None):
+        from pandas.api.extensions import take
+
+        # we always fill with 0 internally
+        # to avoid upcasting
+        data_fill_value = 0 if isna(fill_value) else fill_value
+        result = take(self.data, indexer, fill_value=data_fill_value,
+                      allow_fill=allow_fill)
+
+        mask = take(self.mask, indexer, fill_value=True,
+                    allow_fill=allow_fill)
+
+        # if we are filling
+        # we only fill where the indexer is null
+        # not existing missing values
+        # TODO(jreback) what if we have a non-na float as a fill value?
+        if allow_fill and notna(fill_value):
+            fill_mask = np.asarray(indexer) == -1
+            result[fill_mask] = fill_value
+            mask = mask ^ fill_mask
+
+        return self._from_sequence(result, mask=mask)
+
+    def copy(self, deep=False):
+        if deep:
+            return type(self)(self._data.copy())
+        return type(self)(self)
+
+    def __setitem__(self, key, value):
+        _is_scalar = is_scalar(value)
+        if _is_scalar:
+            value = [value]
+        value, mask = coerce_to_array(value, dtype=self.dtype)
+
+        if _is_scalar:
+            value = value[0]
+            mask = mask[0]
+
+        self.data[key] = value
+        self.mask[key] = mask
+
+    def __len__(self):
+        return len(self.data)
+
+    def __repr__(self):
+
+        formatted = self._formatting_values()
+        return '{}({})'.format(
+            self.__class__.__name__,
+            formatted.tolist())
+
+    @property
+    def nbytes(self):
+        return self.data.nbytes + self.mask.nbytes
+
+    def isna(self):
+        return self.mask
+
+    @property
+    def _na_value(self):
+        return np.nan
+
+    @classmethod
+    def _concat_same_type(cls, to_concat):
+        data = np.concatenate([x.data for x in to_concat])
+        mask = np.concatenate([x.mask for x in to_concat])
+        return cls(data, mask=mask)
+
+    def astype(self, dtype, copy=True):
+        """Cast to a NumPy array with 'dtype'.
+
+        Parameters
+        ----------
+        dtype : str or dtype
+            Typecode or data-type to which the array is cast.
+        copy : bool, default True
+            Whether to copy the data, even if not necessary. If False,
+            a copy is made only if the old dtype does not match the
+            new dtype.
+
+        Returns
+        -------
+        array : ndarray
+            NumPy ndarray with 'dtype' for its dtype.
+        """
+        data = self._coerce_to_ndarray()
+        return data.astype(dtype=dtype, copy=False)
+
+    @property
+    def _ndarray_values(self):
+        # type: () -> np.ndarray
+        """Internal pandas method for lossy conversion to a NumPy ndarray.
+
+        This method is not part of the pandas interface.
+
+        The expectation is that this is cheap to compute, and is primarily
+        used for interacting with our indexers.
+        """
+        return self.data
+
+    def value_counts(self, dropna=True):
+        """
+        Returns a Series containing counts of each category.
+
+        Every category will have an entry, even those with a count of 0.
+
+        Parameters
+        ----------
+        dropna : boolean, default True
+            Don't include counts of NaN.
+
+        Returns
+        -------
+        counts : Series
+
+        See Also
+        --------
+        Series.value_counts
+
+        """
+
+        from pandas import Index, Series
+
+        # compute counts on the data with no nans
+        data = self.data[~self.mask]
+        value_counts = Index(data).value_counts()
+
+        array = value_counts.values
+        index = value_counts.index
+
+        # if we want nans, count the mask
+        if not dropna:
+            array = np.append(array, [self.mask.sum()])
+
+            # TODO(extension)
+            # should this be an and Index backed by the
+            # Array type?
+            index = index.astype(object).append(Index([np.nan]))
+
+        return Series(array, index=index)
+
+    def _values_for_argsort(self):
+        # type: () -> ndarray
+        """Return values for sorting.
+
+        Returns
+        -------
+        ndarray
+            The transformed values should maintain the ordering between values
+            within the array.
+
+        See Also
+        --------
+        ExtensionArray.argsort
+        """
+        data = self.data.copy()
+        data[self.mask] = data.min() - 1
+        return data
+
+
+class UnsignedIntegerArray(IntegerArray):
+    pass
+
+
+module = sys.modules[__name__]
+
+
+# create the Dtype
+types = [(_integer_dtypes, IntegerDtype, _integer_formatter),
+         (_unsigned_dtypes, UnsignedIntegerDtype, _unsigned_formatter)]
+for dtypes, superclass, formatter in types:
+
+    for dtype in dtypes:
+
+        name = formatter(dtype)
+        classname = "{}Dtype".format(name)
+        attributes_dict = {'type': getattr(np, dtype),
+                           'name': name}
+        dtype_type = type(classname, (superclass, ), attributes_dict)
+        setattr(module, classname, dtype_type)
+
+
+# create the Array
+types = [(_integer_dtypes, IntegerArray, _integer_formatter),
+         (_unsigned_dtypes, UnsignedIntegerArray, _unsigned_formatter)]
+for dtypes, superclass, formatter in types:
+
+    for dtype in dtypes:
+
+        dtype_type = getattr(module, "{}Dtype".format(formatter(dtype)))
+        classname = "{}Array".format(formatter(dtype))
+        attributes_dict = {'dtype': dtype_type()}
+        array_type = type(classname, (superclass, ), attributes_dict)
+        setattr(module, classname, array_type)
+
+        # set the Array type on the Dtype
+        dtype_type.array_type = array_type
+
+
+def make_data():
+    return (list(range(8)) +
+            [np.nan] +
+            list(range(10, 98)) +
+            [np.nan] +
+            [99, 100])
diff --git a/pandas/core/dtypes/base.py b/pandas/core/dtypes/base.py
index 49e98c16c716e0..ba359c9ef49822 100644
--- a/pandas/core/dtypes/base.py
+++ b/pandas/core/dtypes/base.py
@@ -156,6 +156,12 @@ def name(self):
         """
         raise AbstractMethodError(self)
 
+    @property
+    def array_type(self):
+        """Return the array type associated with this dtype
+        """
+        raise AbstractMethodError(self)
+
     @classmethod
     def construct_from_string(cls, string):
         """Attempt to construct this type from a string.
diff --git a/pandas/core/dtypes/cast.py b/pandas/core/dtypes/cast.py
index e4ed6d544d42eb..73176887ca0d96 100644
--- a/pandas/core/dtypes/cast.py
+++ b/pandas/core/dtypes/cast.py
@@ -647,6 +647,11 @@ def conv(r, dtype):
 def astype_nansafe(arr, dtype, copy=True):
     """ return a view if copy is False, but
         need to be very careful as the result shape could change! """
+
+    # dispatch on extension dtype if needed
+    if is_extension_array_dtype(dtype):
+        return dtype.array_type._from_sequence(arr, copy=copy)
+
     if not isinstance(dtype, np.dtype):
         dtype = pandas_dtype(dtype)
 
diff --git a/pandas/core/internals.py b/pandas/core/internals.py
index e7b2576ca1eaef..b7881001f4f3c1 100644
--- a/pandas/core/internals.py
+++ b/pandas/core/internals.py
@@ -633,8 +633,9 @@ def _astype(self, dtype, copy=False, errors='raise', values=None,
             return self.make_block(Categorical(self.values, dtype=dtype))
 
         # astype processing
-        dtype = np.dtype(dtype)
-        if self.dtype == dtype:
+        if not is_extension_array_dtype(dtype):
+            dtype = np.dtype(dtype)
+        if is_dtype_equal(self.dtype, dtype):
             if copy:
                 return self.copy()
             return self
@@ -662,7 +663,7 @@ def _astype(self, dtype, copy=False, errors='raise', values=None,
 
                 # _astype_nansafe works fine with 1-d only
                 values = astype_nansafe(values.ravel(), dtype, copy=True)
-                values = values.reshape(self.shape)
+                values = _block_shape(values, ndim=self.ndim)
 
             newb = make_block(values, placement=self.mgr_locs,
                               klass=klass)
@@ -3170,6 +3171,10 @@ def get_block_type(values, dtype=None):
         cls = TimeDeltaBlock
     elif issubclass(vtype, np.complexfloating):
         cls = ComplexBlock
+    elif is_categorical(values):
+        cls = CategoricalBlock
+    elif is_extension_array_dtype(values):
+        cls = ExtensionBlock
     elif issubclass(vtype, np.datetime64):
         assert not is_datetimetz(values)
         cls = DatetimeBlock
@@ -3179,10 +3184,6 @@ def get_block_type(values, dtype=None):
         cls = IntBlock
     elif dtype == np.bool_:
         cls = BoolBlock
-    elif is_categorical(values):
-        cls = CategoricalBlock
-    elif is_extension_array_dtype(values):
-        cls = ExtensionBlock
     else:
         cls = ObjectBlock
     return cls
diff --git a/pandas/core/series.py b/pandas/core/series.py
index 0e5005ac562758..84acc4c76b858a 100644
--- a/pandas/core/series.py
+++ b/pandas/core/series.py
@@ -4054,12 +4054,9 @@ def _try_cast(arr, take_fast_path):
                 subarr = Categorical(arr, dtype.categories,
                                      ordered=dtype.ordered)
             elif is_extension_array_dtype(dtype):
-                # We don't allow casting to third party dtypes, since we don't
-                # know what array belongs to which type.
-                msg = ("Cannot cast data to extension dtype '{}'. "
-                       "Pass the extension array directly.".format(dtype))
-                raise ValueError(msg)
-
+                # create an extension array from its dtype
+                array_type = dtype.array_type
+                subarr = array_type(subarr, copy=copy)
 
             elif dtype is not None and raise_cast_failure:
                 raise
diff --git a/pandas/io/formats/format.py b/pandas/io/formats/format.py
index 12201f62946aca..adb4bf3f47572e 100644
--- a/pandas/io/formats/format.py
+++ b/pandas/io/formats/format.py
@@ -514,7 +514,6 @@ def _to_str_columns(self):
         Render a DataFrame to a list of columns (as lists of strings).
         """
         frame = self.tr_frame
-
         # may include levels names also
 
         str_index = self._get_formatted_index(frame)
diff --git a/pandas/tests/extension/base/methods.py b/pandas/tests/extension/base/methods.py
index c5436aa731d50e..0ad3196277c34f 100644
--- a/pandas/tests/extension/base/methods.py
+++ b/pandas/tests/extension/base/methods.py
@@ -19,7 +19,8 @@ def test_value_counts(self, all_data, dropna):
             other = all_data
 
         result = pd.Series(all_data).value_counts(dropna=dropna).sort_index()
-        expected = pd.Series(other).value_counts(dropna=dropna).sort_index()
+        expected = pd.Series(other).value_counts(
+            dropna=dropna).sort_index()
 
         self.assert_series_equal(result, expected)
 
diff --git a/pandas/tests/extension/base/reshaping.py b/pandas/tests/extension/base/reshaping.py
index fe920a47ab7409..ff739c97f2785d 100644
--- a/pandas/tests/extension/base/reshaping.py
+++ b/pandas/tests/extension/base/reshaping.py
@@ -26,6 +26,14 @@ def test_concat(self, data, in_frame):
         assert dtype == data.dtype
         assert isinstance(result._data.blocks[0], ExtensionBlock)
 
+    def test_append(self, data):
+
+        wrapped = pd.Series(data)
+        result = wrapped.append(wrapped)
+        expected = pd.concat([wrapped, wrapped])
+
+        self.assert_series_equal(result, expected)
+
     @pytest.mark.parametrize('in_frame', [True, False])
     def test_concat_all_na_block(self, data_missing, in_frame):
         valid_block = pd.Series(data_missing.take([1, 1]), index=[0, 1])
@@ -84,6 +92,7 @@ def test_concat_columns(self, data, na_value):
         expected = pd.DataFrame({
             'A': data._from_sequence(list(data[:3]) + [na_value]),
             'B': [np.nan, 1, 2, 3]})
+
         result = pd.concat([df1, df2], axis=1)
         self.assert_frame_equal(result, expected)
         result = pd.concat([df1['A'], df2['B']], axis=1)
diff --git a/pandas/tests/extension/decimal/array.py b/pandas/tests/extension/decimal/array.py
index e9431bd0c233cc..dc0108e3487156 100644
--- a/pandas/tests/extension/decimal/array.py
+++ b/pandas/tests/extension/decimal/array.py
@@ -101,5 +101,8 @@ def _concat_same_type(cls, to_concat):
         return cls(np.concatenate([x._data for x in to_concat]))
 
 
+DecimalDtype.array_type = DecimalArray
+
+
 def make_data():
     return [decimal.Decimal(random.random()) for _ in range(100)]
diff --git a/pandas/tests/extension/integer/__init__.py b/pandas/tests/extension/integer/__init__.py
new file mode 100644
index 00000000000000..e69de29bb2d1d6
diff --git a/pandas/tests/extension/integer/test_integer.py b/pandas/tests/extension/integer/test_integer.py
new file mode 100644
index 00000000000000..8328fac18d7d96
--- /dev/null
+++ b/pandas/tests/extension/integer/test_integer.py
@@ -0,0 +1,222 @@
+import numpy as np
+import pandas as pd
+import pandas.util.testing as tm
+import pytest
+
+from pandas.tests.extension import base
+
+from pandas.core.arrays.integer import (
+    Int8Dtype, Int16Dtype, Int32Dtype, Int64Dtype,
+    UInt8Dtype, UInt16Dtype, UInt32Dtype, UInt64Dtype,
+    Int8Array, Int16Array, Int32Array, Int64Array,
+    UInt8Array, UInt16Array, UInt32Array, UInt64Array,
+    make_data)
+
+
+@pytest.fixture(params=[Int8Dtype, Int16Dtype, Int32Dtype, Int64Dtype,
+                        UInt8Dtype, UInt16Dtype, UInt32Dtype, UInt64Dtype])
+def dtype(request):
+    return request.param()
+
+
+@pytest.fixture(params=[Int8Array, Int16Array, Int32Array, Int64Array,
+                        UInt8Array, UInt16Array, UInt32Array, UInt64Array])
+def arrays(request):
+    return request.param
+
+
+@pytest.fixture
+def data(arrays):
+    return arrays(make_data())
+
+
+@pytest.fixture
+def data_missing(arrays):
+    return arrays([np.nan, 1])
+
+
+@pytest.fixture
+def data_for_sorting(arrays):
+    return arrays([1, 2, 0])
+
+
+@pytest.fixture
+def data_missing_for_sorting(arrays):
+    return arrays([1, np.nan, 0])
+
+
+@pytest.fixture
+def na_cmp():
+    # we are np.nan
+    return lambda x, y: np.isnan(x) and np.isnan(y)
+
+
+@pytest.fixture
+def na_value():
+    return np.nan
+
+
+@pytest.fixture
+def data_for_grouping(arrays):
+    b = 1
+    a = 0
+    c = 2
+    na = np.nan
+    return arrays([b, b, na, na, a, a, b, c])
+
+
+def test_dtypes(dtype):
+    # smoke tests on auto dtype construction
+
+    if dtype.is_signed_integer:
+        assert np.dtype(dtype.type).kind == 'i'
+    else:
+        assert np.dtype(dtype.type).kind == 'u'
+    assert dtype.name is not None
+
+
+class BaseInteger(object):
+
+    def assert_series_equal(self, left, right, *args, **kwargs):
+
+        left_na = left.isna()
+        right_na = right.isna()
+
+        tm.assert_series_equal(left_na, right_na)
+        return tm.assert_series_equal(left[~left_na],
+                                      right[~right_na],
+                                      *args, **kwargs)
+
+    def assert_frame_equal(self, left, right, *args, **kwargs):
+        # TODO(EA): select_dtypes
+        tm.assert_index_equal(
+            left.columns, right.columns,
+            exact=kwargs.get('check_column_type', 'equiv'),
+            check_names=kwargs.get('check_names', True),
+            check_exact=kwargs.get('check_exact', False),
+            check_categorical=kwargs.get('check_categorical', True),
+            obj='{obj}.columns'.format(obj=kwargs.get('obj', 'DataFrame')))
+
+        integers = (left.dtypes == 'integer').index
+
+        for col in integers:
+            self.assert_series_equal(left[col], right[col],
+                                     *args, **kwargs)
+
+        left = left.drop(columns=integers)
+        right = right.drop(columns=integers)
+        tm.assert_frame_equal(left, right, *args, **kwargs)
+
+
+class TestDtype(BaseInteger, base.BaseDtypeTests):
+
+    @pytest.mark.skip(reason="using multiple dtypes")
+    def test_is_dtype_unboxes_dtype(self):
+        # we have multiple dtypes, so skip
+        pass
+
+
+class TestInterface(BaseInteger, base.BaseInterfaceTests):
+    pass
+
+
+class TestConstructors(BaseInteger, base.BaseConstructorsTests):
+    pass
+
+
+class TestReshaping(BaseInteger, base.BaseReshapingTests):
+
+    def test_concat_mixed_dtypes(self, data):
+        # https://github.com/pandas-dev/pandas/issues/20762
+        df1 = pd.DataFrame({'A': data[:3]})
+        df2 = pd.DataFrame({"A": [1, 2, 3]})
+        df3 = pd.DataFrame({"A": ['a', 'b', 'c']}).astype('category')
+        df4 = pd.DataFrame({"A": pd.SparseArray([1, 2, 3])})
+        dfs = [df1, df2, df3, df4]
+
+        # dataframes
+        result = pd.concat(dfs)
+        expected = pd.concat([x.astype(object) for x in dfs])
+        self.assert_frame_equal(result, expected)
+
+        # series
+        result = pd.concat([x['A'] for x in dfs])
+        expected = pd.concat([x['A'].astype(object) for x in dfs])
+        self.assert_series_equal(result, expected)
+
+        result = pd.concat([df1, df2])
+        expected = pd.concat([df1.astype('object'), df2.astype('object')])
+        self.assert_frame_equal(result, expected)
+
+        # concat of an Integer and Int coerces to object dtype
+        # TODO(jreback) once integrated this would
+        # be a result of Integer
+        result = pd.concat([df1['A'], df2['A']])
+        expected = pd.concat([df1['A'].astype('object'),
+                              df2['A'].astype('object')])
+        self.assert_series_equal(result, expected)
+
+
+class TestGetitem(BaseInteger, base.BaseGetitemTests):
+    pass
+
+
+class TestMissing(BaseInteger, base.BaseMissingTests):
+    pass
+
+
+class TestMethods(BaseInteger, base.BaseMethodsTests):
+
+    @pytest.mark.xfail(reason="need a Index type with ExtensionArrays")
+    @pytest.mark.parametrize('dropna', [True, False])
+    def test_value_counts(self, all_data, dropna):
+        all_data = all_data[:10]
+        if dropna:
+            other = np.array(all_data[~all_data.isna()])
+        else:
+            other = all_data
+
+        result = pd.Series(all_data).value_counts(dropna=dropna).sort_index()
+        expected = pd.Series(other).value_counts(
+            dropna=dropna).sort_index()
+
+        self.assert_series_equal(result, expected)
+
+
+class TestCasting(BaseInteger, base.BaseCastingTests):
+    pass
+
+
+class TestGroupby(BaseInteger, base.BaseGroupbyTests):
+    pass
+
+
+def test_frame_repr(data_missing):
+
+    df = pd.DataFrame({'A': data_missing})
+    result = repr(df)
+    expected = '     A\n0  NaN\n1    1'
+    assert result == expected
+
+
+def test_conversions(data_missing):
+
+    # astype to object series
+    df = pd.DataFrame({'A': data_missing})
+    result = df['A'].astype('object')
+    expected = pd.Series(np.array([np.nan, 1], dtype=object), name='A')
+    tm.assert_series_equal(result, expected)
+
+    # convert to object ndarray
+    # we assert that we are exactly equal
+    # including type conversions of scalars
+    result = df['A'].astype('object').values
+    expected = np.array([np.nan, 1], dtype=object)
+    tm.assert_numpy_array_equal(result, expected)
+
+    for r, e in zip(result, expected):
+        if pd.isnull(r):
+            assert pd.isnull(e)
+        else:
+            assert r == e
+            assert type(r) == type(e)
diff --git a/pandas/tests/extension/json/array.py b/pandas/tests/extension/json/array.py
index 88bb66f38b35c4..7e52081ae6274d 100644
--- a/pandas/tests/extension/json/array.py
+++ b/pandas/tests/extension/json/array.py
@@ -170,6 +170,9 @@ def _values_for_argsort(self):
         return np.array(frozen, dtype=object)[1:]
 
 
+JSONDtype.array_type = JSONArray
+
+
 def make_data():
     # TODO: Use a regular dict. See _NDFrameIndexer._setitem_with_indexer
     return [collections.UserDict([