diff --git a/pandas/computation/tests/test_eval.py b/pandas/computation/tests/test_eval.py
index 62e643b095c4d..143e6017b462a 100644
--- a/pandas/computation/tests/test_eval.py
+++ b/pandas/computation/tests/test_eval.py
@@ -607,7 +607,7 @@ def test_unary_in_array(self):
                     '-37, 37, ~37, +37]'),
             np.array([-True, True, ~True, +True,
                       -False, False, ~False, +False,
-                      -37, 37, ~37, +37]))
+                      -37, 37, ~37, +37], dtype=np.object_))
 
     def test_disallow_scalar_bool_ops(self):
         exprs = '1 or 2', '1 and 2'
diff --git a/pandas/core/common.py b/pandas/core/common.py
index d41d49c895599..c64cfa77b9e62 100644
--- a/pandas/core/common.py
+++ b/pandas/core/common.py
@@ -307,7 +307,8 @@ def array_equivalent(left, right, strict_nan=False):
         return False
 
     # Object arrays can contain None, NaN and NaT.
-    if is_object_dtype(left) or is_object_dtype(right):
+    # string dtypes must be come to this path for NumPy 1.7.1 compat
+    if is_string_dtype(left) or is_string_dtype(right):
 
         if not strict_nan:
             # pd.isnull considers NaN and None to be equivalent.
diff --git a/pandas/io/tests/json/test_pandas.py b/pandas/io/tests/json/test_pandas.py
index 9f41bbac03cbf..6fe559e5cacd8 100644
--- a/pandas/io/tests/json/test_pandas.py
+++ b/pandas/io/tests/json/test_pandas.py
@@ -139,7 +139,7 @@ def test_frame_from_json_to_json(self):
         def _check_orient(df, orient, dtype=None, numpy=False,
                           convert_axes=True, check_dtype=True, raise_ok=None,
                           sort=None, check_index_type=True,
-                          check_column_type=True):
+                          check_column_type=True, check_numpy_dtype=False):
             if sort is not None:
                 df = df.sort_values(sort)
             else:
@@ -181,14 +181,16 @@ def _check_orient(df, orient, dtype=None, numpy=False,
                     unser.index.values.astype('i8') * 1e6)
             if orient == "records":
                 # index is not captured in this orientation
-                assert_almost_equal(df.values, unser.values)
+                assert_almost_equal(df.values, unser.values,
+                                    check_dtype=check_numpy_dtype)
                 self.assertTrue(df.columns.equals(unser.columns))
             elif orient == "values":
                 # index and cols are not captured in this orientation
                 if numpy is True and df.shape == (0, 0):
                     assert unser.shape[0] == 0
                 else:
-                    assert_almost_equal(df.values, unser.values)
+                    assert_almost_equal(df.values, unser.values,
+                                        check_dtype=check_numpy_dtype)
             elif orient == "split":
                 # index and col labels might not be strings
                 unser.index = [str(i) for i in unser.index]
@@ -196,7 +198,8 @@ def _check_orient(df, orient, dtype=None, numpy=False,
 
                 if sort is None:
                     unser = unser.sort_index()
-                assert_almost_equal(df.values, unser.values)
+                assert_almost_equal(df.values, unser.values,
+                                    check_dtype=check_numpy_dtype)
             else:
                 if convert_axes:
                     assert_frame_equal(df, unser, check_dtype=check_dtype,
diff --git a/pandas/sparse/tests/test_array.py b/pandas/sparse/tests/test_array.py
index 345715ee0528d..26d018c56a8a8 100644
--- a/pandas/sparse/tests/test_array.py
+++ b/pandas/sparse/tests/test_array.py
@@ -272,7 +272,8 @@ def test_constructor_bool(self):
         self.assertEqual(arr.dtype, bool)
         tm.assert_numpy_array_equal(arr.sp_values, np.array([True, True]))
         tm.assert_numpy_array_equal(arr.sp_values, np.asarray(arr))
-        tm.assert_numpy_array_equal(arr.sp_index.indices, np.array([2, 3]))
+        tm.assert_numpy_array_equal(arr.sp_index.indices,
+                                    np.array([2, 3], np.int32))
 
         for dense in [arr.to_dense(), arr.values]:
             self.assertEqual(dense.dtype, bool)
@@ -297,9 +298,11 @@ def test_constructor_float32(self):
         arr = SparseArray(data, dtype=np.float32)
 
         self.assertEqual(arr.dtype, np.float32)
-        tm.assert_numpy_array_equal(arr.sp_values, np.array([1, 3]))
+        tm.assert_numpy_array_equal(arr.sp_values,
+                                    np.array([1, 3], dtype=np.float32))
         tm.assert_numpy_array_equal(arr.sp_values, np.asarray(arr))
-        tm.assert_numpy_array_equal(arr.sp_index.indices, np.array([0, 2]))
+        tm.assert_numpy_array_equal(arr.sp_index.indices,
+                                    np.array([0, 2], dtype=np.int32))
 
         for dense in [arr.to_dense(), arr.values]:
             self.assertEqual(dense.dtype, np.float32)
@@ -516,7 +519,7 @@ def test_fillna_overlap(self):
         # filling with existing value doesn't replace existing value with
         # fill_value, i.e. existing 3 remains in sp_values
         res = s.fillna(3)
-        exp = np.array([1, 3, 3, 3, 3])
+        exp = np.array([1, 3, 3, 3, 3], dtype=np.float64)
         tm.assert_numpy_array_equal(res.to_dense(), exp)
 
         s = SparseArray([1, np.nan, np.nan, 3, np.nan], fill_value=0)
diff --git a/pandas/src/testing.pyx b/pandas/src/testing.pyx
index 9839c9f416160..9f102ded597fd 100644
--- a/pandas/src/testing.pyx
+++ b/pandas/src/testing.pyx
@@ -1,7 +1,7 @@
 import numpy as np
 
 from pandas import compat
-from pandas.core.common import isnull, array_equivalent
+from pandas.core.common import isnull, array_equivalent, is_dtype_equal
 
 cdef NUMERIC_TYPES = (
     bool,
@@ -55,7 +55,7 @@ cpdef assert_dict_equal(a, b, bint compare_keys=True):
 
     return True
 
-cpdef assert_almost_equal(a, b, bint check_less_precise=False,
+cpdef assert_almost_equal(a, b, bint check_less_precise=False, check_dtype=True,
                           obj=None, lobj=None, robj=None):
     """Check that left and right objects are almost equal.
 
@@ -66,6 +66,8 @@ cpdef assert_almost_equal(a, b, bint check_less_precise=False,
     check_less_precise : bool, default False
         Specify comparison precision.
         5 digits (False) or 3 digits (True) after decimal points are compared.
+    check_dtype: bool, default True
+        check dtype if both a and b are np.ndarray
     obj : str, default None
         Specify object name being compared, internally used to show appropriate
         assertion message
@@ -82,7 +84,7 @@ cpdef assert_almost_equal(a, b, bint check_less_precise=False,
         double diff = 0.0
         Py_ssize_t i, na, nb
         double fa, fb
-        bint is_unequal = False
+        bint is_unequal = False, a_is_ndarray, b_is_ndarray
 
     if lobj is None:
         lobj = a
@@ -97,36 +99,43 @@ cpdef assert_almost_equal(a, b, bint check_less_precise=False,
         assert a == b, "%r != %r" % (a, b)
         return True
 
+    a_is_ndarray = isinstance(a, np.ndarray)
+    b_is_ndarray = isinstance(b, np.ndarray)
+
+    if obj is None:
+        if a_is_ndarray or b_is_ndarray:
+            obj = 'numpy array'
+        else:
+            obj = 'Iterable'
+
     if isiterable(a):
 
         if not isiterable(b):
-            from pandas.util.testing import raise_assert_detail
-            if obj is None:
-                obj = 'Iterable'
-            msg = "First object is iterable, second isn't"
-            raise_assert_detail(obj, msg, a, b)
+            from pandas.util.testing import assert_class_equal
+            # classes can't be the same, to raise error
+            assert_class_equal(a, b, obj=obj)
 
         assert has_length(a) and has_length(b), (
             "Can't compare objects without length, one or both is invalid: "
-            "(%r, %r)" % (a, b)
-        )
+            "(%r, %r)" % (a, b))
 
-        if isinstance(a, np.ndarray) and isinstance(b, np.ndarray):
-            if obj is None:
-                obj = 'numpy array'
+        if a_is_ndarray and b_is_ndarray:
             na, nb = a.size, b.size
             if a.shape != b.shape:
                 from pandas.util.testing import raise_assert_detail
                 raise_assert_detail(obj, '{0} shapes are different'.format(obj),
                                     a.shape, b.shape)
+
+            if check_dtype and not is_dtype_equal(a, b):
+                from pandas.util.testing import assert_attr_equal
+                assert_attr_equal('dtype', a, b, obj=obj)
+
             try:
                 if array_equivalent(a, b, strict_nan=True):
                     return True
             except:
                 pass
         else:
-            if obj is None:
-                obj = 'Iterable'
             na, nb = len(a), len(b)
 
         if na != nb:
@@ -149,27 +158,20 @@ cpdef assert_almost_equal(a, b, bint check_less_precise=False,
         return True
 
     elif isiterable(b):
-        from pandas.util.testing import raise_assert_detail
-        if obj is None:
-            obj = 'Iterable'
-        msg = "Second object is iterable, first isn't"
-        raise_assert_detail(obj, msg, a, b)
+        from pandas.util.testing import assert_class_equal
+        # classes can't be the same, to raise error
+        assert_class_equal(a, b, obj=obj)
 
-    if isnull(a):
-        assert isnull(b), (
-            "First object is null, second isn't: %r != %r" % (a, b)
-        )
+    if a == b:
+        # object comparison
         return True
-    elif isnull(b):
-        assert isnull(a), (
-            "First object is not null, second is null: %r != %r" % (a, b)
-        )
+    if isnull(a) and isnull(b):
+        # nan / None comparison
         return True
-
-    if is_comparable_as_number(a):
-        assert is_comparable_as_number(b), (
-            "First object is numeric, second is not: %r != %r" % (a, b)
-        )
+    if is_comparable_as_number(a) and is_comparable_as_number(b):
+        if array_equivalent(a, b, strict_nan=True):
+            # inf comparison
+            return True
 
         decimal = 5
 
@@ -177,26 +179,17 @@ cpdef assert_almost_equal(a, b, bint check_less_precise=False,
         if check_less_precise:
             decimal = 3
 
-        if np.isinf(a):
-            assert np.isinf(b), "First object is inf, second isn't"
-            if np.isposinf(a):
-                assert np.isposinf(b), "First object is positive inf, second is negative inf"
-            else:
-                assert np.isneginf(b), "First object is negative inf, second is positive inf"
+        fa, fb = a, b
+
+        # case for zero
+        if abs(fa) < 1e-5:
+            if not decimal_almost_equal(fa, fb, decimal):
+                assert False, (
+                    '(very low values) expected %.5f but got %.5f, with decimal %d' % (fb, fa, decimal)
+                )
         else:
-            fa, fb = a, b
-
-            # case for zero
-            if abs(fa) < 1e-5:
-                if not decimal_almost_equal(fa, fb, decimal):
-                    assert False, (
-                        '(very low values) expected %.5f but got %.5f, with decimal %d' % (fb, fa, decimal)
-                    )
-            else:
-                if not decimal_almost_equal(1, fb / fa, decimal):
-                    assert False, 'expected %.5f but got %.5f, with decimal %d' % (fb, fa, decimal)
-
-    else:
-        assert a == b, "%r != %r" % (a, b)
+            if not decimal_almost_equal(1, fb / fa, decimal):
+                assert False, 'expected %.5f but got %.5f, with decimal %d' % (fb, fa, decimal)
+        return True
 
-    return True
+    raise AssertionError("{0} != {1}".format(a, b))
diff --git a/pandas/tests/frame/test_indexing.py b/pandas/tests/frame/test_indexing.py
index a6e46b7d0c756..1e3940dc8f038 100644
--- a/pandas/tests/frame/test_indexing.py
+++ b/pandas/tests/frame/test_indexing.py
@@ -1430,8 +1430,8 @@ def test_setitem_frame(self):
 
         # already aligned
         f = self.mixed_frame.copy()
-        piece = DataFrame([[1, 2], [3, 4]], index=f.index[
-                          0:2], columns=['A', 'B'])
+        piece = DataFrame([[1., 2.], [3., 4.]],
+                          index=f.index[0:2], columns=['A', 'B'])
         key = (slice(None, 2), ['A', 'B'])
         f.ix[key] = piece
         assert_almost_equal(f.ix[0:2, ['A', 'B']].values,
@@ -1439,8 +1439,9 @@ def test_setitem_frame(self):
 
         # rows unaligned
         f = self.mixed_frame.copy()
-        piece = DataFrame([[1, 2], [3, 4], [5, 6], [7, 8]], index=list(
-            f.index[0:2]) + ['foo', 'bar'], columns=['A', 'B'])
+        piece = DataFrame([[1., 2.], [3., 4.], [5., 6.], [7., 8.]],
+                          index=list(f.index[0:2]) + ['foo', 'bar'],
+                          columns=['A', 'B'])
         key = (slice(None, 2), ['A', 'B'])
         f.ix[key] = piece
         assert_almost_equal(f.ix[0:2:, ['A', 'B']].values,
diff --git a/pandas/tests/indexes/common.py b/pandas/tests/indexes/common.py
index f1e2724e628bf..8ea87e9d69c92 100644
--- a/pandas/tests/indexes/common.py
+++ b/pandas/tests/indexes/common.py
@@ -274,7 +274,7 @@ def test_argsort(self):
 
             result = ind.argsort()
             expected = np.array(ind).argsort()
-            tm.assert_numpy_array_equal(result, expected)
+            tm.assert_numpy_array_equal(result, expected, check_dtype=False)
 
     def test_numpy_argsort(self):
         for k, ind in self.indices.items():
diff --git a/pandas/tests/indexes/test_category.py b/pandas/tests/indexes/test_category.py
index 1d8a52e48e468..66ddcdebff83b 100644
--- a/pandas/tests/indexes/test_category.py
+++ b/pandas/tests/indexes/test_category.py
@@ -216,13 +216,15 @@ def test_map(self):
                              ordered=False)
         tm.assert_categorical_equal(result, exp)
 
-        tm.assert_numpy_array_equal(ci.map(lambda x: 1), np.array([1] * 5))
+        tm.assert_numpy_array_equal(ci.map(lambda x: 1),
+                                    np.array([1] * 5, dtype=np.int64))
 
         # change categories dtype
         ci = pd.CategoricalIndex(list('ABABC'), categories=list('BAC'),
                                  ordered=False)
         def f(x):
             return {'A': 10, 'B': 20, 'C': 30}.get(x)
+
         result = ci.map(f)
         exp = pd.Categorical([10, 20, 10, 20, 30], categories=[20, 10, 30],
                              ordered=False)
@@ -340,30 +342,35 @@ def test_reindexing(self):
             tm.assert_numpy_array_equal(expected, actual)
 
     def test_reindex_dtype(self):
-        res, indexer = CategoricalIndex(['a', 'b', 'c', 'a']).reindex(['a', 'c'
-                                                                       ])
+        c = CategoricalIndex(['a', 'b', 'c', 'a'])
+        res, indexer = c.reindex(['a', 'c'])
         tm.assert_index_equal(res, Index(['a', 'a', 'c']), exact=True)
-        tm.assert_numpy_array_equal(indexer, np.array([0, 3, 2]))
-
-        res, indexer = CategoricalIndex(['a', 'b', 'c', 'a']).reindex(
-            Categorical(['a', 'c']))
-        tm.assert_index_equal(res, CategoricalIndex(
-            ['a', 'a', 'c'], categories=['a', 'c']), exact=True)
-        tm.assert_numpy_array_equal(indexer, np.array([0, 3, 2]))
-
-        res, indexer = CategoricalIndex(
-            ['a', 'b', 'c', 'a'
-             ], categories=['a', 'b', 'c', 'd']).reindex(['a', 'c'])
-        tm.assert_index_equal(res, Index(
-            ['a', 'a', 'c'], dtype='object'), exact=True)
-        tm.assert_numpy_array_equal(indexer, np.array([0, 3, 2]))
-
-        res, indexer = CategoricalIndex(
-            ['a', 'b', 'c', 'a'],
-            categories=['a', 'b', 'c', 'd']).reindex(Categorical(['a', 'c']))
-        tm.assert_index_equal(res, CategoricalIndex(
-            ['a', 'a', 'c'], categories=['a', 'c']), exact=True)
-        tm.assert_numpy_array_equal(indexer, np.array([0, 3, 2]))
+        tm.assert_numpy_array_equal(indexer,
+                                    np.array([0, 3, 2], dtype=np.int64))
+
+        c = CategoricalIndex(['a', 'b', 'c', 'a'])
+        res, indexer = c.reindex(Categorical(['a', 'c']))
+
+        exp = CategoricalIndex(['a', 'a', 'c'], categories=['a', 'c'])
+        tm.assert_index_equal(res, exp, exact=True)
+        tm.assert_numpy_array_equal(indexer,
+                                    np.array([0, 3, 2], dtype=np.int64))
+
+        c = CategoricalIndex(['a', 'b', 'c', 'a'],
+                             categories=['a', 'b', 'c', 'd'])
+        res, indexer = c.reindex(['a', 'c'])
+        exp = Index(['a', 'a', 'c'], dtype='object')
+        tm.assert_index_equal(res, exp, exact=True)
+        tm.assert_numpy_array_equal(indexer,
+                                    np.array([0, 3, 2], dtype=np.int64))
+
+        c = CategoricalIndex(['a', 'b', 'c', 'a'],
+                             categories=['a', 'b', 'c', 'd'])
+        res, indexer = c.reindex(Categorical(['a', 'c']))
+        exp = CategoricalIndex(['a', 'a', 'c'], categories=['a', 'c'])
+        tm.assert_index_equal(res, exp, exact=True)
+        tm.assert_numpy_array_equal(indexer,
+                                    np.array([0, 3, 2], dtype=np.int64))
 
     def test_duplicates(self):
 
diff --git a/pandas/tests/indexes/test_multi.py b/pandas/tests/indexes/test_multi.py
index 46180a823c002..b8804daa6cf19 100644
--- a/pandas/tests/indexes/test_multi.py
+++ b/pandas/tests/indexes/test_multi.py
@@ -147,8 +147,8 @@ def assert_matching(actual, expected):
             self.assertEqual(len(actual), len(expected))
             for act, exp in zip(actual, expected):
                 act = np.asarray(act)
-                exp = np.asarray(exp)
-                assert_almost_equal(act, exp)
+                exp = np.asarray(exp, dtype=np.object_)
+                tm.assert_numpy_array_equal(act, exp)
 
         # level changing [w/o mutation]
         ind2 = self.index.set_levels(new_levels)
@@ -211,8 +211,8 @@ def assert_matching(actual, expected):
             self.assertEqual(len(actual), len(expected))
             for act, exp in zip(actual, expected):
                 act = np.asarray(act)
-                exp = np.asarray(exp)
-                assert_almost_equal(act, exp)
+                exp = np.asarray(exp, dtype=np.int8)
+                tm.assert_numpy_array_equal(act, exp)
 
         # label changing [w/o mutation]
         ind2 = self.index.set_labels(new_labels)
@@ -1699,8 +1699,8 @@ def test_join_multi(self):
         jidx, lidx, ridx = midx.join(idx, how='inner', return_indexers=True)
         exp_idx = pd.MultiIndex.from_product(
             [np.arange(4), [1, 2]], names=['a', 'b'])
-        exp_lidx = np.array([1, 2, 5, 6, 9, 10, 13, 14])
-        exp_ridx = np.array([0, 1, 0, 1, 0, 1, 0, 1])
+        exp_lidx = np.array([1, 2, 5, 6, 9, 10, 13, 14], dtype=np.int_)
+        exp_ridx = np.array([0, 1, 0, 1, 0, 1, 0, 1], dtype=np.int64)
         self.assert_index_equal(jidx, exp_idx)
         self.assert_numpy_array_equal(lidx, exp_lidx)
         self.assert_numpy_array_equal(ridx, exp_ridx)
@@ -1713,7 +1713,7 @@ def test_join_multi(self):
         # keep MultiIndex
         jidx, lidx, ridx = midx.join(idx, how='left', return_indexers=True)
         exp_ridx = np.array([-1, 0, 1, -1, -1, 0, 1, -1, -1, 0, 1, -1, -1, 0,
-                             1, -1])
+                             1, -1], dtype=np.int64)
         self.assert_index_equal(jidx, midx)
         self.assertIsNone(lidx)
         self.assert_numpy_array_equal(ridx, exp_ridx)
@@ -1743,11 +1743,11 @@ def test_reindex_level(self):
         exp_index2 = self.index.join(idx, level='second', how='left')
 
         self.assertTrue(target.equals(exp_index))
-        exp_indexer = np.array([0, 2, 4])
+        exp_indexer = np.array([0, 2, 4], dtype=np.int64)
         tm.assert_numpy_array_equal(indexer, exp_indexer)
 
         self.assertTrue(target2.equals(exp_index2))
-        exp_indexer2 = np.array([0, -1, 0, -1, 0, -1])
+        exp_indexer2 = np.array([0, -1, 0, -1, 0, -1], dtype=np.int64)
         tm.assert_numpy_array_equal(indexer2, exp_indexer2)
 
         assertRaisesRegexp(TypeError, "Fill method not supported",
diff --git a/pandas/tests/indexes/test_numeric.py b/pandas/tests/indexes/test_numeric.py
index 06923e364bc63..8592ae1741a4e 100644
--- a/pandas/tests/indexes/test_numeric.py
+++ b/pandas/tests/indexes/test_numeric.py
@@ -580,9 +580,9 @@ def test_join_outer(self):
 
         eres = Int64Index([0, 1, 2, 4, 5, 6, 7, 8, 10, 12, 14, 16, 18, 25])
         elidx = np.array([0, -1, 1, 2, -1, 3, -1, 4, 5, 6, 7, 8, 9, -1],
-                         dtype=np.int64)
+                         dtype=np.int_)
         eridx = np.array([-1, 3, 4, -1, 5, -1, 0, -1, -1, 1, -1, -1, -1, 2],
-                         dtype=np.int64)
+                         dtype=np.int_)
 
         tm.assertIsInstance(res, Int64Index)
         self.assertTrue(res.equals(eres))
@@ -595,6 +595,8 @@ def test_join_outer(self):
         noidx_res = self.index.join(other_mono, how='outer')
         self.assertTrue(res.equals(noidx_res))
 
+        elidx = np.array([0, -1, 1, 2, -1, 3, -1, 4, 5, 6, 7, 8, 9, -1],
+                         dtype=np.int64)
         eridx = np.array([-1, 0, 1, -1, 2, -1, 3, -1, -1, 4, -1, -1, -1, 5],
                          dtype=np.int64)
         tm.assertIsInstance(res, Int64Index)
@@ -617,8 +619,8 @@ def test_join_inner(self):
         ridx = ridx.take(ind)
 
         eres = Int64Index([2, 12])
-        elidx = np.array([1, 6])
-        eridx = np.array([4, 1])
+        elidx = np.array([1, 6], dtype=np.int_)
+        eridx = np.array([4, 1], dtype=np.int_)
 
         tm.assertIsInstance(res, Int64Index)
         self.assertTrue(res.equals(eres))
@@ -632,7 +634,8 @@ def test_join_inner(self):
         res2 = self.index.intersection(other_mono)
         self.assertTrue(res.equals(res2))
 
-        eridx = np.array([1, 4])
+        elidx = np.array([1, 6], dtype=np.int64)
+        eridx = np.array([1, 4], dtype=np.int64)
         tm.assertIsInstance(res, Int64Index)
         self.assertTrue(res.equals(eres))
         tm.assert_numpy_array_equal(lidx, elidx)
@@ -647,7 +650,7 @@ def test_join_left(self):
                                           return_indexers=True)
         eres = self.index
         eridx = np.array([-1, 4, -1, -1, -1, -1, 1, -1, -1, -1],
-                         dtype=np.int64)
+                         dtype=np.int_)
 
         tm.assertIsInstance(res, Int64Index)
         self.assertTrue(res.equals(eres))
@@ -669,8 +672,8 @@ def test_join_left(self):
         idx2 = Index([1, 2, 5, 7, 9])
         res, lidx, ridx = idx2.join(idx, how='left', return_indexers=True)
         eres = Index([1, 1, 2, 5, 7, 9])  # 1 is in idx2, so it should be x2
-        eridx = np.array([0, 1, 2, 3, -1, -1])
-        elidx = np.array([0, 0, 1, 2, 3, 4])
+        eridx = np.array([0, 1, 2, 3, -1, -1], dtype=np.int64)
+        elidx = np.array([0, 0, 1, 2, 3, 4], dtype=np.int64)
         self.assertTrue(res.equals(eres))
         tm.assert_numpy_array_equal(lidx, elidx)
         tm.assert_numpy_array_equal(ridx, eridx)
@@ -683,7 +686,7 @@ def test_join_right(self):
         res, lidx, ridx = self.index.join(other, how='right',
                                           return_indexers=True)
         eres = other
-        elidx = np.array([-1, 6, -1, -1, 1, -1], dtype=np.int64)
+        elidx = np.array([-1, 6, -1, -1, 1, -1], dtype=np.int_)
 
         tm.assertIsInstance(other, Int64Index)
         self.assertTrue(res.equals(eres))
@@ -705,8 +708,8 @@ def test_join_right(self):
         idx2 = Index([1, 2, 5, 7, 9])
         res, lidx, ridx = idx.join(idx2, how='right', return_indexers=True)
         eres = Index([1, 1, 2, 5, 7, 9])  # 1 is in idx2, so it should be x2
-        elidx = np.array([0, 1, 2, 3, -1, -1])
-        eridx = np.array([0, 0, 1, 2, 3, 4])
+        elidx = np.array([0, 1, 2, 3, -1, -1], dtype=np.int64)
+        eridx = np.array([0, 0, 1, 2, 3, 4], dtype=np.int64)
         self.assertTrue(res.equals(eres))
         tm.assert_numpy_array_equal(lidx, elidx)
         tm.assert_numpy_array_equal(ridx, eridx)
@@ -747,10 +750,10 @@ def test_join_non_unique(self):
         exp_joined = Index([3, 3, 3, 3, 4, 4, 4, 4])
         self.assertTrue(joined.equals(exp_joined))
 
-        exp_lidx = np.array([2, 2, 3, 3, 0, 0, 1, 1], dtype=np.int64)
+        exp_lidx = np.array([2, 2, 3, 3, 0, 0, 1, 1], dtype=np.int_)
         tm.assert_numpy_array_equal(lidx, exp_lidx)
 
-        exp_ridx = np.array([2, 3, 2, 3, 0, 1, 0, 1], dtype=np.int64)
+        exp_ridx = np.array([2, 3, 2, 3, 0, 1, 0, 1], dtype=np.int_)
         tm.assert_numpy_array_equal(ridx, exp_ridx)
 
     def test_join_self(self):
diff --git a/pandas/tests/indexes/test_range.py b/pandas/tests/indexes/test_range.py
index f41c252f44d39..8b04b510146d2 100644
--- a/pandas/tests/indexes/test_range.py
+++ b/pandas/tests/indexes/test_range.py
@@ -381,9 +381,9 @@ def test_join_outer(self):
         eres = Int64Index([0, 2, 4, 6, 8, 10, 12, 14, 15, 16, 17, 18, 19, 20,
                            21, 22, 23, 24, 25])
         elidx = np.array([0, 1, 2, 3, 4, 5, 6, 7, -1, 8, -1, 9,
-                          -1, -1, -1, -1, -1, -1, -1], dtype=np.int64)
+                          -1, -1, -1, -1, -1, -1, -1], dtype=np.int_)
         eridx = np.array([-1, -1, -1, -1, -1, -1, -1, -1, 10, 9, 8, 7, 6,
-                          5, 4, 3, 2, 1, 0], dtype=np.int64)
+                          5, 4, 3, 2, 1, 0], dtype=np.int_)
 
         self.assertIsInstance(res, Int64Index)
         self.assertFalse(isinstance(res, RangeIndex))
@@ -445,8 +445,7 @@ def test_join_left(self):
         res, lidx, ridx = self.index.join(other, how='left',
                                           return_indexers=True)
         eres = self.index
-        eridx = np.array([-1, -1, -1, -1, -1, -1, -1, -1, 9, 7],
-                         dtype=np.int64)
+        eridx = np.array([-1, -1, -1, -1, -1, -1, -1, -1, 9, 7], dtype=np.int_)
 
         self.assertIsInstance(res, RangeIndex)
         self.assertTrue(res.equals(eres))
@@ -472,7 +471,7 @@ def test_join_right(self):
                                           return_indexers=True)
         eres = other
         elidx = np.array([-1, -1, -1, -1, -1, -1, -1, 9, -1, 8, -1],
-                         dtype=np.int64)
+                         dtype=np.int_)
 
         self.assertIsInstance(other, Int64Index)
         self.assertTrue(res.equals(eres))
@@ -525,9 +524,9 @@ def test_join_non_unique(self):
         res, lidx, ridx = self.index.join(other, return_indexers=True)
 
         eres = Int64Index([0, 2, 4, 4, 6, 8, 10, 12, 14, 16, 18])
-        elidx = np.array([0, 1, 2, 2, 3, 4, 5, 6, 7, 8, 9], dtype=np.int64)
+        elidx = np.array([0, 1, 2, 2, 3, 4, 5, 6, 7, 8, 9], dtype=np.int_)
         eridx = np.array([-1, -1, 0, 1, -1, -1, -1, -1, -1, -1, -1],
-                         dtype=np.int64)
+                         dtype=np.int_)
 
         self.assertTrue(res.equals(eres))
         self.assert_numpy_array_equal(lidx, elidx)
diff --git a/pandas/tests/series/test_alter_axes.py b/pandas/tests/series/test_alter_axes.py
index e1ae923c5c866..574dcd54933ae 100644
--- a/pandas/tests/series/test_alter_axes.py
+++ b/pandas/tests/series/test_alter_axes.py
@@ -77,8 +77,9 @@ def test_rename_set_name_inplace(self):
         for name in ['foo', 123, 123., datetime(2001, 11, 11), ('foo',)]:
             s.rename(name, inplace=True)
             self.assertEqual(s.name, name)
-            self.assert_numpy_array_equal(s.index.values,
-                                          np.array(['a', 'b', 'c']))
+
+            exp = np.array(['a', 'b', 'c'], dtype=np.object_)
+            self.assert_numpy_array_equal(s.index.values, exp)
 
     def test_set_name_attribute(self):
         s = Series([1, 2, 3])
diff --git a/pandas/tests/series/test_analytics.py b/pandas/tests/series/test_analytics.py
index dd109d8031079..002b7fa3aa8df 100644
--- a/pandas/tests/series/test_analytics.py
+++ b/pandas/tests/series/test_analytics.py
@@ -1358,13 +1358,13 @@ def test_searchsorted_numeric_dtypes_scalar(self):
         tm.assert_equal(r, e)
 
         r = s.searchsorted([30])
-        e = np.array([2])
+        e = np.array([2], dtype=np.int64)
         tm.assert_numpy_array_equal(r, e)
 
     def test_searchsorted_numeric_dtypes_vector(self):
         s = Series([1, 2, 90, 1000, 3e9])
         r = s.searchsorted([91, 2e6])
-        e = np.array([3, 4])
+        e = np.array([3, 4], dtype=np.int64)
         tm.assert_numpy_array_equal(r, e)
 
     def test_search_sorted_datetime64_scalar(self):
@@ -1378,14 +1378,14 @@ def test_search_sorted_datetime64_list(self):
         s = Series(pd.date_range('20120101', periods=10, freq='2D'))
         v = [pd.Timestamp('20120102'), pd.Timestamp('20120104')]
         r = s.searchsorted(v)
-        e = np.array([1, 2])
+        e = np.array([1, 2], dtype=np.int64)
         tm.assert_numpy_array_equal(r, e)
 
     def test_searchsorted_sorter(self):
         # GH8490
         s = Series([3, 1, 2])
         r = s.searchsorted([0, 3], sorter=np.argsort(s))
-        e = np.array([0, 2])
+        e = np.array([0, 2], dtype=np.int64)
         tm.assert_numpy_array_equal(r, e)
 
     def test_is_unique(self):
diff --git a/pandas/tests/series/test_datetime_values.py b/pandas/tests/series/test_datetime_values.py
index 90ee834aaf9c2..5b12baf6c6fc5 100644
--- a/pandas/tests/series/test_datetime_values.py
+++ b/pandas/tests/series/test_datetime_values.py
@@ -316,16 +316,18 @@ def test_strftime(self):
 
         datetime_index = date_range('20150301', periods=5)
         result = datetime_index.strftime("%Y/%m/%d")
-        expected = np.array(
-            ['2015/03/01', '2015/03/02', '2015/03/03', '2015/03/04',
-             '2015/03/05'], dtype=object)
-        self.assert_numpy_array_equal(result, expected)
+
+        expected = np.array(['2015/03/01', '2015/03/02', '2015/03/03',
+                             '2015/03/04', '2015/03/05'], dtype=np.object_)
+        # dtype may be S10 or U10 depending on python version
+        print(result)
+        print(expected)
+        self.assert_numpy_array_equal(result, expected, check_dtype=False)
 
         period_index = period_range('20150301', periods=5)
         result = period_index.strftime("%Y/%m/%d")
-        expected = np.array(
-            ['2015/03/01', '2015/03/02', '2015/03/03', '2015/03/04',
-             '2015/03/05'], dtype=object)
+        expected = np.array(['2015/03/01', '2015/03/02', '2015/03/03',
+                             '2015/03/04', '2015/03/05'], dtype='<U10')
         self.assert_numpy_array_equal(result, expected)
 
         s = Series([datetime(2013, 1, 1, 2, 32, 59), datetime(2013, 1, 2, 14,
@@ -341,9 +343,10 @@ def test_strftime(self):
 
         s = Series(period_range('20130101', periods=4, freq='L'))
         result = s.dt.strftime('%Y/%m/%d %H:%M:%S.%l')
-        expected = Series(
-            ["2013/01/01 00:00:00.000", "2013/01/01 00:00:00.001",
-             "2013/01/01 00:00:00.002", "2013/01/01 00:00:00.003"])
+        expected = Series(["2013/01/01 00:00:00.000",
+                           "2013/01/01 00:00:00.001",
+                           "2013/01/01 00:00:00.002",
+                           "2013/01/01 00:00:00.003"])
         tm.assert_series_equal(result, expected)
 
     def test_valid_dt_with_missing_values(self):
diff --git a/pandas/tests/series/test_dtypes.py b/pandas/tests/series/test_dtypes.py
index 502953034ae2d..fc963d4597246 100644
--- a/pandas/tests/series/test_dtypes.py
+++ b/pandas/tests/series/test_dtypes.py
@@ -134,14 +134,13 @@ def test_astype_unicode(self):
             sys.setdefaultencoding(former_encoding)
 
     def test_complexx(self):
-
         # GH4819
         # complex access for ndarray compat
-        a = np.arange(5)
+        a = np.arange(5, dtype=np.float64)
         b = Series(a + 4j * a)
-        tm.assert_almost_equal(a, b.real)
-        tm.assert_almost_equal(4 * a, b.imag)
+        tm.assert_numpy_array_equal(a, b.real)
+        tm.assert_numpy_array_equal(4 * a, b.imag)
 
         b.real = np.arange(5) + 5
-        tm.assert_almost_equal(a + 5, b.real)
-        tm.assert_almost_equal(4 * a, b.imag)
+        tm.assert_numpy_array_equal(a + 5, b.real)
+        tm.assert_numpy_array_equal(4 * a, b.imag)
diff --git a/pandas/tests/test_algos.py b/pandas/tests/test_algos.py
index 1c0316a97a4af..917f108711d09 100644
--- a/pandas/tests/test_algos.py
+++ b/pandas/tests/test_algos.py
@@ -22,7 +22,7 @@ def test_ints(self):
         to_match = np.array([0, 1, 2, 2, 0, 1, 3, 0])
 
         result = algos.match(to_match, values)
-        expected = np.array([0, 2, 1, 1, 0, 2, -1, 0])
+        expected = np.array([0, 2, 1, 1, 0, 2, -1, 0], dtype=np.int64)
         self.assert_numpy_array_equal(result, expected)
 
         result = Series(algos.match(to_match, values, np.nan))
@@ -31,7 +31,7 @@ def test_ints(self):
 
         s = pd.Series(np.arange(5), dtype=np.float32)
         result = algos.match(s, [2, 4])
-        expected = np.array([-1, -1, 0, -1, 1])
+        expected = np.array([-1, -1, 0, -1, 1], dtype=np.int64)
         self.assert_numpy_array_equal(result, expected)
 
         result = Series(algos.match(s, [2, 4], np.nan))
@@ -43,7 +43,7 @@ def test_strings(self):
         to_match = ['bar', 'foo', 'qux', 'foo', 'bar', 'baz', 'qux']
 
         result = algos.match(to_match, values)
-        expected = np.array([1, 0, -1, 0, 1, 2, -1])
+        expected = np.array([1, 0, -1, 0, 1, 2, -1], dtype=np.int64)
         self.assert_numpy_array_equal(result, expected)
 
         result = Series(algos.match(to_match, values, np.nan))
@@ -63,35 +63,36 @@ def test_basic(self):
 
         labels, uniques = algos.factorize(['a', 'b', 'b', 'a',
                                            'a', 'c', 'c', 'c'], sort=True)
-        self.assert_numpy_array_equal(labels, np.array(
-            [0, 1, 1, 0, 0, 2, 2, 2], dtype=np.int64))
-        self.assert_numpy_array_equal(uniques, np.array(
-            ['a', 'b', 'c'], dtype=object))
+        exp = np.array([0, 1, 1, 0, 0, 2, 2, 2], dtype=np.int_)
+        self.assert_numpy_array_equal(labels, exp)
+        exp = np.array(['a', 'b', 'c'], dtype=object)
+        self.assert_numpy_array_equal(uniques, exp)
 
         labels, uniques = algos.factorize(list(reversed(range(5))))
-        self.assert_numpy_array_equal(labels, np.array(
-            [0, 1, 2, 3, 4], dtype=np.int64))
-        self.assert_numpy_array_equal(uniques, np.array(
-            [4, 3, 2, 1, 0], dtype=np.int64))
+        exp = np.array([0, 1, 2, 3, 4], dtype=np.int_)
+        self.assert_numpy_array_equal(labels, exp)
+        exp = np.array([4, 3, 2, 1, 0], dtype=np.int64)
+        self.assert_numpy_array_equal(uniques, exp)
 
         labels, uniques = algos.factorize(list(reversed(range(5))), sort=True)
-        self.assert_numpy_array_equal(labels, np.array(
-            [4, 3, 2, 1, 0], dtype=np.int64))
-        self.assert_numpy_array_equal(uniques, np.array(
-            [0, 1, 2, 3, 4], dtype=np.int64))
+
+        exp = np.array([4, 3, 2, 1, 0], dtype=np.int_)
+        self.assert_numpy_array_equal(labels, exp)
+        exp = np.array([0, 1, 2, 3, 4], dtype=np.int64)
+        self.assert_numpy_array_equal(uniques, exp)
 
         labels, uniques = algos.factorize(list(reversed(np.arange(5.))))
-        self.assert_numpy_array_equal(labels, np.array(
-            [0., 1., 2., 3., 4.], dtype=np.float64))
-        self.assert_numpy_array_equal(uniques, np.array(
-            [4, 3, 2, 1, 0], dtype=np.int64))
-
-        labels, uniques = algos.factorize(
-            list(reversed(np.arange(5.))), sort=True)
-        self.assert_numpy_array_equal(labels, np.array(
-            [4, 3, 2, 1, 0], dtype=np.int64))
-        self.assert_numpy_array_equal(uniques, np.array(
-            [0., 1., 2., 3., 4.], dtype=np.float64))
+        exp = np.array([0, 1, 2, 3, 4], dtype=np.int_)
+        self.assert_numpy_array_equal(labels, exp)
+        exp = np.array([4., 3., 2., 1., 0.], dtype=np.float64)
+        self.assert_numpy_array_equal(uniques, exp)
+
+        labels, uniques = algos.factorize(list(reversed(np.arange(5.))),
+                                          sort=True)
+        exp = np.array([4, 3, 2, 1, 0], dtype=np.int_)
+        self.assert_numpy_array_equal(labels, exp)
+        exp = np.array([0., 1., 2., 3., 4.], dtype=np.float64)
+        self.assert_numpy_array_equal(uniques, exp)
 
     def test_mixed(self):
 
@@ -99,16 +100,16 @@ def test_mixed(self):
         x = Series(['A', 'A', np.nan, 'B', 3.14, np.inf])
         labels, uniques = algos.factorize(x)
 
-        self.assert_numpy_array_equal(labels, np.array(
-            [0, 0, -1, 1, 2, 3], dtype=np.int64))
-        self.assert_numpy_array_equal(uniques, np.array(
-            ['A', 'B', 3.14, np.inf], dtype=object))
+        exp = np.array([0, 0, -1, 1, 2, 3], dtype=np.int_)
+        self.assert_numpy_array_equal(labels, exp)
+        exp = np.array(['A', 'B', 3.14, np.inf], dtype=object)
+        self.assert_numpy_array_equal(uniques, exp)
 
         labels, uniques = algos.factorize(x, sort=True)
-        self.assert_numpy_array_equal(labels, np.array(
-            [2, 2, -1, 3, 0, 1], dtype=np.int64))
-        self.assert_numpy_array_equal(uniques, np.array(
-            [3.14, np.inf, 'A', 'B'], dtype=object))
+        exp = np.array([2, 2, -1, 3, 0, 1], dtype=np.int_)
+        self.assert_numpy_array_equal(labels, exp)
+        exp = np.array([3.14, np.inf, 'A', 'B'], dtype=object)
+        self.assert_numpy_array_equal(uniques, exp)
 
     def test_datelike(self):
 
@@ -117,16 +118,17 @@ def test_datelike(self):
         v2 = pd.Timestamp('20130101')
         x = Series([v1, v1, v1, v2, v2, v1])
         labels, uniques = algos.factorize(x)
-        self.assert_numpy_array_equal(labels, np.array(
-            [0, 0, 0, 1, 1, 0], dtype=np.int64))
-        self.assert_numpy_array_equal(uniques, np.array(
-            [v1.value, v2.value], dtype='M8[ns]'))
+
+        exp = np.array([0, 0, 0, 1, 1, 0], dtype=np.int_)
+        self.assert_numpy_array_equal(labels, exp)
+        exp = np.array([v1.value, v2.value], dtype='M8[ns]')
+        self.assert_numpy_array_equal(uniques, exp)
 
         labels, uniques = algos.factorize(x, sort=True)
-        self.assert_numpy_array_equal(labels, np.array(
-            [1, 1, 1, 0, 0, 1], dtype=np.int64))
-        self.assert_numpy_array_equal(uniques, np.array(
-            [v2.value, v1.value], dtype='M8[ns]'))
+        exp = np.array([1, 1, 1, 0, 0, 1], dtype=np.int_)
+        self.assert_numpy_array_equal(labels, exp)
+        exp = np.array([v2.value, v1.value], dtype='M8[ns]')
+        self.assert_numpy_array_equal(uniques, exp)
 
         # period
         v1 = pd.Period('201302', freq='M')
@@ -135,13 +137,13 @@ def test_datelike(self):
 
         # periods are not 'sorted' as they are converted back into an index
         labels, uniques = algos.factorize(x)
-        self.assert_numpy_array_equal(labels, np.array(
-            [0, 0, 0, 1, 1, 0], dtype=np.int64))
+        exp = np.array([0, 0, 0, 1, 1, 0], dtype=np.int_)
+        self.assert_numpy_array_equal(labels, exp)
         self.assert_numpy_array_equal(uniques, pd.PeriodIndex([v1, v2]))
 
         labels, uniques = algos.factorize(x, sort=True)
-        self.assert_numpy_array_equal(labels, np.array(
-            [0, 0, 0, 1, 1, 0], dtype=np.int64))
+        exp = np.array([0, 0, 0, 1, 1, 0], dtype=np.int_)
+        self.assert_numpy_array_equal(labels, exp)
         self.assert_numpy_array_equal(uniques, pd.PeriodIndex([v1, v2]))
 
         # GH 5986
@@ -149,13 +151,13 @@ def test_datelike(self):
         v2 = pd.to_timedelta('1 day')
         x = Series([v1, v2, v1, v1, v2, v2, v1])
         labels, uniques = algos.factorize(x)
-        self.assert_numpy_array_equal(labels, np.array(
-            [0, 1, 0, 0, 1, 1, 0], dtype=np.int64))
+        exp = np.array([0, 1, 0, 0, 1, 1, 0], dtype=np.int_)
+        self.assert_numpy_array_equal(labels, exp)
         self.assert_numpy_array_equal(uniques, pd.to_timedelta([v1, v2]))
 
         labels, uniques = algos.factorize(x, sort=True)
-        self.assert_numpy_array_equal(labels, np.array(
-            [1, 0, 1, 1, 0, 0, 1], dtype=np.int64))
+        exp = np.array([1, 0, 1, 1, 0, 0, 1], dtype=np.int_)
+        self.assert_numpy_array_equal(labels, exp)
         self.assert_numpy_array_equal(uniques, pd.to_timedelta([v2, v1]))
 
     def test_factorize_nan(self):
@@ -226,18 +228,24 @@ def test_outer_join_indexer(self):
             tm.assertIsInstance(lindexer, np.ndarray)
             tm.assertIsInstance(rindexer, np.ndarray)
             tm.assert_numpy_array_equal(result, np.arange(5, dtype=dtype))
-            tm.assert_numpy_array_equal(lindexer, np.array([0, 1, 2, -1, -1]))
-            tm.assert_numpy_array_equal(rindexer, np.array([-1, -1, 0, 1, 2]))
+            exp = np.array([0, 1, 2, -1, -1], dtype=np.int64)
+            tm.assert_numpy_array_equal(lindexer, exp)
+            exp = np.array([-1, -1, 0, 1, 2], dtype=np.int64)
+            tm.assert_numpy_array_equal(rindexer, exp)
 
             result, lindexer, rindexer = indexer(empty, right)
             tm.assert_numpy_array_equal(result, right)
-            tm.assert_numpy_array_equal(lindexer, np.array([-1, -1, -1]))
-            tm.assert_numpy_array_equal(rindexer, np.array([0, 1, 2]))
+            exp = np.array([-1, -1, -1], dtype=np.int64)
+            tm.assert_numpy_array_equal(lindexer, exp)
+            exp = np.array([0, 1, 2], dtype=np.int64)
+            tm.assert_numpy_array_equal(rindexer, exp)
 
             result, lindexer, rindexer = indexer(left, empty)
             tm.assert_numpy_array_equal(result, left)
-            tm.assert_numpy_array_equal(lindexer, np.array([0, 1, 2]))
-            tm.assert_numpy_array_equal(rindexer, np.array([-1, -1, -1]))
+            exp = np.array([0, 1, 2], dtype=np.int64)
+            tm.assert_numpy_array_equal(lindexer, exp)
+            exp = np.array([-1, -1, -1], dtype=np.int64)
+            tm.assert_numpy_array_equal(rindexer, exp)
 
 
 class TestUnique(tm.TestCase):
diff --git a/pandas/tests/test_base.py b/pandas/tests/test_base.py
index b2f54bd8c41db..2fec7c591a2b7 100644
--- a/pandas/tests/test_base.py
+++ b/pandas/tests/test_base.py
@@ -580,7 +580,8 @@ def test_value_counts_inferred(self):
             expected = Series([4, 3, 2, 1], index=['b', 'a', 'd', 'c'])
             tm.assert_series_equal(s.value_counts(), expected)
 
-            self.assert_numpy_array_equal(s.unique(), np.unique(s_values))
+            exp = np.unique(np.array(s_values, dtype=np.object_))
+            self.assert_numpy_array_equal(s.unique(), exp)
             self.assertEqual(s.nunique(), 4)
             # don't sort, have to sort after the fact as not sorting is
             # platform-dep
@@ -610,7 +611,8 @@ def test_value_counts_inferred(self):
             exp1n = Series({0.998: 1.0})
             tm.assert_series_equal(res1n, exp1n)
 
-            self.assert_numpy_array_equal(s1.unique(), np.array([1, 2, 3]))
+            self.assert_numpy_array_equal(s1.unique(),
+                                          np.array([1, 2, 3], dtype=np.int64))
             self.assertEqual(s1.nunique(), 3)
 
             res4 = s1.value_counts(bins=4)
@@ -628,21 +630,23 @@ def test_value_counts_inferred(self):
             tm.assert_series_equal(res4n, exp4n)
 
             # handle NA's properly
-            s_values = ['a', 'b', 'b', 'b', np.nan, np.nan, 'd', 'd', 'a', 'a',
-                        'b']
+            s_values = ['a', 'b', 'b', 'b', np.nan, np.nan,
+                        'd', 'd', 'a', 'a', 'b']
             s = klass(s_values)
             expected = Series([4, 3, 2], index=['b', 'a', 'd'])
             tm.assert_series_equal(s.value_counts(), expected)
 
-            self.assert_numpy_array_equal(s.unique(), np.array(
-                ['a', 'b', np.nan, 'd'], dtype='O'))
+            exp = np.array(['a', 'b', np.nan, 'd'], dtype=np.object_)
+            self.assert_numpy_array_equal(s.unique(), exp)
             self.assertEqual(s.nunique(), 3)
 
             s = klass({})
             expected = Series([], dtype=np.int64)
             tm.assert_series_equal(s.value_counts(), expected,
                                    check_index_type=False)
-            self.assert_numpy_array_equal(s.unique(), np.array([]))
+            # returned dtype differs depending on original
+            self.assert_numpy_array_equal(s.unique(), np.array([]),
+                                          check_dtype=False)
             self.assertEqual(s.nunique(), 0)
 
             # GH 3002, datetime64[ns]
@@ -990,7 +994,8 @@ def test_lookup_nan(self):
         xs = np.array([2.718, 3.14, np.nan, -7, 5, 2, 3])
         m = Float64HashTable()
         m.map_locations(xs)
-        self.assert_numpy_array_equal(m.lookup(xs), np.arange(len(xs)))
+        self.assert_numpy_array_equal(m.lookup(xs),
+                                      np.arange(len(xs), dtype=np.int64))
 
 
 class TestTranspose(Ops):
diff --git a/pandas/tests/test_categorical.py b/pandas/tests/test_categorical.py
index 33b7850732230..55df64264d6f9 100644
--- a/pandas/tests/test_categorical.py
+++ b/pandas/tests/test_categorical.py
@@ -125,7 +125,7 @@ def test_is_equal_dtype(self):
 
     def test_constructor(self):
 
-        exp_arr = np.array(["a", "b", "c", "a", "b", "c"])
+        exp_arr = np.array(["a", "b", "c", "a", "b", "c"], dtype=np.object_)
         c1 = Categorical(exp_arr)
         self.assert_numpy_array_equal(c1.__array__(), exp_arr)
         c2 = Categorical(exp_arr, categories=["a", "b", "c"])
@@ -333,9 +333,9 @@ def test_constructor_with_datetimelike(self):
             expected = type(dtl)(s2.dropna())
             expected.freq = None
             tm.assert_index_equal(c.categories, expected)
-            self.assert_numpy_array_equal(c.codes,
-                                          np.concatenate([np.arange(4, dtype='int8'),
-                                                      [-1]]))
+
+            exp = np.array([0, 1, 2, 3, -1], dtype=np.int8)
+            self.assert_numpy_array_equal(c.codes, exp)
 
             result = repr(c)
             self.assertTrue('NaT' in result)
@@ -512,18 +512,16 @@ def f():
     def test_argsort(self):
         c = Categorical([5, 3, 1, 4, 2], ordered=True)
 
-        expected = np.array([2, 4, 1, 3, 0])
-        tm.assert_numpy_array_equal(c.argsort(
-            ascending=True), expected)
+        expected = np.array([2, 4, 1, 3, 0], dtype=np.int64)
+        tm.assert_numpy_array_equal(c.argsort(ascending=True), expected)
 
         expected = expected[::-1]
-        tm.assert_numpy_array_equal(c.argsort(
-            ascending=False), expected)
+        tm.assert_numpy_array_equal(c.argsort(ascending=False), expected)
 
     def test_numpy_argsort(self):
         c = Categorical([5, 3, 1, 4, 2], ordered=True)
 
-        expected = np.array([2, 4, 1, 3, 0])
+        expected = np.array([2, 4, 1, 3, 0], dtype=np.int64)
         tm.assert_numpy_array_equal(np.argsort(c), expected)
 
         msg = "the 'kind' parameter is not supported"
@@ -702,7 +700,7 @@ def test_periodindex(self):
 
         cat1 = Categorical.from_array(idx1)
         str(cat1)
-        exp_arr = np.array([0, 0, 1, 1, 2, 2], dtype='int64')
+        exp_arr = np.array([0, 0, 1, 1, 2, 2], dtype=np.int8)
         exp_idx = PeriodIndex(['2014-01', '2014-02', '2014-03'], freq='M')
         self.assert_numpy_array_equal(cat1._codes, exp_arr)
         self.assertTrue(cat1.categories.equals(exp_idx))
@@ -711,7 +709,7 @@ def test_periodindex(self):
                             '2014-03', '2014-01'], freq='M')
         cat2 = Categorical.from_array(idx2, ordered=True)
         str(cat2)
-        exp_arr = np.array([2, 2, 1, 0, 2, 0], dtype='int64')
+        exp_arr = np.array([2, 2, 1, 0, 2, 0], dtype=np.int8)
         exp_idx2 = PeriodIndex(['2014-01', '2014-02', '2014-03'], freq='M')
         self.assert_numpy_array_equal(cat2._codes, exp_arr)
         self.assertTrue(cat2.categories.equals(exp_idx2))
@@ -719,7 +717,7 @@ def test_periodindex(self):
         idx3 = PeriodIndex(['2013-12', '2013-11', '2013-10', '2013-09',
                             '2013-08', '2013-07', '2013-05'], freq='M')
         cat3 = Categorical.from_array(idx3, ordered=True)
-        exp_arr = np.array([6, 5, 4, 3, 2, 1, 0], dtype='int64')
+        exp_arr = np.array([6, 5, 4, 3, 2, 1, 0], dtype=np.int8)
         exp_idx = PeriodIndex(['2013-05', '2013-07', '2013-08', '2013-09',
                                '2013-10', '2013-11', '2013-12'], freq='M')
         self.assert_numpy_array_equal(cat3._codes, exp_arr)
@@ -727,10 +725,11 @@ def test_periodindex(self):
 
     def test_categories_assigments(self):
         s = pd.Categorical(["a", "b", "c", "a"])
-        exp = np.array([1, 2, 3, 1])
+        exp = np.array([1, 2, 3, 1], dtype=np.int64)
         s.categories = [1, 2, 3]
         self.assert_numpy_array_equal(s.__array__(), exp)
-        self.assert_numpy_array_equal(s.categories, np.array([1, 2, 3]))
+        self.assert_numpy_array_equal(s.categories,
+                                      np.array([1, 2, 3], dtype=np.int64))
 
         # lengthen
         def f():
@@ -802,8 +801,8 @@ def test_set_ordered(self):
 
     def test_set_categories(self):
         cat = Categorical(["a", "b", "c", "a"], ordered=True)
-        exp_categories = np.array(["c", "b", "a"])
-        exp_values = np.array(["a", "b", "c", "a"])
+        exp_categories = np.array(["c", "b", "a"], dtype=np.object_)
+        exp_values = np.array(["a", "b", "c", "a"], dtype=np.object_)
 
         res = cat.set_categories(["c", "b", "a"], inplace=True)
         self.assert_numpy_array_equal(cat.categories, exp_categories)
@@ -823,34 +822,43 @@ def test_set_categories(self):
         # np.nan
         cat = Categorical(["a", "b", "c", "a"], ordered=True)
         res = cat.set_categories(["a"])
-        self.assert_numpy_array_equal(res.codes, np.array([0, -1, -1, 0]))
+        self.assert_numpy_array_equal(res.codes,
+                                      np.array([0, -1, -1, 0], dtype=np.int8))
 
         # still not all "old" in "new"
         res = cat.set_categories(["a", "b", "d"])
-        self.assert_numpy_array_equal(res.codes, np.array([0, 1, -1, 0]))
+        self.assert_numpy_array_equal(res.codes,
+                                      np.array([0, 1, -1, 0], dtype=np.int8))
         self.assert_numpy_array_equal(res.categories,
                                       np.array(["a", "b", "d"]))
 
         # all "old" included in "new"
         cat = cat.set_categories(["a", "b", "c", "d"])
-        exp_categories = np.array(["a", "b", "c", "d"])
+        exp_categories = np.array(["a", "b", "c", "d"], dtype=np.object_)
         self.assert_numpy_array_equal(cat.categories, exp_categories)
 
         # internals...
         c = Categorical([1, 2, 3, 4, 1], categories=[1, 2, 3, 4], ordered=True)
-        self.assert_numpy_array_equal(c._codes, np.array([0, 1, 2, 3, 0]))
+        self.assert_numpy_array_equal(c._codes,
+                                      np.array([0, 1, 2, 3, 0], dtype=np.int8))
         self.assert_numpy_array_equal(c.categories, np.array([1, 2, 3, 4]))
-        self.assert_numpy_array_equal(c.get_values(),
-                                      np.array([1, 2, 3, 4, 1]))
-        c = c.set_categories(
-            [4, 3, 2, 1
-             ])  # all "pointers" to '4' must be changed from 3 to 0,...
-        self.assert_numpy_array_equal(c._codes, np.array([3, 2, 1, 0, 3])
-                                      )  # positions are changed
-        self.assert_numpy_array_equal(c.categories, np.array([4, 3, 2, 1])
-                                      )  # categories are now in new order
-        self.assert_numpy_array_equal(c.get_values(), np.array([1, 2, 3, 4, 1])
-                                      )  # output is the same
+
+        exp = np.array([1, 2, 3, 4, 1], dtype=np.int64)
+        self.assert_numpy_array_equal(c.get_values(), exp)
+
+        # all "pointers" to '4' must be changed from 3 to 0,...
+        c = c.set_categories([4, 3, 2, 1])
+
+        # positions are changed
+        self.assert_numpy_array_equal(c._codes,
+                                      np.array([3, 2, 1, 0, 3], dtype=np.int8))
+
+        # categories are now in new order
+        self.assert_numpy_array_equal(c.categories, np.array([4, 3, 2, 1]))
+
+        # output is the same
+        exp = np.array([1, 2, 3, 4, 1], dtype=np.int64)
+        self.assert_numpy_array_equal(c.get_values(), exp)
         self.assertTrue(c.min(), 4)
         self.assertTrue(c.max(), 1)
 
@@ -869,18 +877,24 @@ def test_rename_categories(self):
 
         # inplace=False: the old one must not be changed
         res = cat.rename_categories([1, 2, 3])
-        self.assert_numpy_array_equal(res.__array__(), np.array([1, 2, 3, 1]))
-        self.assert_numpy_array_equal(res.categories, np.array([1, 2, 3]))
-        self.assert_numpy_array_equal(cat.__array__(),
-                                      np.array(["a", "b", "c", "a"]))
-        self.assert_numpy_array_equal(cat.categories,
-                                      np.array(["a", "b", "c"]))
+        self.assert_numpy_array_equal(res.__array__(),
+                                      np.array([1, 2, 3, 1], dtype=np.int64))
+        self.assert_numpy_array_equal(res.categories,
+                                      np.array([1, 2, 3], dtype=np.int64))
+
+        exp_cat = np.array(["a", "b", "c", "a"], dtype=np.object_)
+        self.assert_numpy_array_equal(cat.__array__(), exp_cat)
+
+        exp_cat = np.array(["a", "b", "c"], dtype=np.object_)
+        self.assert_numpy_array_equal(cat.categories, exp_cat)
         res = cat.rename_categories([1, 2, 3], inplace=True)
 
         # and now inplace
         self.assertIsNone(res)
-        self.assert_numpy_array_equal(cat.__array__(), np.array([1, 2, 3, 1]))
-        self.assert_numpy_array_equal(cat.categories, np.array([1, 2, 3]))
+        self.assert_numpy_array_equal(cat.__array__(),
+                                      np.array([1, 2, 3, 1], dtype=np.int64))
+        self.assert_numpy_array_equal(cat.categories,
+                                      np.array([1, 2, 3], dtype=np.int64))
 
         # lengthen
         def f():
@@ -1042,10 +1056,12 @@ def test_nan_handling(self):
         # Nans are represented as -1 in codes
         c = Categorical(["a", "b", np.nan, "a"])
         self.assert_numpy_array_equal(c.categories, np.array(["a", "b"]))
-        self.assert_numpy_array_equal(c._codes, np.array([0, 1, -1, 0]))
+        self.assert_numpy_array_equal(c._codes,
+                                      np.array([0, 1, -1, 0], dtype=np.int8))
         c[1] = np.nan
         self.assert_numpy_array_equal(c.categories, np.array(["a", "b"]))
-        self.assert_numpy_array_equal(c._codes, np.array([0, -1, -1, 0]))
+        self.assert_numpy_array_equal(c._codes,
+                                      np.array([0, -1, -1, 0], dtype=np.int8))
 
         # If categories have nan included, the code should point to that
         # instead
@@ -1055,12 +1071,14 @@ def test_nan_handling(self):
         self.assert_numpy_array_equal(c.categories,
                                       np.array(["a", "b", np.nan],
                                                dtype=np.object_))
-        self.assert_numpy_array_equal(c._codes, np.array([0, 1, 2, 0]))
+        self.assert_numpy_array_equal(c._codes,
+                                      np.array([0, 1, 2, 0], dtype=np.int8))
         c[1] = np.nan
         self.assert_numpy_array_equal(c.categories,
                                       np.array(["a", "b", np.nan],
                                                dtype=np.object_))
-        self.assert_numpy_array_equal(c._codes, np.array([0, 2, 2, 0]))
+        self.assert_numpy_array_equal(c._codes,
+                                      np.array([0, 2, 2, 0], dtype=np.int8))
 
         # Changing categories should also make the replaced category np.nan
         c = Categorical(["a", "b", "c", "a"])
@@ -1070,33 +1088,35 @@ def test_nan_handling(self):
         self.assert_numpy_array_equal(c.categories,
                                       np.array(["a", "b", np.nan],
                                                dtype=np.object_))
-        self.assert_numpy_array_equal(c._codes, np.array([0, 1, 2, 0]))
+        self.assert_numpy_array_equal(c._codes,
+                                      np.array([0, 1, 2, 0], dtype=np.int8))
 
         # Adding nan to categories should make assigned nan point to the
         # category!
         c = Categorical(["a", "b", np.nan, "a"])
         self.assert_numpy_array_equal(c.categories, np.array(["a", "b"]))
-        self.assert_numpy_array_equal(c._codes, np.array([0, 1, -1, 0]))
+        self.assert_numpy_array_equal(c._codes,
+                                      np.array([0, 1, -1, 0], dtype=np.int8))
         with tm.assert_produces_warning(FutureWarning):
             c.set_categories(["a", "b", np.nan], rename=True, inplace=True)
 
         self.assert_numpy_array_equal(c.categories,
                                       np.array(["a", "b", np.nan],
                                                dtype=np.object_))
-        self.assert_numpy_array_equal(c._codes, np.array([0, 1, -1, 0]))
+        self.assert_numpy_array_equal(c._codes,
+                                      np.array([0, 1, -1, 0], dtype=np.int8))
         c[1] = np.nan
         self.assert_numpy_array_equal(c.categories,
                                       np.array(["a", "b", np.nan],
                                                dtype=np.object_))
-        self.assert_numpy_array_equal(c._codes, np.array([0, 2, -1, 0]))
+        self.assert_numpy_array_equal(c._codes,
+                                      np.array([0, 2, -1, 0], dtype=np.int8))
 
         # Remove null categories (GH 10156)
-        cases = [
-            ([1.0, 2.0, np.nan], [1.0, 2.0]),
-            (['a', 'b', None], ['a', 'b']),
-            ([pd.Timestamp('2012-05-01'), pd.NaT],
-             [pd.Timestamp('2012-05-01')])
-        ]
+        cases = [([1.0, 2.0, np.nan], [1.0, 2.0]),
+                 (['a', 'b', None], ['a', 'b']),
+                 ([pd.Timestamp('2012-05-01'), pd.NaT],
+                  [pd.Timestamp('2012-05-01')])]
 
         null_values = [np.nan, None, pd.NaT]
 
@@ -1407,35 +1427,35 @@ def test_set_item_nan(self):
         with tm.assert_produces_warning(FutureWarning):
             cat.set_categories([1, 2, 3, np.nan], rename=True, inplace=True)
         cat[1] = np.nan
-        exp = np.array([0, 3, 2, -1])
+        exp = np.array([0, 3, 2, -1], dtype=np.int8)
         self.assert_numpy_array_equal(cat.codes, exp)
 
         cat = pd.Categorical([1, 2, 3, np.nan], categories=[1, 2, 3])
         with tm.assert_produces_warning(FutureWarning):
             cat.set_categories([1, 2, 3, np.nan], rename=True, inplace=True)
         cat[1:3] = np.nan
-        exp = np.array([0, 3, 3, -1])
+        exp = np.array([0, 3, 3, -1], dtype=np.int8)
         self.assert_numpy_array_equal(cat.codes, exp)
 
         cat = pd.Categorical([1, 2, 3, np.nan], categories=[1, 2, 3])
         with tm.assert_produces_warning(FutureWarning):
             cat.set_categories([1, 2, 3, np.nan], rename=True, inplace=True)
         cat[1:3] = [np.nan, 1]
-        exp = np.array([0, 3, 0, -1])
+        exp = np.array([0, 3, 0, -1], dtype=np.int8)
         self.assert_numpy_array_equal(cat.codes, exp)
 
         cat = pd.Categorical([1, 2, 3, np.nan], categories=[1, 2, 3])
         with tm.assert_produces_warning(FutureWarning):
             cat.set_categories([1, 2, 3, np.nan], rename=True, inplace=True)
         cat[1:3] = [np.nan, np.nan]
-        exp = np.array([0, 3, 3, -1])
+        exp = np.array([0, 3, 3, -1], dtype=np.int8)
         self.assert_numpy_array_equal(cat.codes, exp)
 
         cat = pd.Categorical([1, 2, np.nan, 3], categories=[1, 2, 3])
         with tm.assert_produces_warning(FutureWarning):
             cat.set_categories([1, 2, 3, np.nan], rename=True, inplace=True)
         cat[pd.isnull(cat)] = np.nan
-        exp = np.array([0, 1, 3, 2])
+        exp = np.array([0, 1, 3, 2], dtype=np.int8)
         self.assert_numpy_array_equal(cat.codes, exp)
 
     def test_shift(self):
@@ -1487,7 +1507,7 @@ def test_searchsorted(self):
         # Single item array
         res = c1.searchsorted(['bread'])
         chk = s1.searchsorted(['bread'])
-        exp = np.array([1])
+        exp = np.array([1], dtype=np.int64)
         self.assert_numpy_array_equal(res, exp)
         self.assert_numpy_array_equal(res, chk)
 
@@ -1496,21 +1516,21 @@ def test_searchsorted(self):
         # np.array.searchsorted()
         res = c1.searchsorted('bread')
         chk = s1.searchsorted('bread')
-        exp = np.array([1])
+        exp = np.array([1], dtype=np.int64)
         self.assert_numpy_array_equal(res, exp)
         self.assert_numpy_array_equal(res, chk)
 
         # Searching for a value that is not present in the Categorical
         res = c1.searchsorted(['bread', 'eggs'])
         chk = s1.searchsorted(['bread', 'eggs'])
-        exp = np.array([1, 4])
+        exp = np.array([1, 4], dtype=np.int64)
         self.assert_numpy_array_equal(res, exp)
         self.assert_numpy_array_equal(res, chk)
 
         # Searching for a value that is not present, to the right
         res = c1.searchsorted(['bread', 'eggs'], side='right')
         chk = s1.searchsorted(['bread', 'eggs'], side='right')
-        exp = np.array([3, 4])  # eggs before milk
+        exp = np.array([3, 4], dtype=np.int64)  # eggs before milk
         self.assert_numpy_array_equal(res, exp)
         self.assert_numpy_array_equal(res, chk)
 
@@ -1519,8 +1539,8 @@ def test_searchsorted(self):
                               sorter=[0, 1, 2, 3, 5, 4])
         chk = s2.searchsorted(['bread', 'eggs'], side='right',
                               sorter=[0, 1, 2, 3, 5, 4])
-        exp = np.array([3, 5]
-                       )  # eggs after donuts, after switching milk and donuts
+        # eggs after donuts, after switching milk and donuts
+        exp = np.array([3, 5], dtype=np.int64)
         self.assert_numpy_array_equal(res, exp)
         self.assert_numpy_array_equal(res, chk)
 
@@ -1596,7 +1616,7 @@ def test_map(self):
         tm.assert_categorical_equal(result, exp)
 
         result = c.map(lambda x: 1)
-        tm.assert_numpy_array_equal(result, np.array([1] * 5))
+        tm.assert_numpy_array_equal(result, np.array([1] * 5, dtype=np.int64))
 
 
 class TestCategoricalAsBlock(tm.TestCase):
@@ -1875,14 +1895,14 @@ def test_sideeffects_free(self):
         s = pd.Series(cat, copy=True)
         self.assertFalse(s.cat is cat)
         s.cat.categories = [1, 2, 3]
-        exp_s = np.array([1, 2, 3, 1])
-        exp_cat = np.array(["a", "b", "c", "a"])
+        exp_s = np.array([1, 2, 3, 1], dtype=np.int64)
+        exp_cat = np.array(["a", "b", "c", "a"], dtype=np.object_)
         self.assert_numpy_array_equal(s.__array__(), exp_s)
         self.assert_numpy_array_equal(cat.__array__(), exp_cat)
 
         # setting
         s[0] = 2
-        exp_s2 = np.array([2, 2, 3, 1])
+        exp_s2 = np.array([2, 2, 3, 1], dtype=np.int64)
         self.assert_numpy_array_equal(s.__array__(), exp_s2)
         self.assert_numpy_array_equal(cat.__array__(), exp_cat)
 
@@ -1892,12 +1912,12 @@ def test_sideeffects_free(self):
         s = pd.Series(cat)
         self.assertTrue(s.values is cat)
         s.cat.categories = [1, 2, 3]
-        exp_s = np.array([1, 2, 3, 1])
+        exp_s = np.array([1, 2, 3, 1], dtype=np.int64)
         self.assert_numpy_array_equal(s.__array__(), exp_s)
         self.assert_numpy_array_equal(cat.__array__(), exp_s)
 
         s[0] = 2
-        exp_s2 = np.array([2, 2, 3, 1])
+        exp_s2 = np.array([2, 2, 3, 1], dtype=np.int64)
         self.assert_numpy_array_equal(s.__array__(), exp_s2)
         self.assert_numpy_array_equal(cat.__array__(), exp_s2)
 
@@ -1905,25 +1925,31 @@ def test_nan_handling(self):
 
         # Nans are represented as -1 in labels
         s = Series(Categorical(["a", "b", np.nan, "a"]))
-        self.assert_numpy_array_equal(s.cat.categories, np.array(["a", "b"]))
-        self.assert_numpy_array_equal(s.values.codes, np.array([0, 1, -1, 0]))
+        self.assert_numpy_array_equal(s.cat.categories,
+                                      np.array(["a", "b"], dtype=np.object_))
+        self.assert_numpy_array_equal(s.values.codes,
+                                      np.array([0, 1, -1, 0], dtype=np.int8))
 
         # If categories have nan included, the label should point to that
         # instead
         with tm.assert_produces_warning(FutureWarning):
-            s2 = Series(Categorical(
-                ["a", "b", np.nan, "a"], categories=["a", "b", np.nan]))
-        self.assert_numpy_array_equal(s2.cat.categories, np.array(
-            ["a", "b", np.nan], dtype=np.object_))
-        self.assert_numpy_array_equal(s2.values.codes, np.array([0, 1, 2, 0]))
+            s2 = Series(Categorical(["a", "b", np.nan, "a"],
+                                    categories=["a", "b", np.nan]))
+
+        exp_cat = np.array(["a", "b", np.nan], dtype=np.object_)
+        self.assert_numpy_array_equal(s2.cat.categories, exp_cat)
+        self.assert_numpy_array_equal(s2.values.codes,
+                                      np.array([0, 1, 2, 0], dtype=np.int8))
 
         # Changing categories should also make the replaced category np.nan
         s3 = Series(Categorical(["a", "b", "c", "a"]))
         with tm.assert_produces_warning(FutureWarning, check_stacklevel=False):
             s3.cat.categories = ["a", "b", np.nan]
-        self.assert_numpy_array_equal(s3.cat.categories, np.array(
-            ["a", "b", np.nan], dtype=np.object_))
-        self.assert_numpy_array_equal(s3.values.codes, np.array([0, 1, 2, 0]))
+
+        exp_cat = np.array(["a", "b", np.nan], dtype=np.object_)
+        self.assert_numpy_array_equal(s3.cat.categories, exp_cat)
+        self.assert_numpy_array_equal(s3.values.codes,
+                                      np.array([0, 1, 2, 0], dtype=np.int8))
 
     def test_cat_accessor(self):
         s = Series(Categorical(["a", "b", np.nan, "a"]))
@@ -1997,7 +2023,7 @@ def test_series_delegations(self):
         # reorder
         s = Series(Categorical(["a", "b", "c", "a"], ordered=True))
         exp_categories = np.array(["c", "b", "a"])
-        exp_values = np.array(["a", "b", "c", "a"])
+        exp_values = np.array(["a", "b", "c", "a"], dtype=np.object_)
         s = s.cat.set_categories(["c", "b", "a"])
         self.assert_numpy_array_equal(s.cat.categories, exp_categories)
         self.assert_numpy_array_equal(s.values.__array__(), exp_values)
@@ -2006,8 +2032,8 @@ def test_series_delegations(self):
         # remove unused categories
         s = Series(Categorical(["a", "b", "b", "a"], categories=["a", "b", "c"
                                                                  ]))
-        exp_categories = np.array(["a", "b"])
-        exp_values = np.array(["a", "b", "b", "a"])
+        exp_categories = np.array(["a", "b"], dtype=object)
+        exp_values = np.array(["a", "b", "b", "a"], dtype=np.object_)
         s = s.cat.remove_unused_categories()
         self.assert_numpy_array_equal(s.cat.categories, exp_categories)
         self.assert_numpy_array_equal(s.values.__array__(), exp_values)
@@ -3078,17 +3104,17 @@ def test_sort_values(self):
 
         cat = Series(Categorical(["a", "c", "b", "d"], ordered=True))
         res = cat.sort_values()
-        exp = np.array(["a", "b", "c", "d"])
+        exp = np.array(["a", "b", "c", "d"], dtype=np.object_)
         self.assert_numpy_array_equal(res.__array__(), exp)
 
         cat = Series(Categorical(["a", "c", "b", "d"], categories=[
                      "a", "b", "c", "d"], ordered=True))
         res = cat.sort_values()
-        exp = np.array(["a", "b", "c", "d"])
+        exp = np.array(["a", "b", "c", "d"], dtype=np.object_)
         self.assert_numpy_array_equal(res.__array__(), exp)
 
         res = cat.sort_values(ascending=False)
-        exp = np.array(["d", "c", "b", "a"])
+        exp = np.array(["d", "c", "b", "a"], dtype=np.object_)
         self.assert_numpy_array_equal(res.__array__(), exp)
 
         raw_cat1 = Categorical(["a", "b", "c", "d"],
@@ -3103,7 +3129,7 @@ def test_sort_values(self):
 
         # Cats must be sorted in a dataframe
         res = df.sort_values(by=["string"], ascending=False)
-        exp = np.array(["d", "c", "b", "a"])
+        exp = np.array(["d", "c", "b", "a"], dtype=np.object_)
         self.assert_numpy_array_equal(res["sort"].values.__array__(), exp)
         self.assertEqual(res["sort"].dtype, "category")
 
@@ -3136,7 +3162,7 @@ def test_sort_values(self):
     def test_slicing(self):
         cat = Series(Categorical([1, 2, 3, 4]))
         reversed = cat[::-1]
-        exp = np.array([4, 3, 2, 1])
+        exp = np.array([4, 3, 2, 1], dtype=np.int64)
         self.assert_numpy_array_equal(reversed.__array__(), exp)
 
         df = DataFrame({'value': (np.arange(100) + 1).astype('int64')})
diff --git a/pandas/tests/test_common.py b/pandas/tests/test_common.py
index 9fe0d3c569ae0..090669681fb4f 100644
--- a/pandas/tests/test_common.py
+++ b/pandas/tests/test_common.py
@@ -374,17 +374,17 @@ def test_downcast_conv():
     for dtype in [np.float64, object, np.int64]:
         arr = np.array([1.0, 2.0], dtype=dtype)
         result = com._possibly_downcast_to_dtype(arr, 'infer')
-        tm.assert_almost_equal(result, expected)
+        tm.assert_almost_equal(result, expected, check_dtype=False)
 
-    expected = np.array([1.0, 2.0, np.nan])
     for dtype in [np.float64, object]:
+        expected = np.array([1.0, 2.0, np.nan], dtype=dtype)
         arr = np.array([1.0, 2.0, np.nan], dtype=dtype)
         result = com._possibly_downcast_to_dtype(arr, 'infer')
         tm.assert_almost_equal(result, expected)
 
     # empties
-    for dtype in [np.int32, np.float64, np.float32, np.bool_, np.int64, object
-                  ]:
+    for dtype in [np.int32, np.float64, np.float32, np.bool_,
+                  np.int64, object]:
         arr = np.array([], dtype=dtype)
         result = com._possibly_downcast_to_dtype(arr, 'int64')
         tm.assert_almost_equal(result, np.array([], dtype=np.int64))
@@ -434,6 +434,14 @@ def test_array_equivalent():
         DatetimeIndex([0, np.nan]), TimedeltaIndex([0, np.nan]))
 
 
+def test_array_equivalent_str():
+    for dtype in ['O', 'S', 'U']:
+        assert array_equivalent(np.array(['A', 'B'], dtype=dtype),
+                                np.array(['A', 'B'], dtype=dtype))
+        assert not array_equivalent(np.array(['A', 'B'], dtype=dtype),
+                                    np.array(['A', 'X'], dtype=dtype))
+
+
 def test_datetimeindex_from_empty_datetime64_array():
     for unit in ['ms', 'us', 'ns']:
         idx = DatetimeIndex(np.array([], dtype='datetime64[%s]' % unit))
diff --git a/pandas/tests/test_graphics.py b/pandas/tests/test_graphics.py
index 604cd89dac617..3820a9d5f6476 100644
--- a/pandas/tests/test_graphics.py
+++ b/pandas/tests/test_graphics.py
@@ -349,7 +349,7 @@ def _check_axes_shape(self, axes, axes_num=None, layout=None,
 
         self.assert_numpy_array_equal(
             np.round(visible_axes[0].figure.get_size_inches()),
-            np.array(figsize))
+            np.array(figsize, dtype=np.float64))
 
     def _get_axes_layout(self, axes):
         x_set = set()
@@ -663,12 +663,12 @@ def test_line_area_nan_series(self):
             ax = _check_plot_works(d.plot)
             masked = ax.lines[0].get_ydata()
             # remove nan for comparison purpose
-            self.assert_numpy_array_equal(
-                np.delete(masked.data, 2), np.array([1, 2, 3]))
+            exp = np.array([1, 2, 3], dtype=np.float64)
+            self.assert_numpy_array_equal(np.delete(masked.data, 2), exp)
             self.assert_numpy_array_equal(
                 masked.mask, np.array([False, False, True, False]))
 
-            expected = np.array([1, 2, 0, 3])
+            expected = np.array([1, 2, 0, 3], dtype=np.float64)
             ax = _check_plot_works(d.plot, stacked=True)
             self.assert_numpy_array_equal(ax.lines[0].get_ydata(), expected)
             ax = _check_plot_works(d.plot.area)
@@ -1855,17 +1855,19 @@ def test_line_area_nan_df(self):
             masked1 = ax.lines[0].get_ydata()
             masked2 = ax.lines[1].get_ydata()
             # remove nan for comparison purpose
-            self.assert_numpy_array_equal(
-                np.delete(masked1.data, 2), np.array([1, 2, 3]))
-            self.assert_numpy_array_equal(
-                np.delete(masked2.data, 1), np.array([3, 2, 1]))
+
+            exp = np.array([1, 2, 3], dtype=np.float64)
+            self.assert_numpy_array_equal(np.delete(masked1.data, 2), exp)
+
+            exp = np.array([3, 2, 1], dtype=np.float64)
+            self.assert_numpy_array_equal(np.delete(masked2.data, 1), exp)
             self.assert_numpy_array_equal(
                 masked1.mask, np.array([False, False, True, False]))
             self.assert_numpy_array_equal(
                 masked2.mask, np.array([False, True, False, False]))
 
-            expected1 = np.array([1, 2, 0, 3])
-            expected2 = np.array([3, 0, 2, 1])
+            expected1 = np.array([1, 2, 0, 3], dtype=np.float64)
+            expected2 = np.array([3, 0, 2, 1], dtype=np.float64)
 
             ax = _check_plot_works(d.plot, stacked=True)
             self.assert_numpy_array_equal(ax.lines[0].get_ydata(), expected1)
@@ -2555,15 +2557,20 @@ def _check_box_coord(self, patches, expected_y=None, expected_h=None,
         result_height = np.array([p.get_height() for p in patches])
         result_x = np.array([p.get_x() for p in patches])
         result_width = np.array([p.get_width() for p in patches])
+        # dtype is depending on above values, no need to check
 
         if expected_y is not None:
-            self.assert_numpy_array_equal(result_y, expected_y)
+            self.assert_numpy_array_equal(result_y, expected_y,
+                                          check_dtype=False)
         if expected_h is not None:
-            self.assert_numpy_array_equal(result_height, expected_h)
+            self.assert_numpy_array_equal(result_height, expected_h,
+                                          check_dtype=False)
         if expected_x is not None:
-            self.assert_numpy_array_equal(result_x, expected_x)
+            self.assert_numpy_array_equal(result_x, expected_x,
+                                          check_dtype=False)
         if expected_w is not None:
-            self.assert_numpy_array_equal(result_width, expected_w)
+            self.assert_numpy_array_equal(result_width, expected_w,
+                                          check_dtype=False)
 
     @slow
     def test_hist_df_coord(self):
@@ -2639,8 +2646,9 @@ def test_hist_df_coord(self):
                 self._check_box_coord(ax.patches[5:10],
                                       expected_x=np.array([10, 9, 8, 7, 6]),
                                       expected_w=np.array([8, 8, 8, 8, 8]))
-                self._check_box_coord(ax.patches[10:], expected_x=np.array(
-                    [18, 17, 16, 15, 14]),
+                self._check_box_coord(
+                    ax.patches[10:],
+                    expected_x=np.array([18, 17, 16, 15, 14]),
                     expected_w=np.array([6, 7, 8, 9, 10]))
 
                 axes = df.plot.hist(bins=5, stacked=True, subplots=True,
diff --git a/pandas/tests/test_groupby.py b/pandas/tests/test_groupby.py
index 0e2dbb7d5405d..5bd5c80f18386 100644
--- a/pandas/tests/test_groupby.py
+++ b/pandas/tests/test_groupby.py
@@ -3312,8 +3312,12 @@ def test_groupby_nat_exclude(self):
         # confirm obj is not filtered
         tm.assert_frame_equal(grouped.grouper.groupings[0].obj, df)
         self.assertEqual(grouped.ngroups, 2)
-        expected = {Timestamp('2013-01-01 00:00:00'): np.array([1, 7]),
-                    Timestamp('2013-02-01 00:00:00'): np.array([3, 5])}
+
+        expected = {
+            Timestamp('2013-01-01 00:00:00'): np.array([1, 7], dtype=np.int64),
+            Timestamp('2013-02-01 00:00:00'): np.array([3, 5], dtype=np.int64)
+        }
+
         for k in grouped.indices:
             self.assert_numpy_array_equal(grouped.indices[k], expected[k])
 
@@ -3409,7 +3413,7 @@ def test_groupby_2d_malformed(self):
         d['ones'] = [1, 1]
         d['label'] = ['l1', 'l2']
         tmp = d.groupby(['group']).mean()
-        res_values = np.array([[0., 1.], [0., 1.]])
+        res_values = np.array([[0, 1], [0, 1]], dtype=np.int64)
         self.assert_numpy_array_equal(tmp.columns, ['zeros', 'ones'])
         self.assert_numpy_array_equal(tmp.values, res_values)
 
@@ -5968,7 +5972,7 @@ def test__cython_agg_general(self):
                 exc.args += ('operation: %s' % op, )
                 raise
 
-    def test_cython_group_transform_algos(self):
+    def test_aa_cython_group_transform_algos(self):
         # GH 4095
         dtypes = [np.int8, np.int16, np.int32, np.int64, np.uint8, np.uint32,
                   np.uint64, np.float32, np.float64]
@@ -5983,7 +5987,8 @@ def test_cython_group_transform_algos(self):
                 accum = np.array([[0]], dtype=dtype)
                 labels = np.array([0, 0, 0, 0], dtype=np.int64)
                 pd_op(ans, data, labels, accum)
-                self.assert_numpy_array_equal(np_op(data), ans[:, 0])
+                self.assert_numpy_array_equal(np_op(data), ans[:, 0],
+                                              check_dtype=False)
 
         # with nans
         labels = np.array([0, 0, 0, 0, 0], dtype=np.int64)
diff --git a/pandas/tests/test_internals.py b/pandas/tests/test_internals.py
index 95e7ab49ccd9c..bf9574f48913a 100644
--- a/pandas/tests/test_internals.py
+++ b/pandas/tests/test_internals.py
@@ -890,8 +890,10 @@ def assert_slice_ok(mgr, axis, slobj):
                         len(ax) - len(slobj), dtype=bool)])
             sliced = mgr.get_slice(slobj, axis=axis)
             mat_slobj = (slice(None), ) * axis + (slobj, )
-            assert_almost_equal(mat[mat_slobj], sliced.as_matrix())
-            assert_almost_equal(mgr.axes[axis][slobj], sliced.axes[axis])
+            tm.assert_numpy_array_equal(mat[mat_slobj], sliced.as_matrix(),
+                                        check_dtype=False)
+            tm.assert_numpy_array_equal(mgr.axes[axis][slobj],
+                                        sliced.axes[axis])
 
         for mgr in self.MANAGERS:
             for ax in range(mgr.ndim):
@@ -927,8 +929,10 @@ def test_take(self):
         def assert_take_ok(mgr, axis, indexer):
             mat = mgr.as_matrix()
             taken = mgr.take(indexer, axis)
-            assert_almost_equal(np.take(mat, indexer, axis), taken.as_matrix())
-            assert_almost_equal(mgr.axes[axis].take(indexer), taken.axes[axis])
+            tm.assert_numpy_array_equal(np.take(mat, indexer, axis),
+                                        taken.as_matrix(), check_dtype=False)
+            tm.assert_numpy_array_equal(mgr.axes[axis].take(indexer),
+                                        taken.axes[axis])
 
         for mgr in self.MANAGERS:
             for ax in range(mgr.ndim):
@@ -950,7 +954,8 @@ def assert_reindex_axis_is_ok(mgr, axis, new_labels, fill_value):
                                          fill_value=fill_value)
             tm.assert_numpy_array_equal(algos.take_nd(mat, indexer, axis,
                                                       fill_value=fill_value),
-                                        reindexed.as_matrix())
+                                        reindexed.as_matrix(),
+                                        check_dtype=False)
             tm.assert_index_equal(reindexed.axes[axis], new_labels)
 
         for mgr in self.MANAGERS:
@@ -985,7 +990,9 @@ def assert_reindex_indexer_is_ok(mgr, axis, new_labels, indexer,
                                           fill_value=fill_value)
             reindexed = mgr.reindex_indexer(new_labels, indexer, axis,
                                             fill_value=fill_value)
-            tm.assert_numpy_array_equal(reindexed_mat, reindexed.as_matrix())
+            tm.assert_numpy_array_equal(reindexed_mat,
+                                        reindexed.as_matrix(),
+                                        check_dtype=False)
             tm.assert_index_equal(reindexed.axes[axis], new_labels)
 
         for mgr in self.MANAGERS:
@@ -1114,7 +1121,7 @@ def test_slice_to_array_conversion(self):
         def assert_as_array_equals(slc, asarray):
             tm.assert_numpy_array_equal(
                 BlockPlacement(slc).as_array,
-                np.asarray(asarray))
+                np.asarray(asarray, dtype=np.int64))
 
         assert_as_array_equals(slice(0, 3), [0, 1, 2])
         assert_as_array_equals(slice(0, 0), [])
diff --git a/pandas/tests/test_nanops.py b/pandas/tests/test_nanops.py
index 8364da2458fd9..d33a64002c3b1 100644
--- a/pandas/tests/test_nanops.py
+++ b/pandas/tests/test_nanops.py
@@ -116,7 +116,7 @@ def setUp(self):
     def tearDown(self):
         nanops._USE_BOTTLENECK = use_bn
 
-    def check_results(self, targ, res, axis):
+    def check_results(self, targ, res, axis, check_dtype=True):
         res = getattr(res, 'asm8', res)
         res = getattr(res, 'values', res)
 
@@ -138,13 +138,13 @@ def _coerce_tds(targ, res):
             targ, res = _coerce_tds(targ, res)
 
         try:
-            tm.assert_almost_equal(targ, res)
+            tm.assert_almost_equal(targ, res, check_dtype=check_dtype)
         except:
 
             # handle timedelta dtypes
             if hasattr(targ, 'dtype') and targ.dtype == 'm8[ns]':
                 targ, res = _coerce_tds(targ, res)
-                tm.assert_almost_equal(targ, res)
+                tm.assert_almost_equal(targ, res, check_dtype=check_dtype)
                 return
 
             # There are sometimes rounding errors with
@@ -170,11 +170,13 @@ def _coerce_tds(targ, res):
             # but nanops doesn't, so make that an exception
             elif targ.dtype.kind == 'O':
                 raise
-            tm.assert_almost_equal(targ.real, res.real)
-            tm.assert_almost_equal(targ.imag, res.imag)
+            tm.assert_almost_equal(targ.real, res.real,
+                                   check_dtype=check_dtype)
+            tm.assert_almost_equal(targ.imag, res.imag,
+                                   check_dtype=check_dtype)
 
     def check_fun_data(self, testfunc, targfunc, testarval, targarval,
-                       targarnanval, **kwargs):
+                       targarnanval, check_dtype=True, **kwargs):
         for axis in list(range(targarval.ndim)) + [None]:
             for skipna in [False, True]:
                 targartempval = targarval if skipna else targarnanval
@@ -182,16 +184,20 @@ def check_fun_data(self, testfunc, targfunc, testarval, targarval,
                     targ = targfunc(targartempval, axis=axis, **kwargs)
                     res = testfunc(testarval, axis=axis, skipna=skipna,
                                    **kwargs)
-                    self.check_results(targ, res, axis)
+                    self.check_results(targ, res, axis,
+                                       check_dtype=check_dtype)
                     if skipna:
                         res = testfunc(testarval, axis=axis, **kwargs)
-                        self.check_results(targ, res, axis)
+                        self.check_results(targ, res, axis,
+                                           check_dtype=check_dtype)
                     if axis is None:
                         res = testfunc(testarval, skipna=skipna, **kwargs)
-                        self.check_results(targ, res, axis)
+                        self.check_results(targ, res, axis,
+                                           check_dtype=check_dtype)
                     if skipna and axis is None:
                         res = testfunc(testarval, **kwargs)
-                        self.check_results(targ, res, axis)
+                        self.check_results(targ, res, axis,
+                                           check_dtype=check_dtype)
                 except BaseException as exc:
                     exc.args += ('axis: %s of %s' % (axis, testarval.ndim - 1),
                                  'skipna: %s' % skipna, 'kwargs: %s' % kwargs)
@@ -207,7 +213,7 @@ def check_fun_data(self, testfunc, targfunc, testarval, targarval,
         except ValueError:
             return
         self.check_fun_data(testfunc, targfunc, testarval2, targarval2,
-                            targarnanval2, **kwargs)
+                            targarnanval2, check_dtype=check_dtype, **kwargs)
 
     def check_fun(self, testfunc, targfunc, testar, targar=None,
                   targarnan=None, **kwargs):
@@ -317,7 +323,7 @@ def test_nanall(self):
 
     def test_nansum(self):
         self.check_funs(nanops.nansum, np.sum, allow_str=False,
-                        allow_date=False, allow_tdelta=True)
+                        allow_date=False, allow_tdelta=True, check_dtype=False)
 
     def test_nanmean(self):
         self.check_funs(nanops.nanmean, np.mean, allow_complex=False,
@@ -596,11 +602,11 @@ def check_nancomp(self, checkfun, targ0):
                 else:
                     targ1 = np.hstack([targ0, arr_nan])
                 res1 = checkfun(arr_float_nan, arr_float1_nan)
-                tm.assert_almost_equal(targ1, res1)
+                tm.assert_numpy_array_equal(targ1, res1, check_dtype=False)
 
                 targ2 = arr_nan_nan
                 res2 = checkfun(arr_float_nan, arr_nan_float1)
-                tm.assert_almost_equal(targ2, res2)
+                tm.assert_numpy_array_equal(targ2, res2, check_dtype=False)
             except Exception as exc:
                 exc.args += ('ndim: %s' % arr_float.ndim, )
                 raise
diff --git a/pandas/tests/test_strings.py b/pandas/tests/test_strings.py
index 4dd9a2653d687..4179949bc49a6 100644
--- a/pandas/tests/test_strings.py
+++ b/pandas/tests/test_strings.py
@@ -1335,32 +1335,38 @@ def test_find(self):
         values = Series(['ABCDEFG', 'BCDEFEF', 'DEFGHIJEF', 'EFGHEF', 'XXXX'])
         result = values.str.find('EF')
         tm.assert_series_equal(result, Series([4, 3, 1, 0, -1]))
-        expected = np.array([v.find('EF') for v in values.values])
+        expected = np.array([v.find('EF') for v in values.values],
+                            dtype=np.int64)
         tm.assert_numpy_array_equal(result.values, expected)
 
         result = values.str.rfind('EF')
         tm.assert_series_equal(result, Series([4, 5, 7, 4, -1]))
-        expected = np.array([v.rfind('EF') for v in values.values])
+        expected = np.array([v.rfind('EF') for v in values.values],
+                            dtype=np.int64)
         tm.assert_numpy_array_equal(result.values, expected)
 
         result = values.str.find('EF', 3)
         tm.assert_series_equal(result, Series([4, 3, 7, 4, -1]))
-        expected = np.array([v.find('EF', 3) for v in values.values])
+        expected = np.array([v.find('EF', 3) for v in values.values],
+                            dtype=np.int64)
         tm.assert_numpy_array_equal(result.values, expected)
 
         result = values.str.rfind('EF', 3)
         tm.assert_series_equal(result, Series([4, 5, 7, 4, -1]))
-        expected = np.array([v.rfind('EF', 3) for v in values.values])
+        expected = np.array([v.rfind('EF', 3) for v in values.values],
+                            dtype=np.int64)
         tm.assert_numpy_array_equal(result.values, expected)
 
         result = values.str.find('EF', 3, 6)
         tm.assert_series_equal(result, Series([4, 3, -1, 4, -1]))
-        expected = np.array([v.find('EF', 3, 6) for v in values.values])
+        expected = np.array([v.find('EF', 3, 6) for v in values.values],
+                            dtype=np.int64)
         tm.assert_numpy_array_equal(result.values, expected)
 
         result = values.str.rfind('EF', 3, 6)
         tm.assert_series_equal(result, Series([4, 3, -1, 4, -1]))
-        expected = np.array([v.rfind('EF', 3, 6) for v in values.values])
+        expected = np.array([v.rfind('EF', 3, 6) for v in values.values],
+                            dtype=np.int64)
         tm.assert_numpy_array_equal(result.values, expected)
 
         with tm.assertRaisesRegexp(TypeError,
@@ -1397,32 +1403,38 @@ def test_index(self):
 
             result = s.str.index('EF')
             tm.assert_numpy_array_equal(result, klass([4, 3, 1, 0]))
-            expected = np.array([v.index('EF') for v in s.values])
+            expected = np.array([v.index('EF') for v in s.values],
+                                dtype=np.int64)
             tm.assert_numpy_array_equal(result.values, expected)
 
             result = s.str.rindex('EF')
             tm.assert_numpy_array_equal(result, klass([4, 5, 7, 4]))
-            expected = np.array([v.rindex('EF') for v in s.values])
+            expected = np.array([v.rindex('EF') for v in s.values],
+                                dtype=np.int64)
             tm.assert_numpy_array_equal(result.values, expected)
 
             result = s.str.index('EF', 3)
             tm.assert_numpy_array_equal(result, klass([4, 3, 7, 4]))
-            expected = np.array([v.index('EF', 3) for v in s.values])
+            expected = np.array([v.index('EF', 3) for v in s.values],
+                                dtype=np.int64)
             tm.assert_numpy_array_equal(result.values, expected)
 
             result = s.str.rindex('EF', 3)
             tm.assert_numpy_array_equal(result, klass([4, 5, 7, 4]))
-            expected = np.array([v.rindex('EF', 3) for v in s.values])
+            expected = np.array([v.rindex('EF', 3) for v in s.values],
+                                dtype=np.int64)
             tm.assert_numpy_array_equal(result.values, expected)
 
             result = s.str.index('E', 4, 8)
             tm.assert_numpy_array_equal(result, klass([4, 5, 7, 4]))
-            expected = np.array([v.index('E', 4, 8) for v in s.values])
+            expected = np.array([v.index('E', 4, 8) for v in s.values],
+                                dtype=np.int64)
             tm.assert_numpy_array_equal(result.values, expected)
 
             result = s.str.rindex('E', 0, 5)
             tm.assert_numpy_array_equal(result, klass([4, 3, 1, 4]))
-            expected = np.array([v.rindex('E', 0, 5) for v in s.values])
+            expected = np.array([v.rindex('E', 0, 5) for v in s.values],
+                                dtype=np.int64)
             tm.assert_numpy_array_equal(result.values, expected)
 
             with tm.assertRaisesRegexp(ValueError, "substring not found"):
@@ -1611,19 +1623,22 @@ def test_center_ljust_rjust_fillchar(self):
         result = values.str.center(5, fillchar='X')
         expected = Series(['XXaXX', 'XXbbX', 'Xcccc', 'ddddd', 'eeeeee'])
         tm.assert_series_equal(result, expected)
-        expected = np.array([v.center(5, 'X') for v in values.values])
+        expected = np.array([v.center(5, 'X') for v in values.values],
+                            dtype=np.object_)
         tm.assert_numpy_array_equal(result.values, expected)
 
         result = values.str.ljust(5, fillchar='X')
         expected = Series(['aXXXX', 'bbXXX', 'ccccX', 'ddddd', 'eeeeee'])
         tm.assert_series_equal(result, expected)
-        expected = np.array([v.ljust(5, 'X') for v in values.values])
+        expected = np.array([v.ljust(5, 'X') for v in values.values],
+                            dtype=np.object_)
         tm.assert_numpy_array_equal(result.values, expected)
 
         result = values.str.rjust(5, fillchar='X')
         expected = Series(['XXXXa', 'XXXbb', 'Xcccc', 'ddddd', 'eeeeee'])
         tm.assert_series_equal(result, expected)
-        expected = np.array([v.rjust(5, 'X') for v in values.values])
+        expected = np.array([v.rjust(5, 'X') for v in values.values],
+                            dtype=np.object_)
         tm.assert_numpy_array_equal(result.values, expected)
 
         # If fillchar is not a charatter, normal str raises TypeError
@@ -1659,13 +1674,15 @@ def test_zfill(self):
         result = values.str.zfill(5)
         expected = Series(['00001', '00022', '00aaa', '00333', '45678'])
         tm.assert_series_equal(result, expected)
-        expected = np.array([v.zfill(5) for v in values.values])
+        expected = np.array([v.zfill(5) for v in values.values],
+                            dtype=np.object_)
         tm.assert_numpy_array_equal(result.values, expected)
 
         result = values.str.zfill(3)
         expected = Series(['001', '022', 'aaa', '333', '45678'])
         tm.assert_series_equal(result, expected)
-        expected = np.array([v.zfill(3) for v in values.values])
+        expected = np.array([v.zfill(3) for v in values.values],
+                            dtype=np.object_)
         tm.assert_numpy_array_equal(result.values, expected)
 
         values = Series(['1', np.nan, 'aaa', np.nan, '45678'])
diff --git a/pandas/tests/test_testing.py b/pandas/tests/test_testing.py
index caacfc4115b68..9294bccce013f 100644
--- a/pandas/tests/test_testing.py
+++ b/pandas/tests/test_testing.py
@@ -55,9 +55,11 @@ def test_assert_almost_equal_numbers_with_mixed(self):
 
     def test_assert_almost_equal_edge_case_ndarrays(self):
         self._assert_almost_equal_both(np.array([], dtype='M8[ns]'),
-                                       np.array([], dtype='float64'))
+                                       np.array([], dtype='float64'),
+                                       check_dtype=False)
         self._assert_almost_equal_both(np.array([], dtype=str),
-                                       np.array([], dtype='int64'))
+                                       np.array([], dtype='int64'),
+                                       check_dtype=False)
 
     def test_assert_almost_equal_dicts(self):
         self._assert_almost_equal_both({'a': 1, 'b': 2}, {'a': 1, 'b': 2})
@@ -113,8 +115,13 @@ def test_assert_almost_equal_null(self):
     def test_assert_almost_equal_inf(self):
         self._assert_almost_equal_both(np.inf, np.inf)
         self._assert_almost_equal_both(np.inf, float("inf"))
-
         self._assert_not_almost_equal_both(np.inf, 0)
+        self._assert_almost_equal_both(np.array([np.inf, np.nan, -np.inf]),
+                                       np.array([np.inf, np.nan, -np.inf]))
+        self._assert_almost_equal_both(np.array([np.inf, None, -np.inf],
+                                                dtype=np.object_),
+                                       np.array([np.inf, np.nan, -np.inf],
+                                                dtype=np.object_))
 
     def test_assert_almost_equal_pandas(self):
         self.assert_almost_equal(pd.Index([1., 1.1]),
@@ -124,6 +131,11 @@ def test_assert_almost_equal_pandas(self):
         self.assert_almost_equal(pd.DataFrame({'a': [1., 1.1]}),
                                  pd.DataFrame({'a': [1., 1.100001]}))
 
+    def test_assert_almost_equal_object(self):
+        a = [pd.Timestamp('2011-01-01'), pd.Timestamp('2011-01-01')]
+        b = [pd.Timestamp('2011-01-01'), pd.Timestamp('2011-01-01')]
+        self._assert_almost_equal_both(a, b)
+
 
 class TestUtilTesting(tm.TestCase):
     _multiprocess_can_split_ = True
@@ -173,11 +185,11 @@ def test_numpy_array_equal_message(self):
             assert_almost_equal(1, 2)
 
         # array / scalar array comparison
-        expected = """(numpy array|Iterable) are different
+        expected = """numpy array are different
 
-First object is iterable, second isn't
-\\[left\\]:  \\[1\\]
-\\[right\\]: 1"""
+numpy array classes are different
+\\[left\\]:  ndarray
+\\[right\\]: int"""
 
         with assertRaisesRegexp(AssertionError, expected):
             assert_numpy_array_equal(np.array([1]), 1)
@@ -185,11 +197,11 @@ def test_numpy_array_equal_message(self):
             assert_almost_equal(np.array([1]), 1)
 
         # scalar / array comparison
-        expected = """(numpy array|Iterable) are different
+        expected = """numpy array are different
 
-Second object is iterable, first isn't
-\\[left\\]:  1
-\\[right\\]: \\[1\\]"""
+numpy array classes are different
+\\[left\\]:  int
+\\[right\\]: ndarray"""
 
         with assertRaisesRegexp(AssertionError, expected):
             assert_numpy_array_equal(1, np.array([1]))
@@ -273,6 +285,26 @@ def test_numpy_array_equal_message(self):
             assert_almost_equal(np.array([1, 2]), np.array([3, 4, 5]),
                                 obj='Index')
 
+    def test_numpy_array_equal_object_message(self):
+
+        if is_platform_windows():
+            raise nose.SkipTest("windows has incomparable line-endings "
+                                "and uses L on the shape")
+
+        a = np.array([pd.Timestamp('2011-01-01'), pd.Timestamp('2011-01-01')])
+        b = np.array([pd.Timestamp('2011-01-01'), pd.Timestamp('2011-01-02')])
+
+        expected = """numpy array are different
+
+numpy array values are different \\(50\\.0 %\\)
+\\[left\\]:  \\[2011-01-01 00:00:00, 2011-01-01 00:00:00\\]
+\\[right\\]: \\[2011-01-01 00:00:00, 2011-01-02 00:00:00\\]"""
+
+        with assertRaisesRegexp(AssertionError, expected):
+            assert_numpy_array_equal(a, b)
+        with assertRaisesRegexp(AssertionError, expected):
+            assert_almost_equal(a, b)
+
     def test_assert_almost_equal_iterable_message(self):
 
         expected = """Iterable are different
diff --git a/pandas/tests/test_tseries.py b/pandas/tests/test_tseries.py
index f3784a246eb4b..854b7295aece4 100644
--- a/pandas/tests/test_tseries.py
+++ b/pandas/tests/test_tseries.py
@@ -104,8 +104,8 @@ def test_inner_join_indexer():
     index_exp = np.array([3, 5], dtype=np.int64)
     assert_almost_equal(index, index_exp)
 
-    aexp = np.array([2, 4])
-    bexp = np.array([1, 2])
+    aexp = np.array([2, 4], dtype=np.int64)
+    bexp = np.array([1, 2], dtype=np.int64)
     assert_almost_equal(ares, aexp)
     assert_almost_equal(bres, bexp)
 
@@ -128,7 +128,7 @@ def test_outer_join_indexer():
     assert_almost_equal(index, index_exp)
 
     aexp = np.array([-1, 0, 1, 2, 3, 4, -1, -1], dtype=np.int64)
-    bexp = np.array([0, -1, -1, 1, -1, 2, 3, 4])
+    bexp = np.array([0, -1, -1, 1, -1, 2, 3, 4], dtype=np.int64)
     assert_almost_equal(ares, aexp)
     assert_almost_equal(bres, bexp)
 
diff --git a/pandas/tests/test_window.py b/pandas/tests/test_window.py
index ac46c9a287ec7..22ac583a3b808 100644
--- a/pandas/tests/test_window.py
+++ b/pandas/tests/test_window.py
@@ -863,7 +863,7 @@ def test_rolling_max(self):
             self._check_moment_func(mom.rolling_max, np.max, name='max')
 
         with tm.assert_produces_warning(FutureWarning, check_stacklevel=False):
-            a = np.array([1, 2, 3, 4, 5])
+            a = np.array([1, 2, 3, 4, 5], dtype=np.float64)
             b = mom.rolling_max(a, window=100, min_periods=1)
             assert_almost_equal(a, b)
 
diff --git a/pandas/tools/tests/test_util.py b/pandas/tools/tests/test_util.py
index 4f9dd0b316127..1c4f55b2defa4 100644
--- a/pandas/tools/tests/test_util.py
+++ b/pandas/tools/tests/test_util.py
@@ -152,7 +152,7 @@ def test_list(self):
     def test_list_numeric(self):
         s = [1, 3, 4, 5]
         res = to_numeric(s)
-        tm.assert_numpy_array_equal(res, np.array(s))
+        tm.assert_numpy_array_equal(res, np.array(s, dtype=np.int64))
 
         s = [1., 3., 4., 5.]
         res = to_numeric(s)
diff --git a/pandas/tseries/base.py b/pandas/tseries/base.py
index f1e061bb1b9bc..0f58d17f0ade4 100644
--- a/pandas/tseries/base.py
+++ b/pandas/tseries/base.py
@@ -27,7 +27,8 @@ class DatelikeOps(object):
     """ common ops for DatetimeIndex/PeriodIndex, but not TimedeltaIndex """
 
     def strftime(self, date_format):
-        return np.asarray(self.format(date_format=date_format))
+        return np.asarray(self.format(date_format=date_format),
+                          dtype=compat.text_type)
     strftime.__doc__ = """
     Return an array of formatted strings specified by date_format, which
     supports the same string format as the python standard library. Details
diff --git a/pandas/tseries/tests/test_base.py b/pandas/tseries/tests/test_base.py
index 3b10cae1ddca2..2077409f4afec 100644
--- a/pandas/tseries/tests/test_base.py
+++ b/pandas/tseries/tests/test_base.py
@@ -537,14 +537,16 @@ def test_order(self):
 
             ordered, indexer = idx.sort_values(return_indexer=True)
             self.assert_index_equal(ordered, idx)
-            self.assert_numpy_array_equal(indexer, np.array([0, 1, 2]))
+            self.assert_numpy_array_equal(indexer,
+                                          np.array([0, 1, 2], dtype=np.int64))
             self.assertEqual(ordered.freq, idx.freq)
 
             ordered, indexer = idx.sort_values(return_indexer=True,
                                                ascending=False)
             expected = idx[::-1]
             self.assert_index_equal(ordered, expected)
-            self.assert_numpy_array_equal(indexer, np.array([2, 1, 0]))
+            self.assert_numpy_array_equal(indexer,
+                                          np.array([2, 1, 0], dtype=np.int64))
             self.assertEqual(ordered.freq, expected.freq)
             self.assertEqual(ordered.freq.n, -1)
 
@@ -580,13 +582,17 @@ def test_order(self):
 
             ordered, indexer = idx.sort_values(return_indexer=True)
             self.assert_index_equal(ordered, expected)
-            self.assert_numpy_array_equal(indexer, np.array([0, 4, 3, 1, 2]))
+
+            exp = np.array([0, 4, 3, 1, 2], dtype=np.int64)
+            self.assert_numpy_array_equal(indexer, exp)
             self.assertIsNone(ordered.freq)
 
             ordered, indexer = idx.sort_values(return_indexer=True,
                                                ascending=False)
             self.assert_index_equal(ordered, expected[::-1])
-            self.assert_numpy_array_equal(indexer, np.array([2, 1, 3, 4, 0]))
+
+            exp = np.array([2, 1, 3, 4, 0], dtype=np.int64)
+            self.assert_numpy_array_equal(indexer, exp)
             self.assertIsNone(ordered.freq)
 
     def test_getitem(self):
@@ -1297,7 +1303,8 @@ def test_order(self):
 
             ordered, indexer = idx.sort_values(return_indexer=True)
             self.assert_index_equal(ordered, idx)
-            self.assert_numpy_array_equal(indexer, np.array([0, 1, 2]))
+            self.assert_numpy_array_equal(indexer,
+                                          np.array([0, 1, 2], dtype=np.int64))
             self.assertEqual(ordered.freq, idx.freq)
 
             ordered, indexer = idx.sort_values(return_indexer=True,
@@ -1334,13 +1341,17 @@ def test_order(self):
 
             ordered, indexer = idx.sort_values(return_indexer=True)
             self.assert_index_equal(ordered, expected)
-            self.assert_numpy_array_equal(indexer, np.array([0, 4, 3, 1, 2]))
+
+            exp = np.array([0, 4, 3, 1, 2], dtype=np.int64)
+            self.assert_numpy_array_equal(indexer, exp)
             self.assertIsNone(ordered.freq)
 
             ordered, indexer = idx.sort_values(return_indexer=True,
                                                ascending=False)
             self.assert_index_equal(ordered, expected[::-1])
-            self.assert_numpy_array_equal(indexer, np.array([2, 1, 3, 4, 0]))
+
+            exp = np.array([2, 1, 3, 4, 0], dtype=np.int64)
+            self.assert_numpy_array_equal(indexer, exp)
             self.assertIsNone(ordered.freq)
 
     def test_getitem(self):
@@ -2095,13 +2106,15 @@ def _check_freq(index, expected_index):
 
             ordered, indexer = idx.sort_values(return_indexer=True)
             self.assert_index_equal(ordered, idx)
-            self.assert_numpy_array_equal(indexer, np.array([0, 1, 2]))
+            self.assert_numpy_array_equal(indexer,
+                                          np.array([0, 1, 2], dtype=np.int64))
             _check_freq(ordered, idx)
 
             ordered, indexer = idx.sort_values(return_indexer=True,
                                                ascending=False)
             self.assert_index_equal(ordered, idx[::-1])
-            self.assert_numpy_array_equal(indexer, np.array([2, 1, 0]))
+            self.assert_numpy_array_equal(indexer,
+                                          np.array([2, 1, 0], dtype=np.int64))
             _check_freq(ordered, idx[::-1])
 
         pidx = PeriodIndex(['2011', '2013', '2015', '2012',
@@ -2122,13 +2135,17 @@ def _check_freq(index, expected_index):
 
             ordered, indexer = idx.sort_values(return_indexer=True)
             self.assert_index_equal(ordered, expected)
-            self.assert_numpy_array_equal(indexer, np.array([0, 4, 3, 1, 2]))
+
+            exp = np.array([0, 4, 3, 1, 2], dtype=np.int64)
+            self.assert_numpy_array_equal(indexer, exp)
             _check_freq(ordered, idx)
 
             ordered, indexer = idx.sort_values(return_indexer=True,
                                                ascending=False)
             self.assert_index_equal(ordered, expected[::-1])
-            self.assert_numpy_array_equal(indexer, np.array([2, 1, 3, 4, 0]))
+
+            exp = np.array([2, 1, 3, 4, 0], dtype=np.int64)
+            self.assert_numpy_array_equal(indexer, exp)
             _check_freq(ordered, idx)
 
         pidx = PeriodIndex(['2011', '2013', 'NaT', '2011'], name='pidx',
@@ -2163,7 +2180,8 @@ def test_order(self):
 
             ordered, indexer = idx.sort_values(return_indexer=True)
             self.assert_index_equal(ordered, idx)
-            self.assert_numpy_array_equal(indexer, np.array([0, 1, 2]))
+            self.assert_numpy_array_equal(indexer,
+                                          np.array([0, 1, 2], dtype=np.int64))
             self.assertEqual(ordered.freq, idx.freq)
             self.assertEqual(ordered.freq, freq)
 
@@ -2171,7 +2189,8 @@ def test_order(self):
                                                ascending=False)
             expected = idx[::-1]
             self.assert_index_equal(ordered, expected)
-            self.assert_numpy_array_equal(indexer, np.array([2, 1, 0]))
+            self.assert_numpy_array_equal(indexer,
+                                          np.array([2, 1, 0], dtype=np.int64))
             self.assertEqual(ordered.freq, expected.freq)
             self.assertEqual(ordered.freq, freq)
 
@@ -2204,13 +2223,17 @@ def test_order(self):
 
             ordered, indexer = idx.sort_values(return_indexer=True)
             self.assert_index_equal(ordered, expected)
-            self.assert_numpy_array_equal(indexer, np.array([0, 4, 3, 1, 2]))
+
+            exp = np.array([0, 4, 3, 1, 2], dtype=np.int64)
+            self.assert_numpy_array_equal(indexer, exp)
             self.assertEqual(ordered.freq, 'D')
 
             ordered, indexer = idx.sort_values(return_indexer=True,
                                                ascending=False)
             self.assert_index_equal(ordered, expected[::-1])
-            self.assert_numpy_array_equal(indexer, np.array([2, 1, 3, 4, 0]))
+
+            exp = np.array([2, 1, 3, 4, 0], dtype=np.int64)
+            self.assert_numpy_array_equal(indexer, exp)
             self.assertEqual(ordered.freq, 'D')
 
     def test_getitem(self):
diff --git a/pandas/tseries/tests/test_period.py b/pandas/tseries/tests/test_period.py
index debb3e7956488..b5b2ed3d911fa 100644
--- a/pandas/tseries/tests/test_period.py
+++ b/pandas/tseries/tests/test_period.py
@@ -1673,8 +1673,8 @@ def test_constructor_U(self):
                           freq='X')
 
     def test_constructor_arrays_negative_year(self):
-        years = np.arange(1960, 2000).repeat(4)
-        quarters = np.tile(lrange(1, 5), 40)
+        years = np.arange(1960, 2000, dtype=np.int64).repeat(4)
+        quarters = np.tile(np.array([1, 2, 3, 4], dtype=np.int64), 40)
 
         pindex = PeriodIndex(year=years, quarter=quarters)
 
@@ -2732,9 +2732,11 @@ def test_range_slice_outofbounds(self):
     def test_pindex_fieldaccessor_nat(self):
         idx = PeriodIndex(['2011-01', '2011-02', 'NaT',
                            '2012-03', '2012-04'], freq='D')
-        self.assert_numpy_array_equal(idx.year,
-                                      np.array([2011, 2011, -1, 2012, 2012]))
-        self.assert_numpy_array_equal(idx.month, np.array([1, 2, -1, 3, 4]))
+
+        exp = np.array([2011, 2011, -1, 2012, 2012], dtype=np.int64)
+        self.assert_numpy_array_equal(idx.year, exp)
+        exp = np.array([1, 2, -1, 3, 4], dtype=np.int64)
+        self.assert_numpy_array_equal(idx.month, exp)
 
     def test_pindex_qaccess(self):
         pi = PeriodIndex(['2Q05', '3Q05', '4Q05', '1Q06', '2Q06'], freq='Q')
diff --git a/pandas/tseries/tests/test_plotting.py b/pandas/tseries/tests/test_plotting.py
index 4a06a5500094a..c3c29a0c51316 100644
--- a/pandas/tseries/tests/test_plotting.py
+++ b/pandas/tseries/tests/test_plotting.py
@@ -790,9 +790,9 @@ def test_from_weekly_resampling(self):
         low.plot()
         ax = high.plot()
 
-        expected_h = idxh.to_period().asi8
+        expected_h = idxh.to_period().asi8.astype(np.float64)
         expected_l = np.array([1514, 1519, 1523, 1527, 1531, 1536, 1540, 1544,
-                               1549, 1553, 1558, 1562])
+                               1549, 1553, 1558, 1562], dtype=np.float64)
         for l in ax.get_lines():
             self.assertTrue(PeriodIndex(data=l.get_xdata()).freq, idxh.freq)
             xdata = l.get_xdata(orig=False)
@@ -832,30 +832,31 @@ def test_from_resampling_area_line_mixed(self):
 
             # check low dataframe result
             expected_x = np.array([1514, 1519, 1523, 1527, 1531, 1536, 1540,
-                                   1544, 1549, 1553, 1558, 1562])
-            expected_y = np.zeros(len(expected_x))
+                                   1544, 1549, 1553, 1558, 1562],
+                                  dtype=np.float64)
+            expected_y = np.zeros(len(expected_x), dtype=np.float64)
             for i in range(3):
                 l = ax.lines[i]
                 self.assertEqual(PeriodIndex(l.get_xdata()).freq, idxh.freq)
-                self.assert_numpy_array_equal(
-                    l.get_xdata(orig=False), expected_x)
+                self.assert_numpy_array_equal(l.get_xdata(orig=False),
+                                              expected_x)
                 # check stacked values are correct
                 expected_y += low[i].values
                 self.assert_numpy_array_equal(
                     l.get_ydata(orig=False), expected_y)
 
             # check high dataframe result
-            expected_x = idxh.to_period().asi8
-            expected_y = np.zeros(len(expected_x))
+            expected_x = idxh.to_period().asi8.astype(np.float64)
+            expected_y = np.zeros(len(expected_x), dtype=np.float64)
             for i in range(3):
                 l = ax.lines[3 + i]
-                self.assertEqual(PeriodIndex(
-                    data=l.get_xdata()).freq, idxh.freq)
-                self.assert_numpy_array_equal(
-                    l.get_xdata(orig=False), expected_x)
+                self.assertEqual(PeriodIndex(data=l.get_xdata()).freq,
+                                 idxh.freq)
+                self.assert_numpy_array_equal(l.get_xdata(orig=False),
+                                              expected_x)
                 expected_y += high[i].values
-                self.assert_numpy_array_equal(
-                    l.get_ydata(orig=False), expected_y)
+                self.assert_numpy_array_equal(l.get_ydata(orig=False),
+                                              expected_y)
 
         # high to low
         for kind1, kind2 in [('line', 'area'), ('area', 'line')]:
@@ -863,12 +864,12 @@ def test_from_resampling_area_line_mixed(self):
             ax = low.plot(kind=kind2, stacked=True, ax=ax)
 
             # check high dataframe result
-            expected_x = idxh.to_period().asi8
-            expected_y = np.zeros(len(expected_x))
+            expected_x = idxh.to_period().asi8.astype(np.float64)
+            expected_y = np.zeros(len(expected_x), dtype=np.float64)
             for i in range(3):
                 l = ax.lines[i]
-                self.assertEqual(PeriodIndex(
-                    data=l.get_xdata()).freq, idxh.freq)
+                self.assertEqual(PeriodIndex(data=l.get_xdata()).freq,
+                                 idxh.freq)
                 self.assert_numpy_array_equal(
                     l.get_xdata(orig=False), expected_x)
                 expected_y += high[i].values
@@ -877,17 +878,18 @@ def test_from_resampling_area_line_mixed(self):
 
             # check low dataframe result
             expected_x = np.array([1514, 1519, 1523, 1527, 1531, 1536, 1540,
-                                   1544, 1549, 1553, 1558, 1562])
-            expected_y = np.zeros(len(expected_x))
+                                   1544, 1549, 1553, 1558, 1562],
+                                  dtype=np.float64)
+            expected_y = np.zeros(len(expected_x), dtype=np.float64)
             for i in range(3):
                 l = ax.lines[3 + i]
-                self.assertEqual(PeriodIndex(
-                    data=l.get_xdata()).freq, idxh.freq)
-                self.assert_numpy_array_equal(
-                    l.get_xdata(orig=False), expected_x)
+                self.assertEqual(PeriodIndex(data=l.get_xdata()).freq,
+                                 idxh.freq)
+                self.assert_numpy_array_equal(l.get_xdata(orig=False),
+                                              expected_x)
                 expected_y += low[i].values
-                self.assert_numpy_array_equal(
-                    l.get_ydata(orig=False), expected_y)
+                self.assert_numpy_array_equal(l.get_ydata(orig=False),
+                                              expected_y)
 
     @slow
     def test_mixed_freq_second_millisecond(self):
@@ -1125,10 +1127,11 @@ def test_mpl_nopandas(self):
         ax.plot_date([x.toordinal() for x in dates], values2, **kw)
 
         line1, line2 = ax.get_lines()
-        tm.assert_numpy_array_equal(np.array([x.toordinal() for x in dates]),
-                                    line1.get_xydata()[:, 0])
-        tm.assert_numpy_array_equal(np.array([x.toordinal() for x in dates]),
-                                    line2.get_xydata()[:, 0])
+
+        exp = np.array([x.toordinal() for x in dates], dtype=np.float64)
+        tm.assert_numpy_array_equal(line1.get_xydata()[:, 0], exp)
+        exp = np.array([x.toordinal() for x in dates], dtype=np.float64)
+        tm.assert_numpy_array_equal(line2.get_xydata()[:, 0], exp)
 
     @slow
     def test_irregular_ts_shared_ax_xlim(self):
diff --git a/pandas/tseries/tests/test_timedeltas.py b/pandas/tseries/tests/test_timedeltas.py
index 8f55a68a6a27a..c764f34b697c1 100644
--- a/pandas/tseries/tests/test_timedeltas.py
+++ b/pandas/tseries/tests/test_timedeltas.py
@@ -387,9 +387,11 @@ def test_ops_ndarray(self):
         self.assertRaises(TypeError, lambda: td * other)
         self.assertRaises(TypeError, lambda: other * td)
 
-        self.assert_numpy_array_equal(td / other, np.array([1]))
+        self.assert_numpy_array_equal(td / other,
+                                      np.array([1], dtype=np.float64))
         if LooseVersion(np.__version__) >= '1.8':
-            self.assert_numpy_array_equal(other / td, np.array([1]))
+            self.assert_numpy_array_equal(other / td,
+                                          np.array([1], dtype=np.float64))
 
         # timedelta, datetime
         other = pd.to_datetime(['2000-01-01']).values
diff --git a/pandas/tseries/tests/test_timeseries.py b/pandas/tseries/tests/test_timeseries.py
index 37e708df2595d..3d8e389ba30f2 100644
--- a/pandas/tseries/tests/test_timeseries.py
+++ b/pandas/tseries/tests/test_timeseries.py
@@ -3765,7 +3765,8 @@ def test_datetimeindex_accessors(self):
     def test_nanosecond_field(self):
         dti = DatetimeIndex(np.arange(10))
 
-        self.assert_numpy_array_equal(dti.nanosecond, np.arange(10))
+        self.assert_numpy_array_equal(dti.nanosecond,
+                                      np.arange(10, dtype=np.int32))
 
     def test_datetimeindex_diff(self):
         dti1 = DatetimeIndex(freq='Q-JAN', start=datetime(1997, 12, 31),
diff --git a/pandas/tseries/tests/test_timezones.py b/pandas/tseries/tests/test_timezones.py
index 3961a8b99b4dd..cd1ce5904738a 100644
--- a/pandas/tseries/tests/test_timezones.py
+++ b/pandas/tseries/tests/test_timezones.py
@@ -363,7 +363,7 @@ def test_field_access_localize(self):
         dr = date_range('2011-10-02 00:00', freq='h', periods=10,
                         tz=self.tzstr('America/Atikokan'))
 
-        expected = np.arange(10)
+        expected = np.arange(10, dtype=np.int32)
         self.assert_numpy_array_equal(dr.hour, expected)
 
     def test_with_tz(self):
@@ -890,7 +890,8 @@ def test_tslib_tz_convert_trans_pos_plus_1__bug(self):
             idx = idx.tz_localize('UTC')
             idx = idx.tz_convert('Europe/Moscow')
 
-            expected = np.repeat(np.array([3, 4, 5]), np.array([n, n, 1]))
+            expected = np.repeat(np.array([3, 4, 5], dtype=np.int32),
+                                 np.array([n, n, 1]))
             self.assert_numpy_array_equal(idx.hour, expected)
 
     def test_tslib_tz_convert_dst(self):
@@ -900,14 +901,15 @@ def test_tslib_tz_convert_dst(self):
                              tz='UTC')
             idx = idx.tz_convert('US/Eastern')
             expected = np.repeat(np.array([18, 19, 20, 21, 22, 23,
-                                           0, 1, 3, 4, 5]),
+                                           0, 1, 3, 4, 5], dtype=np.int32),
                                  np.array([n, n, n, n, n, n, n, n, n, n, 1]))
             self.assert_numpy_array_equal(idx.hour, expected)
 
             idx = date_range('2014-03-08 18:00', '2014-03-09 05:00', freq=freq,
                              tz='US/Eastern')
             idx = idx.tz_convert('UTC')
-            expected = np.repeat(np.array([23, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9]),
+            expected = np.repeat(np.array([23, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9],
+                                          dtype=np.int32),
                                  np.array([n, n, n, n, n, n, n, n, n, n, 1]))
             self.assert_numpy_array_equal(idx.hour, expected)
 
@@ -916,7 +918,7 @@ def test_tslib_tz_convert_dst(self):
                              tz='UTC')
             idx = idx.tz_convert('US/Eastern')
             expected = np.repeat(np.array([19, 20, 21, 22, 23,
-                                           0, 1, 1, 2, 3, 4]),
+                                           0, 1, 1, 2, 3, 4], dtype=np.int32),
                                  np.array([n, n, n, n, n, n, n, n, n, n, 1]))
             self.assert_numpy_array_equal(idx.hour, expected)
 
@@ -924,7 +926,7 @@ def test_tslib_tz_convert_dst(self):
                              tz='US/Eastern')
             idx = idx.tz_convert('UTC')
             expected = np.repeat(np.array([22, 23, 0, 1, 2, 3, 4, 5, 6,
-                                           7, 8, 9, 10]),
+                                           7, 8, 9, 10], dtype=np.int32),
                                  np.array([n, n, n, n, n, n, n, n, n,
                                            n, n, n, 1]))
             self.assert_numpy_array_equal(idx.hour, expected)
@@ -934,23 +936,27 @@ def test_tslib_tz_convert_dst(self):
         idx = date_range('2014-03-08 00:00', '2014-03-09 00:00', freq='D',
                          tz='UTC')
         idx = idx.tz_convert('US/Eastern')
-        self.assert_numpy_array_equal(idx.hour, np.array([19, 19]))
+        self.assert_numpy_array_equal(idx.hour,
+                                      np.array([19, 19], dtype=np.int32))
 
         idx = date_range('2014-03-08 00:00', '2014-03-09 00:00', freq='D',
                          tz='US/Eastern')
         idx = idx.tz_convert('UTC')
-        self.assert_numpy_array_equal(idx.hour, np.array([5, 5]))
+        self.assert_numpy_array_equal(idx.hour,
+                                      np.array([5, 5], dtype=np.int32))
 
         # End DST
         idx = date_range('2014-11-01 00:00', '2014-11-02 00:00', freq='D',
                          tz='UTC')
         idx = idx.tz_convert('US/Eastern')
-        self.assert_numpy_array_equal(idx.hour, np.array([20, 20]))
+        self.assert_numpy_array_equal(idx.hour,
+                                      np.array([20, 20], dtype=np.int32))
 
         idx = date_range('2014-11-01 00:00', '2014-11-02 000:00', freq='D',
                          tz='US/Eastern')
         idx = idx.tz_convert('UTC')
-        self.assert_numpy_array_equal(idx.hour, np.array([4, 4]))
+        self.assert_numpy_array_equal(idx.hour,
+                                      np.array([4, 4], dtype=np.int32))
 
 
 class TestTimeZoneCacheKey(tm.TestCase):
diff --git a/pandas/tseries/tests/test_tslib.py b/pandas/tseries/tests/test_tslib.py
index b2311bf4d6661..8a420158039de 100644
--- a/pandas/tseries/tests/test_tslib.py
+++ b/pandas/tseries/tests/test_tslib.py
@@ -733,16 +733,18 @@ def test_parsers_time(self):
                          expected_arr)
         self.assertEqual(tools.to_time(arg, format="%I:%M%p", errors="coerce"),
                          [None, None])
-        self.assert_numpy_array_equal(tools.to_time(arg, format="%I:%M%p",
-                                                    errors="ignore"),
-                                      np.array(arg))
-        self.assertRaises(ValueError,
-                          lambda: tools.to_time(arg, format="%I:%M%p",
-                                                errors="raise"))
+
+        res = tools.to_time(arg, format="%I:%M%p", errors="ignore")
+        self.assert_numpy_array_equal(res, np.array(arg, dtype=np.object_))
+
+        with tm.assertRaises(ValueError):
+            tools.to_time(arg, format="%I:%M%p", errors="raise")
+
         self.assert_series_equal(tools.to_time(Series(arg, name="test")),
                                  Series(expected_arr, name="test"))
+
         self.assert_numpy_array_equal(tools.to_time(np.array(arg)),
-                                      np.array(expected_arr))
+                                      np.array(expected_arr, dtype=np.object_))
 
     def test_parsers_monthfreq(self):
         cases = {'201101': datetime.datetime(2011, 1, 1, 0, 0),
diff --git a/pandas/util/testing.py b/pandas/util/testing.py
index eb1d5c6c2d0d0..e1e8159a7627f 100644
--- a/pandas/util/testing.py
+++ b/pandas/util/testing.py
@@ -682,21 +682,8 @@ def assert_index_equal(left, right, exact='equiv', check_names=True,
 
     def _check_types(l, r, obj='Index'):
         if exact:
-
-            if exact == 'equiv':
-                if type(l) != type(r):
-                    # allow equivalence of Int64Index/RangeIndex
-                    types = set([type(l).__name__, type(r).__name__])
-                    if len(types - set(['Int64Index', 'RangeIndex'])):
-                        msg = '{0} classes are not equivalent'.format(obj)
-                        raise_assert_detail(obj, msg, l, r)
-            else:
-                if type(l) != type(r):
-                    msg = '{0} classes are different'.format(obj)
-                    raise_assert_detail(obj, msg, l, r)
-
+            assert_class_equal(left, right, exact=exact, obj=obj)
             assert_attr_equal('dtype', l, r, obj=obj)
-
             # allow string-like to have different inferred_types
             if l.inferred_type in ('string', 'unicode'):
                 assertIn(r.inferred_type, ('string', 'unicode'))
@@ -758,6 +745,7 @@ def _get_ilevel_values(index, level):
     else:
         _testing.assert_almost_equal(left.values, right.values,
                                      check_less_precise=check_less_precise,
+                                     check_dtype=exact,
                                      obj=obj, lobj=left, robj=right)
 
     # metadata comparison
@@ -765,6 +753,34 @@ def _get_ilevel_values(index, level):
         assert_attr_equal('names', left, right, obj=obj)
 
 
+def assert_class_equal(left, right, exact=True, obj='Input'):
+    """checks classes are equal."""
+
+    def repr_class(x):
+        if isinstance(x, Index):
+            # return Index as it is to include values in the error message
+            return x
+
+        try:
+            return x.__class__.__name__
+        except AttributeError:
+            return repr(type(x))
+
+    if exact == 'equiv':
+        if type(left) != type(right):
+            # allow equivalence of Int64Index/RangeIndex
+            types = set([type(left).__name__, type(right).__name__])
+            if len(types - set(['Int64Index', 'RangeIndex'])):
+                msg = '{0} classes are not equivalent'.format(obj)
+                raise_assert_detail(obj, msg, repr_class(left),
+                                    repr_class(right))
+    elif exact:
+        if type(left) != type(right):
+            msg = '{0} classes are different'.format(obj)
+            raise_assert_detail(obj, msg, repr_class(left),
+                                repr_class(right))
+
+
 def assert_attr_equal(attr, left, right, obj='Attributes'):
     """checks attributes are equal. Both objects must have attribute.
 
@@ -915,54 +931,65 @@ def raise_assert_detail(obj, message, left, right):
     raise AssertionError(msg)
 
 
-def assert_numpy_array_equal(left, right,
-                             strict_nan=False, err_msg=None,
+def assert_numpy_array_equal(left, right, strict_nan=False,
+                             check_dtype=True, err_msg=None,
                              obj='numpy array'):
-    """Checks that 'np_array' is equivalent to 'assert_equal'.
+    """ Checks that 'np.ndarray' is equivalent
 
-    This is similar to ``numpy.testing.assert_array_equal``, but can
-    check equality including ``np.nan``. Two numpy arrays are regarded as
-    equivalent if the arrays have equal non-NaN elements,
-    and `np.nan` in corresponding locations.
+    Parameters
+    ----------
+    left : np.ndarray or iterable
+    right : np.ndarray or iterable
+    strict_nan : bool, default False
+        If True, consider NaN and None to be different.
+    check_dtype: bool, default True
+        check dtype if both a and b are np.ndarray
+    err_msg : str, default None
+        If provided, used as assertion message
+    obj : str, default 'numpy array'
+        Specify object name being compared, internally used to show appropriate
+        assertion message
     """
 
-    # compare shape and values
-    if array_equivalent(left, right, strict_nan=strict_nan):
-        return True
-
-    if err_msg is None:
-        # show detailed error
-
-        if lib.isscalar(left) and lib.isscalar(right):
-            # show scalar comparison error
-            assert_equal(left, right)
-        elif is_list_like(left) and is_list_like(right):
-            # some test cases pass list
-            left = np.asarray(left)
-            right = np.array(right)
+    def _raise(left, right, err_msg):
+        if err_msg is None:
+            # show detailed error
+            if lib.isscalar(left) and lib.isscalar(right):
+                # show scalar comparison error
+                assert_equal(left, right)
+            elif is_list_like(left) and is_list_like(right):
+                # some test cases pass list
+                left = np.asarray(left)
+                right = np.array(right)
+
+                if left.shape != right.shape:
+                    raise_assert_detail(obj, '{0} shapes are different'
+                                        .format(obj), left.shape, right.shape)
+
+                diff = 0
+                for l, r in zip(left, right):
+                    # count up differences
+                    if not array_equivalent(l, r, strict_nan=strict_nan):
+                        diff += 1
+
+                diff = diff * 100.0 / left.size
+                msg = '{0} values are different ({1} %)'\
+                    .format(obj, np.round(diff, 5))
+                raise_assert_detail(obj, msg, left, right)
+            else:
+                assert_class_equal(left, right, obj=obj)
 
-            if left.shape != right.shape:
-                raise_assert_detail(obj, '{0} shapes are different'
-                                    .format(obj), left.shape, right.shape)
+        raise AssertionError(err_msg)
 
-            diff = 0
-            for l, r in zip(left, right):
-                # count up differences
-                if not array_equivalent(l, r, strict_nan=strict_nan):
-                    diff += 1
+    # compare shape and values
+    if not array_equivalent(left, right, strict_nan=strict_nan):
+        _raise(left, right, err_msg)
 
-            diff = diff * 100.0 / left.size
-            msg = '{0} values are different ({1} %)'\
-                .format(obj, np.round(diff, 5))
-            raise_assert_detail(obj, msg, left, right)
-        elif is_list_like(left):
-            msg = "First object is iterable, second isn't"
-            raise_assert_detail(obj, msg, left, right)
-        else:
-            msg = "Second object is iterable, first isn't"
-            raise_assert_detail(obj, msg, left, right)
+    if check_dtype:
+        if isinstance(left, np.ndarray) and isinstance(right, np.ndarray):
+            assert_attr_equal('dtype', left, right, obj=obj)
 
-    raise AssertionError(err_msg)
+    return True
 
 
 # This could be refactored to use the NDFrame.equals method
@@ -1007,7 +1034,10 @@ def assert_series_equal(left, right, check_dtype=True,
     assertIsInstance(right, Series, '[Series] ')
 
     if check_series_type:
+        # ToDo: There are some tests using rhs is sparse
+        # lhs is dense. Should use assert_class_equal in future
         assertIsInstance(left, type(right))
+        # assert_class_equal(left, right, obj=obj)
 
     # length comparison
     if len(left) != len(right):
@@ -1027,7 +1057,8 @@ def assert_series_equal(left, right, check_dtype=True,
 
     if check_exact:
         assert_numpy_array_equal(left.get_values(), right.get_values(),
-                                 obj='{0}'.format(obj))
+                                 obj='{0}'.format(obj),
+                                 check_dtype=check_dtype)
     elif check_datetimelike_compat:
         # we want to check only if we have compat dtypes
         # e.g. integer and M|m are NOT compat, but we can simply check
@@ -1043,10 +1074,13 @@ def assert_series_equal(left, right, check_dtype=True,
                 msg = '[datetimelike_compat=True] {0} is not equal to {1}.'
                 raise AssertionError(msg.format(left.values, right.values))
         else:
-            assert_numpy_array_equal(left.values, right.values)
+            assert_numpy_array_equal(left.values, right.values,
+                                     check_dtype=check_dtype)
     else:
         _testing.assert_almost_equal(left.get_values(), right.get_values(),
-                                     check_less_precise, obj='{0}'.format(obj))
+                                     check_less_precise,
+                                     check_dtype=check_dtype,
+                                     obj='{0}'.format(obj))
 
     # metadata comparison
     if check_names:
@@ -1106,7 +1140,10 @@ def assert_frame_equal(left, right, check_dtype=True,
     assertIsInstance(right, DataFrame, '[DataFrame] ')
 
     if check_frame_type:
+        # ToDo: There are some tests using rhs is SparseDataFrame
+        # lhs is DataFrame. Should use assert_class_equal in future
         assertIsInstance(left, type(right))
+        # assert_class_equal(left, right, obj=obj)
 
     if check_like:
         left, right = left.reindex_like(right), right
@@ -1172,7 +1209,7 @@ def assert_panelnd_equal(left, right,
                          assert_func=assert_frame_equal,
                          check_names=False):
     if check_panel_type:
-        assertIsInstance(left, type(right))
+        assert_class_equal(left, right, obj=obj)
 
     for axis in ['items', 'major_axis', 'minor_axis']:
         left_ind = getattr(left, axis)
@@ -1204,7 +1241,7 @@ def assert_sp_array_equal(left, right):
     assertIsInstance(left, pd.SparseArray, '[SparseArray]')
     assertIsInstance(right, pd.SparseArray, '[SparseArray]')
 
-    assert_almost_equal(left.sp_values, right.sp_values)
+    assert_numpy_array_equal(left.sp_values, right.sp_values)
 
     # SparseIndex comparison
     assertIsInstance(left.sp_index, pd._sparse.SparseIndex, '[SparseIndex]')