diff --git a/pandas/computation/tests/test_eval.py b/pandas/computation/tests/test_eval.py
index 0c07dc5c214b4..8f82e2eaea711 100644
--- a/pandas/computation/tests/test_eval.py
+++ b/pandas/computation/tests/test_eval.py
@@ -1207,7 +1207,9 @@ def f():
             a = 1
             old_a = df.a.copy()
             df.eval('a = a + b')
-            assert_series_equal(old_a + df.b, df.a)
+            result = old_a + df.b
+            assert_series_equal(result, df.a, check_names=False)
+            self.assertTrue(result.name is None)
 
         f()
 
@@ -1251,7 +1253,7 @@ def test_date_boolean(self):
         res = self.eval('df.dates1 < 20130101', local_dict={'df': df},
                         engine=self.engine, parser=self.parser)
         expec = df.dates1 < '20130101'
-        assert_series_equal(res, expec)
+        assert_series_equal(res, expec, check_names=False)
 
     def test_simple_in_ops(self):
         if self.parser != 'python':
diff --git a/pandas/io/tests/test_json/test_pandas.py b/pandas/io/tests/test_json/test_pandas.py
index 26fae0717f956..39f645aef0154 100644
--- a/pandas/io/tests/test_json/test_pandas.py
+++ b/pandas/io/tests/test_json/test_pandas.py
@@ -409,12 +409,10 @@ def _check_orient(series, orient, dtype=None, numpy=False):
             if orient == "records" or orient == "values":
                 assert_almost_equal(series.values, unser.values)
             else:
-                try:
-                    assert_series_equal(series, unser)
-                except:
-                    raise
                 if orient == "split":
-                    self.assertEqual(series.name, unser.name)
+                    assert_series_equal(series, unser)
+                else:
+                    assert_series_equal(series, unser, check_names=False)
 
         def _check_all_orients(series, dtype=None):
             _check_orient(series, "columns", dtype=dtype)
@@ -491,7 +489,8 @@ def test_axis_dates(self):
         # series
         json = self.ts.to_json()
         result = read_json(json, typ='series')
-        assert_series_equal(result, self.ts)
+        assert_series_equal(result, self.ts, check_names=False)
+        self.assertTrue(result.name is None)
 
     def test_convert_dates(self):
 
diff --git a/pandas/io/tests/test_parsers.py b/pandas/io/tests/test_parsers.py
index 7d52c6ad4cb3b..1177149e7efa6 100755
--- a/pandas/io/tests/test_parsers.py
+++ b/pandas/io/tests/test_parsers.py
@@ -272,7 +272,8 @@ def test_squeeze(self):
 b,2
 c,3
 """
-        expected = Series([1, 2, 3], index=Index(['a', 'b', 'c'], name=0))
+        idx = Index(['a', 'b', 'c'], name=0)
+        expected = Series([1, 2, 3], name=1, index=idx)
         result = self.read_table(StringIO(data), sep=',', index_col=0,
                                  header=None, squeeze=True)
         tm.assert_isinstance(result, Series)
@@ -2638,7 +2639,7 @@ def test_iteration_open_handle(self):
                 result = read_table(f, squeeze=True, header=None,
                                     engine='python')
 
-                expected = Series(['DDD', 'EEE', 'FFF', 'GGG'])
+                expected = Series(['DDD', 'EEE', 'FFF', 'GGG'], name=0)
                 tm.assert_series_equal(result, expected)
 
     def test_iterator(self):
diff --git a/pandas/io/tests/test_sql.py b/pandas/io/tests/test_sql.py
index 9576f80696350..54d53c909d9ca 100644
--- a/pandas/io/tests/test_sql.py
+++ b/pandas/io/tests/test_sql.py
@@ -1256,7 +1256,7 @@ def test_transactions(self):
         self._transaction_test()
 
     def test_get_schema_create_table(self):
-        # Use a dataframe without a bool column, since MySQL converts bool to 
+        # Use a dataframe without a bool column, since MySQL converts bool to
         # TINYINT (which read_sql_table returns as an int and causes a dtype
         # mismatch)
 
@@ -2025,7 +2025,7 @@ def test_tquery(self):
         frame = tm.makeTimeDataFrame()
         sql.write_frame(frame, name='test_table', con=self.db)
         result = sql.tquery("select A from test_table", self.db)
-        expected = Series(frame.A, frame.index) # not to have name
+        expected = Series(frame.A.values, frame.index) # not to have name
         result = Series(result, frame.index)
         tm.assert_series_equal(result, expected)
 
@@ -2370,7 +2370,7 @@ def test_tquery(self):
         cur.execute(drop_sql)
         sql.write_frame(frame, name='test_table', con=self.db, flavor='mysql')
         result = sql.tquery("select A from test_table", self.db)
-        expected = Series(frame.A, frame.index) # not to have name
+        expected = Series(frame.A.values, frame.index) # not to have name
         result = Series(result, frame.index)
         tm.assert_series_equal(result, expected)
 
diff --git a/pandas/sparse/tests/test_sparse.py b/pandas/sparse/tests/test_sparse.py
index 96e5ff87fbb0c..b506758355228 100644
--- a/pandas/sparse/tests/test_sparse.py
+++ b/pandas/sparse/tests/test_sparse.py
@@ -12,7 +12,8 @@
 dec = np.testing.dec
 
 from pandas.util.testing import (assert_almost_equal, assert_series_equal,
-                                 assert_frame_equal, assert_panel_equal, assertRaisesRegexp, assert_array_equal)
+                                 assert_frame_equal, assert_panel_equal, assertRaisesRegexp,
+                                 assert_array_equal, assert_attr_equal)
 from numpy.testing import assert_equal
 
 from pandas import Series, DataFrame, bdate_range, Panel, MultiIndex
@@ -76,9 +77,11 @@ def _test_data2_zero():
     return arr, index
 
 
-def assert_sp_series_equal(a, b, exact_indices=True):
+def assert_sp_series_equal(a, b, exact_indices=True, check_names=True):
     assert(a.index.equals(b.index))
     assert_sp_array_equal(a, b)
+    if check_names:
+        assert_attr_equal('name', a, b)
 
 
 def assert_sp_frame_equal(left, right, exact_indices=True):
@@ -130,7 +133,6 @@ def setUp(self):
 
         self.bseries = SparseSeries(arr, index=index, kind='block',
                                     name='bseries')
-
         self.ts = self.bseries
 
         self.btseries = SparseSeries(arr, index=date_index, kind='block')
@@ -168,10 +170,10 @@ def test_construct_DataFrame_with_sp_series(self):
         df.dtypes
         str(df)
 
-        assert_sp_series_equal(df['col'], self.bseries)
+        assert_sp_series_equal(df['col'], self.bseries, check_names=False)
 
         result = df.iloc[:, 0]
-        assert_sp_series_equal(result, self.bseries)
+        assert_sp_series_equal(result, self.bseries, check_names=False)
 
         # blocking
         expected = Series({'col': 'float64:sparse'})
@@ -209,14 +211,16 @@ def test_dense_to_sparse(self):
         bseries = series.to_sparse(kind='block')
         iseries = series.to_sparse(kind='integer')
         assert_sp_series_equal(bseries, self.bseries)
-        assert_sp_series_equal(iseries, self.iseries)
+        assert_sp_series_equal(iseries, self.iseries, check_names=False)
+        self.assertEqual(iseries.name, self.bseries.name)
 
         # non-NaN fill value
         series = self.zbseries.to_dense()
         zbseries = series.to_sparse(kind='block', fill_value=0)
         ziseries = series.to_sparse(kind='integer', fill_value=0)
         assert_sp_series_equal(zbseries, self.zbseries)
-        assert_sp_series_equal(ziseries, self.ziseries)
+        assert_sp_series_equal(ziseries, self.ziseries, check_names=False)
+        self.assertEqual(ziseries.name, self.zbseries.name)
 
     def test_to_dense_preserve_name(self):
         assert(self.bseries.name is not None)
@@ -244,7 +248,7 @@ def _check_const(sparse, name):
 
             # use passed name
             result = SparseSeries(sparse, name='x')
-            assert_sp_series_equal(result, sparse)
+            assert_sp_series_equal(result, sparse, check_names=False)
             self.assertEqual(result.name, 'x')
 
         _check_const(self.bseries, 'bseries')
@@ -1301,7 +1305,7 @@ def _check_frame(frame):
             # insert SparseSeries
             frame['E'] = frame['A']
             tm.assert_isinstance(frame['E'], SparseSeries)
-            assert_sp_series_equal(frame['E'], frame['A'])
+            assert_sp_series_equal(frame['E'], frame['A'], check_names=False)
 
             # insert SparseSeries differently-indexed
             to_insert = frame['A'][::2]
@@ -1315,13 +1319,14 @@ def _check_frame(frame):
             # insert Series
             frame['F'] = frame['A'].to_dense()
             tm.assert_isinstance(frame['F'], SparseSeries)
-            assert_sp_series_equal(frame['F'], frame['A'])
+            assert_sp_series_equal(frame['F'], frame['A'], check_names=False)
 
             # insert Series differently-indexed
             to_insert = frame['A'].to_dense()[::2]
             frame['G'] = to_insert
             expected = to_insert.reindex(
                 frame.index).fillna(frame.default_fill_value)
+            expected.name = 'G'
             assert_series_equal(frame['G'].to_dense(), expected)
 
             # insert ndarray
@@ -1349,18 +1354,18 @@ def _check_frame(frame):
 
     def test_setitem_corner(self):
         self.frame['a'] = self.frame['B']
-        assert_sp_series_equal(self.frame['a'], self.frame['B'])
+        assert_sp_series_equal(self.frame['a'], self.frame['B'], check_names=False)
 
     def test_setitem_array(self):
         arr = self.frame['B']
 
         self.frame['E'] = arr
-        assert_sp_series_equal(self.frame['E'], self.frame['B'])
+        assert_sp_series_equal(self.frame['E'], self.frame['B'], check_names=False)
 
         self.frame['F'] = arr[:-1]
         index = self.frame.index[:-1]
-        assert_sp_series_equal(
-            self.frame['E'].reindex(index), self.frame['F'].reindex(index))
+        assert_sp_series_equal(self.frame['E'].reindex(index),
+                               self.frame['F'].reindex(index), check_names=False)
 
     def test_delitem(self):
         A = self.frame['A']
diff --git a/pandas/tests/test_categorical.py b/pandas/tests/test_categorical.py
index 21b64378cfc24..bec688db99114 100755
--- a/pandas/tests/test_categorical.py
+++ b/pandas/tests/test_categorical.py
@@ -1233,7 +1233,7 @@ def test_codes_dtypes(self):
     def test_basic(self):
 
         # test basic creation / coercion of categoricals
-        s = Series(self.factor,name='A')
+        s = Series(self.factor, name='A')
         self.assertEqual(s.dtype,'category')
         self.assertEqual(len(s),len(self.factor))
         str(s.values)
@@ -1260,8 +1260,9 @@ def test_basic(self):
         df = DataFrame({'A' : s, 'B' : s, 'C' : 1})
         result1 = df['A']
         result2 = df['B']
-        tm.assert_series_equal(result1,s)
-        tm.assert_series_equal(result2,s)
+        tm.assert_series_equal(result1, s)
+        tm.assert_series_equal(result2, s, check_names=False)
+        self.assertEqual(result2.name, 'B')
         self.assertEqual(len(df),len(self.factor))
         str(df.values)
         str(df)
@@ -1344,23 +1345,23 @@ def test_construction_frame(self):
         # GH8626
 
         # dict creation
-        df = DataFrame({ 'A' : list('abc') },dtype='category')
-        expected = Series(list('abc'),dtype='category')
-        tm.assert_series_equal(df['A'],expected)
+        df = DataFrame({ 'A' : list('abc') }, dtype='category')
+        expected = Series(list('abc'), dtype='category', name='A')
+        tm.assert_series_equal(df['A'], expected)
 
         # to_frame
-        s = Series(list('abc'),dtype='category')
+        s = Series(list('abc'), dtype='category')
         result = s.to_frame()
-        expected = Series(list('abc'),dtype='category')
-        tm.assert_series_equal(result[0],expected)
+        expected = Series(list('abc'), dtype='category', name=0)
+        tm.assert_series_equal(result[0], expected)
         result = s.to_frame(name='foo')
-        expected = Series(list('abc'),dtype='category')
-        tm.assert_series_equal(result['foo'],expected)
+        expected = Series(list('abc'), dtype='category', name='foo')
+        tm.assert_series_equal(result['foo'], expected)
 
         # list-like creation
-        df = DataFrame(list('abc'),dtype='category')
-        expected = Series(list('abc'),dtype='category')
-        tm.assert_series_equal(df[0],expected)
+        df = DataFrame(list('abc'), dtype='category')
+        expected = Series(list('abc'), dtype='category', name=0)
+        tm.assert_series_equal(df[0], expected)
 
         # ndim != 1
         df = DataFrame([pd.Categorical(list('abc'))])
@@ -1833,7 +1834,11 @@ def f(x):
         # Monotonic
         df = DataFrame({"a": [5, 15, 25]})
         c = pd.cut(df.a, bins=[0,10,20,30,40])
-        tm.assert_series_equal(df.a.groupby(c).transform(sum), df['a'])
+
+        result = df.a.groupby(c).transform(sum)
+        tm.assert_series_equal(result, df['a'], check_names=False)
+        self.assertTrue(result.name is None)
+
         tm.assert_series_equal(df.a.groupby(c).transform(lambda xs: np.sum(xs)), df['a'])
         tm.assert_frame_equal(df.groupby(c).transform(sum), df[['a']])
         tm.assert_frame_equal(df.groupby(c).transform(lambda xs: np.max(xs)), df[['a']])
@@ -1845,7 +1850,11 @@ def f(x):
         # Non-monotonic
         df = DataFrame({"a": [5, 15, 25, -5]})
         c = pd.cut(df.a, bins=[-10, 0,10,20,30,40])
-        tm.assert_series_equal(df.a.groupby(c).transform(sum), df['a'])
+
+        result = df.a.groupby(c).transform(sum)
+        tm.assert_series_equal(result, df['a'], check_names=False)
+        self.assertTrue(result.name is None)
+
         tm.assert_series_equal(df.a.groupby(c).transform(lambda xs: np.sum(xs)), df['a'])
         tm.assert_frame_equal(df.groupby(c).transform(sum), df[['a']])
         tm.assert_frame_equal(df.groupby(c).transform(lambda xs: np.sum(xs)), df[['a']])
@@ -1983,19 +1992,19 @@ def test_slicing(self):
         df = DataFrame({'value': (np.arange(100)+1).astype('int64')})
         df['D'] = pd.cut(df.value, bins=[0,25,50,75,100])
 
-        expected = Series([11,'(0, 25]'],index=['value','D'])
+        expected = Series([11,'(0, 25]'], index=['value','D'], name=10)
         result = df.iloc[10]
-        tm.assert_series_equal(result,expected)
+        tm.assert_series_equal(result, expected)
 
         expected = DataFrame({'value': np.arange(11,21).astype('int64')},
                              index=np.arange(10,20).astype('int64'))
         expected['D'] = pd.cut(expected.value, bins=[0,25,50,75,100])
         result = df.iloc[10:20]
-        tm.assert_frame_equal(result,expected)
+        tm.assert_frame_equal(result, expected)
 
-        expected = Series([9,'(0, 25]'],index=['value','D'])
+        expected = Series([9,'(0, 25]'],index=['value', 'D'], name=8)
         result = df.loc[8]
-        tm.assert_series_equal(result,expected)
+        tm.assert_series_equal(result, expected)
 
     def test_slicing_and_getting_ops(self):
 
@@ -2151,7 +2160,8 @@ def test_slicing_doc_examples(self):
         tm.assert_series_equal(result, expected)
 
         result = df.loc["h":"j","cats"]
-        expected = Series(Categorical(['a','b','b'],categories=['a','b','c']),index=['h','i','j'])
+        expected = Series(Categorical(['a','b','b'], name='cats',
+                          categories=['a','b','c']), index=['h','i','j'])
         tm.assert_series_equal(result, expected)
 
         result = df.ix["h":"j",0:1]
@@ -2832,21 +2842,21 @@ def test_to_records(self):
         # GH8626
 
         # dict creation
-        df = DataFrame({ 'A' : list('abc') },dtype='category')
-        expected = Series(list('abc'),dtype='category')
-        tm.assert_series_equal(df['A'],expected)
+        df = DataFrame({ 'A' : list('abc') }, dtype='category')
+        expected = Series(list('abc'), dtype='category', name='A')
+        tm.assert_series_equal(df['A'], expected)
 
         # list-like creation
-        df = DataFrame(list('abc'),dtype='category')
-        expected = Series(list('abc'),dtype='category')
-        tm.assert_series_equal(df[0],expected)
+        df = DataFrame(list('abc'), dtype='category')
+        expected = Series(list('abc'), dtype='category', name=0)
+        tm.assert_series_equal(df[0], expected)
 
         # to record array
         # this coerces
         result = df.to_records()
         expected = np.rec.array([(0, 'a'), (1, 'b'), (2, 'c')],
                                 dtype=[('index', '<i8'), ('0', 'O')])
-        tm.assert_almost_equal(result,expected)
+        tm.assert_almost_equal(result, expected)
 
     def test_numeric_like_ops(self):
 
diff --git a/pandas/tests/test_frame.py b/pandas/tests/test_frame.py
index f74cb07557342..33614b7d87c0f 100644
--- a/pandas/tests/test_frame.py
+++ b/pandas/tests/test_frame.py
@@ -189,8 +189,8 @@ def test_setitem_list(self):
         data = self.frame[['A', 'B']]
         self.frame[['B', 'A']] = data
 
-        assert_series_equal(self.frame['B'], data['A'])
-        assert_series_equal(self.frame['A'], data['B'])
+        assert_series_equal(self.frame['B'], data['A'], check_names=False)
+        assert_series_equal(self.frame['A'], data['B'], check_names=False)
 
         with assertRaisesRegexp(ValueError, 'Columns must be same length as key'):
             data[['A']] = self.frame[['A', 'B']]
@@ -202,13 +202,13 @@ def test_setitem_list(self):
         df.ix[1, ['tt1', 'tt2']] = [1, 2]
 
         result = df.ix[1, ['tt1', 'tt2']]
-        expected = Series([1, 2], df.columns, dtype=np.int_)
+        expected = Series([1, 2], df.columns, dtype=np.int_, name=1)
         assert_series_equal(result, expected)
 
         df['tt1'] = df['tt2'] = '0'
         df.ix[1, ['tt1', 'tt2']] = ['1', '2']
         result = df.ix[1, ['tt1', 'tt2']]
-        expected = Series(['1', '2'], df.columns)
+        expected = Series(['1', '2'], df.columns, name=1)
         assert_series_equal(result, expected)
 
     def test_setitem_list_not_dataframe(self):
@@ -221,7 +221,7 @@ def test_setitem_list_of_tuples(self):
         self.frame['tuples'] = tuples
 
         result = self.frame['tuples']
-        expected = Series(tuples, index=self.frame.index)
+        expected = Series(tuples, index=self.frame.index, name='tuples')
         assert_series_equal(result, expected)
 
     def test_setitem_mulit_index(self):
@@ -505,7 +505,9 @@ def test_getitem_setitem_ix_negative_integers(self):
         a = DataFrame(randn(20, 2), index=[chr(x + 65) for x in range(20)])
         a.ix[-1] = a.ix[-2]
 
-        assert_series_equal(a.ix[-1], a.ix[-2])
+        assert_series_equal(a.ix[-1], a.ix[-2], check_names=False)
+        self.assertEqual(a.ix[-1].name, 'T')
+        self.assertEqual(a.ix[-2].name, 'S')
 
     def test_getattr(self):
         tm.assert_series_equal(self.frame.A, self.frame['A'])
@@ -574,7 +576,7 @@ def f():
 
     def test_setitem_tuple(self):
         self.frame['A', 'B'] = self.frame['A']
-        assert_series_equal(self.frame['A', 'B'], self.frame['A'])
+        assert_series_equal(self.frame['A', 'B'], self.frame['A'], check_names=False)
 
     def test_setitem_always_copy(self):
         s = self.frame['A'].copy()
@@ -772,16 +774,16 @@ def test_setitem_clear_caches(self):
 
         df.ix[2:, 'z'] = 42
 
-        expected = Series([np.nan, np.nan, 42, 42], index=df.index)
+        expected = Series([np.nan, np.nan, 42, 42], index=df.index, name='z')
         self.assertIsNot(df['z'], foo)
         assert_series_equal(df['z'], expected)
 
     def test_setitem_None(self):
         # GH #766
         self.frame[None] = self.frame['A']
-        assert_series_equal(self.frame.iloc[:,-1], self.frame['A'])
-        assert_series_equal(self.frame.loc[:,None], self.frame['A'])
-        assert_series_equal(self.frame[None], self.frame['A'])
+        assert_series_equal(self.frame.iloc[:,-1], self.frame['A'], check_names=False)
+        assert_series_equal(self.frame.loc[:,None], self.frame['A'], check_names=False)
+        assert_series_equal(self.frame[None], self.frame['A'], check_names=False)
         repr(self.frame)
 
     def test_setitem_empty(self):
@@ -1077,7 +1079,8 @@ def test_setitem_fancy_mixed_2d(self):
         self.assertTrue(isnull(self.mixed_frame.ix[5]).all())
 
         self.mixed_frame.ix[5] = self.mixed_frame.ix[6]
-        assert_series_equal(self.mixed_frame.ix[5], self.mixed_frame.ix[6])
+        assert_series_equal(self.mixed_frame.ix[5], self.mixed_frame.ix[6],
+                            check_names=False)
 
         # #1432
         df = DataFrame({1: [1., 2., 3.],
@@ -1092,7 +1095,7 @@ def test_setitem_fancy_mixed_2d(self):
         assert_frame_equal(df, expected)
 
     def test_ix_align(self):
-        b = Series(randn(10))
+        b = Series(randn(10), name=0)
         b.sort()
         df_orig = DataFrame(randn(10, 4))
         df = df_orig.copy()
@@ -2040,14 +2043,15 @@ def test_setitem_with_sparse_value(self):
         df = pd.DataFrame({'c_1':['a', 'b', 'c'], 'n_1': [1., 2., 3.]})
         sp_series = pd.Series([0, 0, 1]).to_sparse(fill_value=0)
         df['new_column'] = sp_series
-        tm.assert_series_equal(df['new_column'], sp_series)
+        tm.assert_series_equal(df['new_column'], sp_series, check_names=False)
 
     def test_setitem_with_unaligned_sparse_value(self):
         df = pd.DataFrame({'c_1':['a', 'b', 'c'], 'n_1': [1., 2., 3.]})
         sp_series = (pd.Series([0, 0, 1], index=[2, 1, 0])
                      .to_sparse(fill_value=0))
         df['new_column'] = sp_series
-        tm.assert_series_equal(df['new_column'], pd.Series([1, 0, 0]))
+        exp = pd.Series([1, 0, 0], name='new_column')
+        tm.assert_series_equal(df['new_column'], exp)
 
 
 _seriesd = tm.getSeriesData()
@@ -2452,7 +2456,8 @@ def test_set_index_cast_datetimeindex(self):
         # assignt to frame
         df['B'] = i
         result = df['B']
-        assert_series_equal(result, expected)
+        assert_series_equal(result, expected, check_names=False)
+        self.assertEqual(result.name, 'B')
 
         # keep the timezone
         result = i.to_series(keep_tz=True)
@@ -2468,7 +2473,8 @@ def test_set_index_cast_datetimeindex(self):
         # list of datetimes with a tz
         df['D'] = i.to_pydatetime()
         result = df['D']
-        assert_series_equal(result, expected)
+        assert_series_equal(result, expected, check_names=False)
+        self.assertEqual(result.name, 'D')
 
         # GH 6785
         # set the index manually
@@ -5929,7 +5935,13 @@ def test_combineSeries(self):
             added = self.tsframe + ts
 
             for key, col in compat.iteritems(self.tsframe):
-                assert_series_equal(added[key], col + ts)
+                result = col + ts
+                assert_series_equal(added[key], result, check_names=False)
+                self.assertEqual(added[key].name, key)
+                if col.name == ts.name:
+                    self.assertEqual(result.name, 'A')
+                else:
+                    self.assertTrue(result.name is None)
 
             smaller_frame = self.tsframe[:-5]
             smaller_added = smaller_frame + ts
@@ -7592,7 +7604,7 @@ def test_dropEmptyRows(self):
         mat[:5] = nan
 
         frame = DataFrame({'foo': mat}, index=self.frame.index)
-        original = Series(mat, index=self.frame.index)
+        original = Series(mat, index=self.frame.index, name='foo')
         expected = original.dropna()
         inplace_frame1, inplace_frame2 = frame.copy(), frame.copy()
 
@@ -7615,7 +7627,7 @@ def test_dropIncompleteRows(self):
 
         frame = DataFrame({'foo': mat}, index=self.frame.index)
         frame['bar'] = 5
-        original = Series(mat, index=self.frame.index)
+        original = Series(mat, index=self.frame.index, name='foo')
         inp_frame1, inp_frame2 = frame.copy(), frame.copy()
 
         smaller_frame = frame.dropna()
@@ -7692,8 +7704,8 @@ def test_dropna(self):
 
     def test_drop_and_dropna_caching(self):
         # tst that cacher updates
-        original = Series([1, 2, np.nan])
-        expected = Series([1, 2], dtype=original.dtype)
+        original = Series([1, 2, np.nan], name='A')
+        expected = Series([1, 2], dtype=original.dtype, name='A')
         df = pd.DataFrame({'A': original.values.copy()})
         df2 = df.copy()
         df['A'].dropna()
@@ -9299,7 +9311,7 @@ def test_xs_corner(self):
         # no columns but index
         df = DataFrame(index=['a', 'b', 'c'])
         result = df.xs('a')
-        expected = Series([])
+        expected = Series([], name='a')
         assert_series_equal(result, expected)
 
     def test_xs_duplicates(self):
@@ -9738,7 +9750,8 @@ def _check_get(df, cond, check_dtypes = True):
             rs = df.where(cond, other1)
             rs2 = df.where(cond.values, other1)
             for k, v in rs.iteritems():
-                assert_series_equal(v, Series(np.where(cond[k], df[k], other1[k]),index=v.index))
+                exp = Series(np.where(cond[k], df[k], other1[k]),index=v.index)
+                assert_series_equal(v, exp, check_names=False)
             assert_frame_equal(rs, rs2)
 
             # dtypes
@@ -9779,7 +9792,7 @@ def _check_align(df, cond, other, check_dtypes = True):
                         o = other[k].values
 
                 new_values = d if c.all() else np.where(c, d, o)
-                expected = Series(new_values,index=result.index)
+                expected = Series(new_values, index=result.index, name=k)
 
                 # since we can't always have the correct numpy dtype
                 # as numpy doesn't know how to downcast, don't check
@@ -10226,7 +10239,7 @@ def test_shift(self):
         d = self.tsframe.index[0]
         shifted_d = d + datetools.BDay(5)
         assert_series_equal(self.tsframe.xs(d),
-                            shiftedFrame.xs(shifted_d))
+                            shiftedFrame.xs(shifted_d), check_names=False)
 
         # shift int frame
         int_shifted = self.intframe.shift(1)
@@ -11264,27 +11277,27 @@ def test_combine_first_mixed_bug(self):
         df2 = DataFrame([[-42.6, np.nan, True], [-5., 1.6, False]], index=[1, 2])
 
         result = df1.combine_first(df2)[2]
-        expected = Series([True,True,False])
-        assert_series_equal(result,expected)
+        expected = Series([True, True, False], name=2)
+        assert_series_equal(result, expected)
 
         # GH 3593, converting datetime64[ns] incorrecly
         df0 = DataFrame({"a":[datetime(2000, 1, 1), datetime(2000, 1, 2), datetime(2000, 1, 3)]})
         df1 = DataFrame({"a":[None, None, None]})
         df2 = df1.combine_first(df0)
-        assert_frame_equal(df2,df0)
+        assert_frame_equal(df2, df0)
 
         df2 = df0.combine_first(df1)
-        assert_frame_equal(df2,df0)
+        assert_frame_equal(df2, df0)
 
         df0 = DataFrame({"a":[datetime(2000, 1, 1), datetime(2000, 1, 2), datetime(2000, 1, 3)]})
         df1 = DataFrame({"a":[datetime(2000, 1, 2), None, None]})
         df2 = df1.combine_first(df0)
         result = df0.copy()
         result.iloc[0,:] = df1.iloc[0,:]
-        assert_frame_equal(df2,result)
+        assert_frame_equal(df2, result)
 
         df2 = df0.combine_first(df1)
-        assert_frame_equal(df2,df0)
+        assert_frame_equal(df2, df0)
 
     def test_update(self):
         df = DataFrame([[1.5, nan, 3.],
@@ -11497,8 +11510,14 @@ def test_clip_against_series(self):
             ub_mask = df.iloc[:, i] >= ub
             mask = ~lb_mask & ~ub_mask
 
-            assert_series_equal(clipped_df.loc[lb_mask, i], lb[lb_mask])
-            assert_series_equal(clipped_df.loc[ub_mask, i], ub[ub_mask])
+            result = clipped_df.loc[lb_mask, i]
+            assert_series_equal(result, lb[lb_mask], check_names=False)
+            self.assertEqual(result.name, i)
+
+            result = clipped_df.loc[ub_mask, i]
+            assert_series_equal(result, ub[ub_mask], check_names=False)
+            self.assertEqual(result.name, i)
+
             assert_series_equal(clipped_df.loc[mask, i], df.loc[mask, i])
 
     def test_clip_against_frame(self):
@@ -11837,7 +11856,12 @@ def alt(x):
                                    [0, 1, 2, 0, 1, 2],
                                    [0, 1, 0, 1, 0, 1]])
         df = DataFrame(np.random.randn(6, 3), index=index)
-        assert_series_equal(df.kurt(), df.kurt(level=0).xs('bar'))
+
+        kurt = df.kurt()
+        kurt2 = df.kurt(level=0).xs('bar')
+        assert_series_equal(kurt, kurt2, check_names=False)
+        self.assertTrue(kurt.name is None)
+        self.assertEqual(kurt2.name, 'bar')
 
     def _check_stat_op(self, name, alternative, frame=None, has_skipna=True,
                        has_numeric_only=False, check_dtype=True, check_dates=False,
@@ -13118,63 +13142,64 @@ def test_constructor_with_convert(self):
         # #2845
         df = DataFrame({'A' : [2**63-1] })
         result = df['A']
-        expected = Series(np.asarray([2**63-1], np.int64))
+        expected = Series(np.asarray([2**63-1], np.int64), name='A')
         assert_series_equal(result, expected)
 
         df = DataFrame({'A' : [2**63] })
         result = df['A']
-        expected = Series(np.asarray([2**63], np.object_))
+        expected = Series(np.asarray([2**63], np.object_), name='A')
         assert_series_equal(result, expected)
 
         df = DataFrame({'A' : [datetime(2005, 1, 1), True] })
         result = df['A']
-        expected = Series(np.asarray([datetime(2005, 1, 1), True], np.object_))
+        expected = Series(np.asarray([datetime(2005, 1, 1), True], np.object_),
+                          name='A')
         assert_series_equal(result, expected)
 
         df = DataFrame({'A' : [None, 1] })
         result = df['A']
-        expected = Series(np.asarray([np.nan, 1], np.float_))
+        expected = Series(np.asarray([np.nan, 1], np.float_), name='A')
         assert_series_equal(result, expected)
 
         df = DataFrame({'A' : [1.0, 2] })
         result = df['A']
-        expected = Series(np.asarray([1.0, 2], np.float_))
+        expected = Series(np.asarray([1.0, 2], np.float_), name='A')
         assert_series_equal(result, expected)
 
         df = DataFrame({'A' : [1.0+2.0j, 3] })
         result = df['A']
-        expected = Series(np.asarray([1.0+2.0j, 3], np.complex_))
+        expected = Series(np.asarray([1.0+2.0j, 3], np.complex_), name='A')
         assert_series_equal(result, expected)
 
         df = DataFrame({'A' : [1.0+2.0j, 3.0] })
         result = df['A']
-        expected = Series(np.asarray([1.0+2.0j, 3.0], np.complex_))
+        expected = Series(np.asarray([1.0+2.0j, 3.0], np.complex_), name='A')
         assert_series_equal(result, expected)
 
         df = DataFrame({'A' : [1.0+2.0j, True] })
         result = df['A']
-        expected = Series(np.asarray([1.0+2.0j, True], np.object_))
+        expected = Series(np.asarray([1.0+2.0j, True], np.object_), name='A')
         assert_series_equal(result, expected)
 
         df = DataFrame({'A' : [1.0, None] })
         result = df['A']
-        expected = Series(np.asarray([1.0, np.nan], np.float_))
+        expected = Series(np.asarray([1.0, np.nan], np.float_), name='A')
         assert_series_equal(result, expected)
 
         df = DataFrame({'A' : [1.0+2.0j, None] })
         result = df['A']
-        expected = Series(np.asarray([1.0+2.0j, np.nan], np.complex_))
+        expected = Series(np.asarray([1.0+2.0j, np.nan], np.complex_), name='A')
         assert_series_equal(result, expected)
 
         df = DataFrame({'A' : [2.0, 1, True, None] })
         result = df['A']
-        expected = Series(np.asarray([2.0, 1, True, None], np.object_))
+        expected = Series(np.asarray([2.0, 1, True, None], np.object_), name='A')
         assert_series_equal(result, expected)
 
         df = DataFrame({'A' : [2.0, 1, datetime(2006, 1, 1), None] })
         result = df['A']
         expected = Series(np.asarray([2.0, 1, datetime(2006, 1, 1),
-                                      None], np.object_))
+                                      None], np.object_), name='A')
         assert_series_equal(result, expected)
 
     def test_construction_with_mixed(self):
@@ -13282,8 +13307,8 @@ def test_assign_columns(self):
 
         frame = self.frame.copy()
         frame.columns = ['foo', 'bar', 'baz', 'quux', 'foo2']
-        assert_series_equal(self.frame['C'], frame['baz'])
-        assert_series_equal(self.frame['hi'], frame['foo2'])
+        assert_series_equal(self.frame['C'], frame['baz'], check_names=False)
+        assert_series_equal(self.frame['hi'], frame['foo2'], check_names=False)
 
     def test_columns_with_dups(self):
 
@@ -13593,9 +13618,12 @@ def test_dot(self):
 
         # Check series argument
         result = a.dot(b['one'])
-        assert_series_equal(result, expected['one'])
+        assert_series_equal(result, expected['one'], check_names=False)
+        self.assertTrue(result.name is None)
+
         result = a.dot(b1['one'])
-        assert_series_equal(result, expected['one'])
+        assert_series_equal(result, expected['one'], check_names=False)
+        self.assertTrue(result.name is None)
 
         # can pass correct-length arrays
         row = a.ix[0].values
diff --git a/pandas/tests/test_generic.py b/pandas/tests/test_generic.py
index 3f751310438e4..a03fe3c2241a3 100644
--- a/pandas/tests/test_generic.py
+++ b/pandas/tests/test_generic.py
@@ -921,8 +921,8 @@ def test_describe_empty(self):
     def test_describe_none(self):
         noneSeries = Series([None])
         noneSeries.name = 'None'
-        assert_series_equal(noneSeries.describe(),
-                            Series([0, 0], index=['count', 'unique']))
+        expected = Series([0, 0], index=['count', 'unique'], name='None')
+        assert_series_equal(noneSeries.describe(), expected)
 
 
 class TestDataFrame(tm.TestCase, Generic):
@@ -980,11 +980,11 @@ def test_interp_combo(self):
                         'C': [1, 2, 3, 5], 'D': list('abcd')})
 
         result = df['A'].interpolate()
-        expected = Series([1., 2., 3., 4.])
+        expected = Series([1., 2., 3., 4.], name='A')
         assert_series_equal(result, expected)
 
         result = df['A'].interpolate(downcast='infer')
-        expected = Series([1, 2, 3, 4])
+        expected = Series([1, 2, 3, 4], name='A')
         assert_series_equal(result, expected)
 
     def test_interp_nan_idx(self):
@@ -1519,7 +1519,7 @@ def test_set_attribute(self):
         df.y = 5
 
         assert_equal(df.y, 5)
-        assert_series_equal(df['y'], Series([2, 4, 6]))
+        assert_series_equal(df['y'], Series([2, 4, 6], name='y'))
 
 
 class TestPanel(tm.TestCase, Generic):
diff --git a/pandas/tests/test_graphics.py b/pandas/tests/test_graphics.py
index 82f4b8c05ca06..433645448fe2b 100644
--- a/pandas/tests/test_graphics.py
+++ b/pandas/tests/test_graphics.py
@@ -454,12 +454,12 @@ def is_grid_on():
             self.plt.subplot(1,4*len(kinds),spndx); spndx+=1
             mpl.rc('axes',grid=False)
             obj.plot(kind=kind, **kws)
-            self.assertFalse(is_grid_on())    
+            self.assertFalse(is_grid_on())
 
             self.plt.subplot(1,4*len(kinds),spndx); spndx+=1
             mpl.rc('axes',grid=True)
             obj.plot(kind=kind, grid=False, **kws)
-            self.assertFalse(is_grid_on())    
+            self.assertFalse(is_grid_on())
 
             if kind != 'pie':
                 self.plt.subplot(1,4*len(kinds),spndx); spndx+=1
@@ -1143,7 +1143,7 @@ def test_table(self):
     @slow
     def test_series_grid_settings(self):
         # Make sure plot defaults to rcParams['axes.grid'] setting, GH 9792
-        self._check_grid_settings(Series([1,2,3]), 
+        self._check_grid_settings(Series([1,2,3]),
             plotting._series_kinds + plotting._common_kinds)
 
 
@@ -1376,7 +1376,7 @@ def test_unsorted_index(self):
         ax = df.plot()
         l = ax.get_lines()[0]
         rs = l.get_xydata()
-        rs = Series(rs[:, 1], rs[:, 0], dtype=np.int64)
+        rs = Series(rs[:, 1], rs[:, 0], dtype=np.int64, name='y')
         tm.assert_series_equal(rs, df.y)
 
     @slow
@@ -3467,9 +3467,9 @@ def test_sharey_and_ax(self):
     @slow
     def test_df_grid_settings(self):
         # Make sure plot defaults to rcParams['axes.grid'] setting, GH 9792
-        self._check_grid_settings(DataFrame({'a':[1,2,3],'b':[2,3,4]}), 
+        self._check_grid_settings(DataFrame({'a':[1,2,3],'b':[2,3,4]}),
             plotting._dataframe_kinds, kws={'x':'a','y':'b'})
-        
+
 
 @tm.mplskip
 class TestDataFrameGroupByPlots(TestPlotBase):
diff --git a/pandas/tests/test_groupby.py b/pandas/tests/test_groupby.py
index 0789e20df3945..e1ae65c95b965 100644
--- a/pandas/tests/test_groupby.py
+++ b/pandas/tests/test_groupby.py
@@ -286,7 +286,9 @@ def test_nth(self):
         g = df[0]
         expected = s.groupby(g).first()
         expected2 = s.groupby(g).apply(lambda x: x.iloc[0])
-        assert_series_equal(expected2,expected)
+        assert_series_equal(expected2, expected, check_names=False)
+        self.assertTrue(expected.name, 0)
+        self.assertEqual(expected.name, 1)
 
         # validate first
         v = s[g==1].iloc[0]
@@ -1098,7 +1100,7 @@ def nsum(x):
                    df.groupby('col1').transform(nsum)['col2'],
                    df.groupby('col1')['col2'].transform(nsum)]
         for result in results:
-            assert_series_equal(result, expected)
+            assert_series_equal(result, expected, check_names=False)
 
     def test_with_na(self):
         index = Index(np.arange(10))
@@ -1251,9 +1253,9 @@ def test_series_describe_multikey(self):
         ts = tm.makeTimeSeries()
         grouped = ts.groupby([lambda x: x.year, lambda x: x.month])
         result = grouped.describe().unstack()
-        assert_series_equal(result['mean'], grouped.mean())
-        assert_series_equal(result['std'], grouped.std())
-        assert_series_equal(result['min'], grouped.min())
+        assert_series_equal(result['mean'], grouped.mean(), check_names=False)
+        assert_series_equal(result['std'], grouped.std(), check_names=False)
+        assert_series_equal(result['min'], grouped.min(), check_names=False)
 
     def test_series_describe_single(self):
         ts = tm.makeTimeSeries()
@@ -1304,7 +1306,7 @@ def test_frame_describe_multikey(self):
 
         for col in self.tsframe:
             expected = grouped[col].describe()
-            assert_series_equal(result[col], expected)
+            assert_series_equal(result[col], expected, check_names=False)
 
         groupedT = self.tsframe.groupby({'A': 0, 'B': 0,
                                          'C': 1, 'D': 1}, axis=1)
@@ -1901,7 +1903,6 @@ def test_builtins_apply(self): # GH8155
         df = pd.DataFrame(np.random.randint(1, 50, (1000, 2)),
                           columns=['jim', 'joe'])
         df['jolie'] = np.random.randn(1000)
-        print(df.head())
 
         for keys in ['jim', ['jim', 'joe']]:  # single key & multi-key
             if keys == 'jim': continue
@@ -1949,6 +1950,7 @@ def _testit(op):
                 expd.setdefault(cat1, {})[cat2] = op(group['C'])
             exp = DataFrame(expd).T.stack(dropna=False)
             exp.index.names = ['A', 'B']
+            exp.name = 'C'
 
             result = op(grouped)['C']
             assert_series_equal(result, exp)
@@ -2207,7 +2209,8 @@ def trans2(group):
 
         result = df.groupby('A').apply(trans)
         exp = df.groupby('A')['C'].apply(trans2)
-        assert_series_equal(result, exp)
+        assert_series_equal(result, exp, check_names=False)
+        self.assertEqual(result.name, 'C')
 
     def test_apply_transform(self):
         grouped = self.ts.groupby(lambda x: x.month)
@@ -3106,7 +3109,8 @@ def test_rank_apply(self):
             expected.append(piece.value.rank())
         expected = concat(expected, axis=0)
         expected = expected.reindex(result.index)
-        assert_series_equal(result, expected)
+        assert_series_equal(result, expected, check_names=False)
+        self.assertTrue(result.name is None)
 
         result = df.groupby(['key1', 'key2']).value.rank(pct=True)
 
@@ -3115,7 +3119,8 @@ def test_rank_apply(self):
             expected.append(piece.value.rank(pct=True))
         expected = concat(expected, axis=0)
         expected = expected.reindex(result.index)
-        assert_series_equal(result, expected)
+        assert_series_equal(result, expected, check_names=False)
+        self.assertTrue(result.name is None)
 
     def test_dont_clobber_name_column(self):
         df = DataFrame({'key': ['a', 'a', 'a', 'b', 'b', 'b'],
@@ -3147,7 +3152,8 @@ def test_skip_group_keys(self):
             pieces.append(group.order()[:3])
 
         expected = concat(pieces)
-        assert_series_equal(result, expected)
+        assert_series_equal(result, expected, check_names=False)
+        self.assertTrue(result.name is None)
 
     def test_no_nonsense_name(self):
         # GH #995
@@ -4328,7 +4334,7 @@ def test_filter_using_len(self):
         s = df['B']
         grouped = s.groupby(s)
         actual = grouped.filter(lambda x: len(x) > 2)
-        expected = Series(4*['b'], index=np.arange(2, 6))
+        expected = Series(4*['b'], index=np.arange(2, 6), name='B')
         assert_series_equal(actual, expected)
 
         actual = grouped.filter(lambda x: len(x) > 4)
@@ -4410,7 +4416,7 @@ def test_filter_and_transform_with_non_unique_int_index(self):
 
         # Transform Series
         actual = grouped_ser.transform(len)
-        expected = Series([1, 2, 2, 1, 2, 1, 1, 2], index)
+        expected = Series([1, 2, 2, 1, 2, 1, 1, 2], index, name='pid')
         assert_series_equal(actual, expected)
 
         # Transform (a column from) DataFrameGroupBy
@@ -4450,7 +4456,7 @@ def test_filter_and_transform_with_multiple_non_unique_int_index(self):
 
         # Transform Series
         actual = grouped_ser.transform(len)
-        expected = Series([1, 2, 2, 1, 2, 1, 1, 2], index)
+        expected = Series([1, 2, 2, 1, 2, 1, 1, 2], index, name='pid')
         assert_series_equal(actual, expected)
 
         # Transform (a column from) DataFrameGroupBy
@@ -4530,7 +4536,7 @@ def test_filter_and_transform_with_non_unique_float_index(self):
 
         # Transform Series
         actual = grouped_ser.transform(len)
-        expected = Series([1, 2, 2, 1, 2, 1, 1, 2], index)
+        expected = Series([1, 2, 2, 1, 2, 1, 1, 2], index, name='pid')
         assert_series_equal(actual, expected)
 
         # Transform (a column from) DataFrameGroupBy
@@ -4573,7 +4579,7 @@ def test_filter_and_transform_with_non_unique_timestamp_index(self):
 
         # Transform Series
         actual = grouped_ser.transform(len)
-        expected = Series([1, 2, 2, 1, 2, 1, 1, 2], index)
+        expected = Series([1, 2, 2, 1, 2, 1, 1, 2], index, name='pid')
         assert_series_equal(actual, expected)
 
         # Transform (a column from) DataFrameGroupBy
@@ -4613,7 +4619,7 @@ def test_filter_and_transform_with_non_unique_string_index(self):
 
         # Transform Series
         actual = grouped_ser.transform(len)
-        expected = Series([1, 2, 2, 1, 2, 1, 1, 2], index)
+        expected = Series([1, 2, 2, 1, 2, 1, 1, 2], index, name='pid')
         assert_series_equal(actual, expected)
 
         # Transform (a column from) DataFrameGroupBy
diff --git a/pandas/tests/test_indexing.py b/pandas/tests/test_indexing.py
index c998ce65791a3..c6d31fb8d0449 100644
--- a/pandas/tests/test_indexing.py
+++ b/pandas/tests/test_indexing.py
@@ -373,8 +373,8 @@ def test_imethods_with_dups(self):
 
         df = s.to_frame()
         result = df.iloc[2]
-        expected = Series(2,index=[0])
-        assert_series_equal(result,expected)
+        expected = Series(2, index=[0], name=2)
+        assert_series_equal(result, expected)
 
         result = df.iat[2,0]
         expected = 2
@@ -512,7 +512,7 @@ def test_iloc_getitem_dups(self):
         self.assertTrue(isnull(result))
 
         result = df.iloc[0,:]
-        expected = Series([np.nan,1,3,3],index=['A','B','A','B'])
+        expected = Series([np.nan, 1, 3, 3], index=['A','B','A','B'], name=0)
         assert_series_equal(result,expected)
 
     def test_iloc_getitem_array(self):
@@ -1021,8 +1021,8 @@ def test_loc_general(self):
 
         # mixed type
         result = DataFrame({ 'a' : [Timestamp('20130101')], 'b' : [1] }).iloc[0]
-        expected = Series([ Timestamp('20130101'), 1],index=['a','b'])
-        assert_series_equal(result,expected)
+        expected = Series([ Timestamp('20130101'), 1], index=['a','b'], name=0)
+        assert_series_equal(result, expected)
         self.assertEqual(result.dtype, object)
 
     def test_loc_setitem_consistency(self):
@@ -1126,12 +1126,12 @@ def test_loc_setitem_frame(self):
         # setting with mixed labels
         df = DataFrame({1:[1,2],2:[3,4],'a':['a','b']})
 
-        result = df.loc[0,[1,2]]
-        expected = Series([1,3],index=[1,2],dtype=object)
-        assert_series_equal(result,expected)
+        result = df.loc[0, [1,2]]
+        expected = Series([1,3],index=[1,2],dtype=object, name=0)
+        assert_series_equal(result, expected)
 
         expected = DataFrame({1:[5,2],2:[6,4],'a':['a','b']})
-        df.loc[0,[1,2]] = [5,6]
+        df.loc[0, [1,2]] = [5,6]
         assert_frame_equal(df, expected)
 
     def test_loc_setitem_frame_multiples(self):
@@ -1404,8 +1404,8 @@ def f():
         df.ix[2:5, 'bar'] = np.array([2.33j, 1.23+0.1j, 2.2, 1.0])
 
         result = df.ix[2:5, 'bar']
-        expected = Series([2.33j, 1.23+0.1j, 2.2, 1.0],index=[2,3,4,5])
-        assert_series_equal(result,expected)
+        expected = Series([2.33j, 1.23+0.1j, 2.2, 1.0], index=[2,3,4,5], name='bar')
+        assert_series_equal(result, expected)
 
         # dtype getting changed?
         df = DataFrame(index=Index(lrange(1,11)))
@@ -1473,7 +1473,9 @@ def test_iloc_getitem_multiindex(self):
         # the first row
         rs = mi_int.iloc[0]
         xp = mi_int.ix[4].ix[8]
-        assert_series_equal(rs, xp)
+        assert_series_equal(rs, xp, check_names=False)
+        self.assertEqual(rs.name, (4, 8))
+        self.assertEqual(xp.name, 8)
 
         # 2nd (last) columns
         rs = mi_int.iloc[:,2]
@@ -2955,14 +2957,14 @@ def test_mi_access(self):
         # GH 4146, not returning a block manager when selecting a unique index
         # from a duplicate index
         # as of 4879, this returns a Series (which is similar to what happens with a non-unique)
-        expected = Series(['a',1,1],index=['h1','h3','h5'])
+        expected = Series(['a',1,1], index=['h1','h3','h5'], name='A1')
         result = df2['A']['A1']
-        assert_series_equal(result,expected)
+        assert_series_equal(result, expected)
 
         # selecting a non_unique from the 2nd level
         expected = DataFrame([['d',4,4],['e',5,5]],index=Index(['B2','B2'],name='sub'),columns=['h1','h3','h5'],).T
         result = df2['A']['B2']
-        assert_frame_equal(result,expected)
+        assert_frame_equal(result, expected)
 
     def test_non_unique_loc_memory_error(self):
 
@@ -3057,15 +3059,16 @@ def test_dups_loc(self):
 
         # GH4726
         # dup indexing with iloc/loc
-        df = DataFrame([[1,2,'foo','bar',Timestamp('20130101')]],
-                       columns=['a','a','a','a','a'],index=[1])
-        expected = Series([1,2,'foo','bar',Timestamp('20130101')],index=['a','a','a','a','a'])
+        df = DataFrame([[1, 2, 'foo', 'bar', Timestamp('20130101')]],
+                       columns=['a','a','a','a','a'], index=[1])
+        expected = Series([1, 2, 'foo', 'bar', Timestamp('20130101')],
+                          index=['a','a','a','a','a'], name=1)
 
         result = df.iloc[0]
-        assert_series_equal(result,expected)
+        assert_series_equal(result, expected)
 
         result = df.loc[1]
-        assert_series_equal(result,expected)
+        assert_series_equal(result, expected)
 
     def test_partial_setting(self):
 
diff --git a/pandas/tests/test_multilevel.py b/pandas/tests/test_multilevel.py
index b2efc20aa0694..9460c6373d0d2 100644
--- a/pandas/tests/test_multilevel.py
+++ b/pandas/tests/test_multilevel.py
@@ -149,7 +149,7 @@ def test_reindex_level(self):
         # Series
         result = month_sums['A'].reindex(self.ymd.index, level=1)
         expected = self.ymd['A'].groupby(level='month').transform(np.sum)
-        assert_series_equal(result, expected)
+        assert_series_equal(result, expected, check_names=False)
 
         # axis=1
         month_sums = self.ymd.T.sum(axis=1, level='month')
@@ -173,6 +173,7 @@ def _check_op(opname):
             broadcasted = self.ymd['A'].groupby(
                 level='month').transform(np.sum)
             expected = op(self.ymd['A'], broadcasted)
+            expected.name = 'A'
             assert_series_equal(result, expected)
 
         _check_op('sub')
@@ -1209,7 +1210,8 @@ def test_groupby_transform(self):
 
         applied = grouped.apply(lambda x: x * 2)
         expected = grouped.transform(lambda x: x * 2)
-        assert_series_equal(applied.reindex(expected.index), expected)
+        result = applied.reindex(expected.index)
+        assert_series_equal(result, expected, check_names=False)
 
     def test_unstack_sparse_keyspace(self):
         # memory problems with naive impl #2278
diff --git a/pandas/tests/test_panel.py b/pandas/tests/test_panel.py
index 57fd465993e14..e86551c6b9158 100644
--- a/pandas/tests/test_panel.py
+++ b/pandas/tests/test_panel.py
@@ -1700,7 +1700,8 @@ def test_compound(self):
         compounded = self.panel.compound()
 
         assert_series_equal(compounded['ItemA'],
-                            (1 + self.panel['ItemA']).product(0) - 1)
+                            (1 + self.panel['ItemA']).product(0) - 1,
+                            check_names=False)
 
     def test_shift(self):
         # major
@@ -2186,7 +2187,7 @@ def test_ops_differently_indexed(self):
         # careful, mutation
         self.panel['foo'] = lp2['ItemA']
         assert_series_equal(self.panel['foo'].reindex(lp2.index),
-                            lp2['ItemA'])
+                            lp2['ItemA'], check_names=False)
 
     def test_ops_scalar(self):
         result = self.panel.mul(2)
diff --git a/pandas/tests/test_panel4d.py b/pandas/tests/test_panel4d.py
index fff3b0c5450b1..7a72200077225 100644
--- a/pandas/tests/test_panel4d.py
+++ b/pandas/tests/test_panel4d.py
@@ -471,7 +471,7 @@ def test_major_xs(self):
         idx = self.panel4d.major_axis[5]
         xs = self.panel4d.major_xs(idx)
 
-        assert_series_equal(xs['l1'].T['ItemA'], ref.xs(idx))
+        assert_series_equal(xs['l1'].T['ItemA'], ref.xs(idx), check_names=False)
 
         # not contained
         idx = self.panel4d.major_axis[0] - bday
@@ -489,7 +489,7 @@ def test_minor_xs(self):
         idx = self.panel4d.minor_axis[1]
         xs = self.panel4d.minor_xs(idx)
 
-        assert_series_equal(xs['l1'].T['ItemA'], ref[idx])
+        assert_series_equal(xs['l1'].T['ItemA'], ref[idx], check_names=False)
 
         # not contained
         self.assertRaises(Exception, self.panel4d.minor_xs, 'E')
@@ -1099,6 +1099,5 @@ def test_to_excel(self):
 
 if __name__ == '__main__':
     import nose
-    nose.runmodule(argv=[__file__, '-vvs', '-x', '--pdb', '--pdb-failure',
-                         '--with-timer'],
+    nose.runmodule(argv=[__file__, '-vvs', '-x', '--pdb', '--pdb-failure'],
                    exit=False)
diff --git a/pandas/tests/test_series.py b/pandas/tests/test_series.py
index eb583f17f3ace..30566c703d4ec 100644
--- a/pandas/tests/test_series.py
+++ b/pandas/tests/test_series.py
@@ -1064,7 +1064,7 @@ def test_pop(self):
         result = k.pop('B')
         self.assertEqual(result, 4)
 
-        expected = Series([0,0],index=['A','C'])
+        expected = Series([0, 0], index=['A', 'C'], name=4)
         assert_series_equal(k, expected)
 
     def test_not_hashable(self):
@@ -1453,8 +1453,10 @@ def test_setitem(self):
         # set item that's not contained
         s = self.series.copy()
         s['foobar'] = 1
-        expected = self.series.append(Series([1],index=['foobar']))
-        assert_series_equal(s,expected)
+
+        app = Series([1], index=['foobar'], name='series')
+        expected = self.series.append(app)
+        assert_series_equal(s, expected)
 
     def test_setitem_dtypes(self):
 
@@ -2717,7 +2719,8 @@ def test_round(self):
         # numpy.round doesn't preserve metadata, probably a numpy bug,
         # re: GH #314
         result = np.round(self.ts, 2)
-        expected = Series(np.round(self.ts.values, 2), index=self.ts.index)
+        expected = Series(np.round(self.ts.values, 2), index=self.ts.index,
+                          name='ts')
         assert_series_equal(result, expected)
         self.assertEqual(result.name, self.ts.name)
 
@@ -2866,7 +2869,7 @@ def test_modulo(self):
         assert_series_equal(result, expected)
 
         result = p['first'] % 0
-        expected = Series(np.nan, index=p.index)
+        expected = Series(np.nan, index=p.index, name='first')
         assert_series_equal(result, expected)
 
         p = p.astype('float64')
@@ -2895,13 +2898,13 @@ def test_div(self):
         # no longer do integer div for any ops, but deal with the 0's
         p = DataFrame({'first': [3, 4, 5, 8], 'second': [0, 0, 0, 3]})
         result = p['first'] / p['second']
-        expected = Series(
-            p['first'].values.astype(float) / p['second'].values, dtype='float64')
+        expected = Series(p['first'].values.astype(float) / p['second'].values,
+                          dtype='float64')
         expected.iloc[0:3] = np.inf
         assert_series_equal(result, expected)
 
         result = p['first'] / 0
-        expected = Series(np.inf, index=p.index)
+        expected = Series(np.inf, index=p.index, name='first')
         assert_series_equal(result, expected)
 
         p = p.astype('float64')
@@ -2911,7 +2914,8 @@ def test_div(self):
 
         p = DataFrame({'first': [3, 4, 5, 8], 'second': [1, 1, 1, 1]})
         result = p['first'] / p['second']
-        assert_series_equal(result, p['first'].astype('float64'))
+        assert_series_equal(result, p['first'].astype('float64'), check_names=False)
+        self.assertTrue(result.name is None)
         self.assertFalse(np.array_equal(result, p['second'] / p['first']))
 
         # inf signing
@@ -2926,7 +2930,7 @@ def test_div(self):
         expected = Series([-0.01,-np.inf])
 
         result = p['second'].div(p['first'])
-        assert_series_equal(result, expected)
+        assert_series_equal(result, expected, check_names=False)
 
         result = p['second'] / p['first']
         assert_series_equal(result, expected)
@@ -3101,13 +3105,13 @@ def test_operators_timedelta64(self):
 
         # timestamp on lhs
         result = resultb + df['A']
-        expected = Series(
-            [Timestamp('20111230'), Timestamp('20120101'), Timestamp('20120103')])
+        values = [Timestamp('20111230'), Timestamp('20120101'), Timestamp('20120103')]
+        expected = Series(values, name='A')
         assert_series_equal(result, expected)
 
         # datetimes on rhs
         result = df['A'] - datetime(2001, 1, 1)
-        expected = Series([timedelta(days=4017 + i) for i in range(3)])
+        expected = Series([timedelta(days=4017 + i) for i in range(3)], name='A')
         assert_series_equal(result, expected)
         self.assertEqual(result.dtype, 'm8[ns]')
 
@@ -3432,13 +3436,14 @@ def test_ops_datetimelike_align(self):
         dt.iloc[2] = np.nan
         dt2 = dt[::-1]
 
-        expected = Series([timedelta(0),timedelta(0),pd.NaT])
-
-        result = dt2-dt
-        assert_series_equal(result,expected)
+        expected = Series([timedelta(0), timedelta(0), pd.NaT])
+        # name is reset
+        result = dt2 - dt
+        assert_series_equal(result, expected)
 
-        result = (dt2.to_frame()-dt.to_frame())[0]
-        assert_series_equal(result,expected)
+        expected = Series(expected, name=0)
+        result = (dt2.to_frame() - dt.to_frame())[0]
+        assert_series_equal(result, expected)
 
     def test_timedelta64_functions(self):
 
@@ -3739,25 +3744,27 @@ def test_datetime64_with_index(self):
 
         # arithmetic integer ops with an index
         s = Series(np.random.randn(5))
-        expected = s-s.index.to_series()
-        result = s-s.index
-        assert_series_equal(result,expected)
+        expected = s - s.index.to_series()
+        result = s - s.index
+        assert_series_equal(result, expected)
 
         # GH 4629
         # arithmetic datetime64 ops with an index
-        s = Series(date_range('20130101',periods=5),index=date_range('20130101',periods=5))
-        expected = s-s.index.to_series()
-        result = s-s.index
-        assert_series_equal(result,expected)
+        s = Series(date_range('20130101', periods=5),
+                   index=date_range('20130101', periods=5))
+        expected = s - s.index.to_series()
+        result = s - s.index
+        assert_series_equal(result, expected)
 
-        result = s-s.index.to_period()
-        assert_series_equal(result,expected)
+        result = s - s.index.to_period()
+        assert_series_equal(result, expected)
 
-        df = DataFrame(np.random.randn(5,2),index=date_range('20130101',periods=5))
+        df = DataFrame(np.random.randn(5,2),
+                      index=date_range('20130101', periods=5))
         df['date'] = Timestamp('20130102')
         df['expected'] = df['date'] - df.index.to_series()
         df['result'] = df['date'] - df.index
-        assert_series_equal(df['result'],df['expected'])
+        assert_series_equal(df['result'], df['expected'], check_names=False)
 
     def test_timedelta64_nan(self):
 
@@ -4934,14 +4941,17 @@ def test_from_csv(self):
         with ensure_clean() as path:
             self.ts.to_csv(path)
             ts = Series.from_csv(path)
-            assert_series_equal(self.ts, ts)
+            assert_series_equal(self.ts, ts, check_names=False)
+            self.assertTrue(ts.name is None)
             self.assertTrue(ts.index.name is None)
 
             self.series.to_csv(path)
             series = Series.from_csv(path)
             self.assertIsNone(series.name)
             self.assertIsNone(series.index.name)
-            assert_series_equal(self.series, series)
+            assert_series_equal(self.series, series, check_names=False)
+            self.assertTrue(series.name is None)
+            self.assertTrue(series.index.name is None)
 
             outfile = open(path, 'w')
             outfile.write('1998-01-01|1.0\n1999-01-01|2.0')
@@ -5191,7 +5201,8 @@ def test_tshift(self):
         shifted2 = self.ts.tshift(freq=self.ts.index.freq)
         assert_series_equal(shifted, shifted2)
 
-        inferred_ts = Series(self.ts.values, Index(np.asarray(self.ts.index)))
+        inferred_ts = Series(self.ts.values, Index(np.asarray(self.ts.index)),
+                             name='ts')
         shifted = inferred_ts.tshift(1)
         unshifted = shifted.tshift(-1)
         assert_series_equal(shifted, self.ts.tshift(1))
@@ -5779,7 +5790,7 @@ def test_map_dict_with_tuple_keys(self):
         df['labels'] = df['a'].map(label_mappings)
         df['expected_labels'] = pd.Series(['A', 'B', 'A', 'B'], index=df.index)
         # All labels should be filled now
-        tm.assert_series_equal(df['labels'], df['expected_labels'])
+        tm.assert_series_equal(df['labels'], df['expected_labels'], check_names=False)
 
     def test_apply(self):
         assert_series_equal(self.ts.apply(np.sqrt), np.sqrt(self.ts))
@@ -6361,6 +6372,8 @@ def test_unstack(self):
         left = ts.unstack()
         right = DataFrame([[nan, 1], [2, nan]], index=[101, 102],
                           columns=[nan, 3.5])
+        print(left)
+        print(right)
         assert_frame_equal(left, right)
 
         idx = pd.MultiIndex.from_arrays([['cat', 'cat', 'cat', 'dog', 'dog'],
diff --git a/pandas/tools/tests/test_merge.py b/pandas/tools/tests/test_merge.py
index cf5cc4661ec52..7b322b0d311de 100644
--- a/pandas/tools/tests/test_merge.py
+++ b/pandas/tools/tests/test_merge.py
@@ -922,8 +922,10 @@ def run_asserts(left, right):
                 self.assertFalse(res['4th'].isnull().any())
                 self.assertFalse(res['5th'].isnull().any())
 
-                tm.assert_series_equal(res['4th'], - res['5th'])
-                tm.assert_series_equal(res['4th'], bind_cols(res.iloc[:, :-2]))
+                tm.assert_series_equal(res['4th'], - res['5th'], check_names=False)
+                result = bind_cols(res.iloc[:, :-2])
+                tm.assert_series_equal(res['4th'], result, check_names=False)
+                self.assertTrue(result.name is None)
 
                 if sort:
                     tm.assert_frame_equal(res,
@@ -1250,8 +1252,10 @@ def test_int64_overflow_issues(self):
 
         out = merge(left, right, how='outer')
         self.assertEqual(len(out), len(left))
-        assert_series_equal(out['left'], - out['right'])
-        assert_series_equal(out['left'], out.iloc[:, :-2].sum(axis=1))
+        assert_series_equal(out['left'], - out['right'], check_names=False)
+        result = out.iloc[:, :-2].sum(axis=1)
+        assert_series_equal(out['left'], result, check_names=False)
+        self.assertTrue(result.name is None)
 
         out.sort(out.columns.tolist(), inplace=True)
         out.index = np.arange(len(out))
diff --git a/pandas/tools/tests/test_pivot.py b/pandas/tools/tests/test_pivot.py
index 4618501bed841..bb95234657ec2 100644
--- a/pandas/tools/tests/test_pivot.py
+++ b/pandas/tools/tests/test_pivot.py
@@ -166,8 +166,8 @@ def test_pivot_index_with_nan(self):
         result = df.pivot('a','b','c')
         expected = DataFrame([[nan,nan,17,nan],[10,nan,nan,nan],
                               [nan,15,nan,nan],[nan,nan,nan,20]],
-                             index = Index([nan,'R1','R2','R4'],name='a'),
-                             columns = Index(['C1','C2','C3','C4'],name='b'))
+                             index = Index([nan,'R1','R2','R4'], name='a'),
+                             columns = Index(['C1','C2','C3','C4'], name='b'))
         tm.assert_frame_equal(result, expected)
         tm.assert_frame_equal(df.pivot('b', 'a', 'c'), expected.T)
 
@@ -227,12 +227,14 @@ def test_margins(self):
         def _check_output(res, col, index=['A', 'B'], columns=['C']):
             cmarg = res['All'][:-1]
             exp = self.data.groupby(index)[col].mean()
-            tm.assert_series_equal(cmarg, exp)
+            tm.assert_series_equal(cmarg, exp, check_names=False)
+            self.assertEqual(cmarg.name, 'All')
 
             res = res.sortlevel()
             rmarg = res.xs(('All', ''))[:-1]
             exp = self.data.groupby(columns)[col].mean()
-            tm.assert_series_equal(rmarg, exp)
+            tm.assert_series_equal(rmarg, exp, check_names=False)
+            self.assertEqual(rmarg.name, ('All', ''))
 
             gmarg = res['All']['All', '']
             exp = self.data[col].mean()
@@ -679,12 +681,14 @@ def test_crosstab_margins(self):
         all_cols = result['All', '']
         exp_cols = df.groupby(['a']).size().astype('i8')
         exp_cols = exp_cols.append(Series([len(df)], index=['All']))
+        exp_cols.name = ('All', '')
 
         tm.assert_series_equal(all_cols, exp_cols)
 
         all_rows = result.ix['All']
         exp_rows = df.groupby(['b', 'c']).size().astype('i8')
         exp_rows = exp_rows.append(Series([len(df)], index=[('All', '')]))
+        exp_rows.name = 'All'
 
         exp_rows = exp_rows.reindex(all_rows.index)
         exp_rows = exp_rows.fillna(0).astype(np.int64)
diff --git a/pandas/tseries/tests/test_resample.py b/pandas/tseries/tests/test_resample.py
index d7b1256329cc3..202ccb9438db5 100644
--- a/pandas/tseries/tests/test_resample.py
+++ b/pandas/tseries/tests/test_resample.py
@@ -815,7 +815,9 @@ def test_how_lambda_functions(self):
         result = ts.resample('M', how={'foo': lambda x: x.mean(),
                                        'bar': lambda x: x.std(ddof=1)})
         foo_exp = ts.resample('M', how='mean')
+        foo_exp.name = 'foo'
         bar_exp = ts.resample('M', how='std')
+        bar_exp.name = 'bar'
 
         tm.assert_series_equal(result['foo'], foo_exp)
         tm.assert_series_equal(result['bar'], bar_exp)
diff --git a/pandas/tseries/tests/test_timeseries.py b/pandas/tseries/tests/test_timeseries.py
index 8412ba8d4aad1..09b2bb24714af 100644
--- a/pandas/tseries/tests/test_timeseries.py
+++ b/pandas/tseries/tests/test_timeseries.py
@@ -248,25 +248,27 @@ def test_indexing(self):
 
         # GH 3070, make sure semantics work on Series/Frame
         expected = ts['2001']
+        expected.name = 'A'
 
         df = DataFrame(dict(A = ts))
         result = df['2001']['A']
-        assert_series_equal(expected,result)
+        assert_series_equal(expected, result)
 
         # setting
         ts['2001'] = 1
         expected = ts['2001']
+        expected.name = 'A'
 
         df.loc['2001','A'] = 1
 
         result = df['2001']['A']
-        assert_series_equal(expected,result)
+        assert_series_equal(expected, result)
 
         # GH3546 (not including times on the last day)
         idx = date_range(start='2013-05-31 00:00', end='2013-05-31 23:00', freq='H')
         ts  = Series(lrange(len(idx)), index=idx)
         expected = ts['2013-05']
-        assert_series_equal(expected,ts)
+        assert_series_equal(expected, ts)
 
         idx = date_range(start='2013-05-31 00:00', end='2013-05-31 23:59', freq='S')
         ts  = Series(lrange(len(idx)), index=idx)
@@ -882,10 +884,10 @@ def test_string_na_nat_conversion(self):
             else:
                 expected[i] = to_datetime(x)
 
-        assert_series_equal(result, expected)
+        assert_series_equal(result, expected, check_names=False)
         self.assertEqual(result.name, 'foo')
 
-        assert_series_equal(dresult, expected)
+        assert_series_equal(dresult, expected, check_names=False)
         self.assertEqual(dresult.name, 'foo')
 
     def test_to_datetime_iso8601(self):
diff --git a/pandas/tseries/tests/test_util.py b/pandas/tseries/tests/test_util.py
index df556cdc77d08..c75fcbdac07c0 100644
--- a/pandas/tseries/tests/test_util.py
+++ b/pandas/tseries/tests/test_util.py
@@ -30,12 +30,15 @@ def test_daily(self):
             subset = ts[doy == i]
             subset.index = [x.year for x in subset.index]
 
-            tm.assert_series_equal(annual[i].dropna(), subset)
+            result = annual[i].dropna()
+            tm.assert_series_equal(result, subset, check_names=False)
+            self.assertEqual(result.name, i)
 
         # check leap days
         leaps = ts[(ts.index.month == 2) & (ts.index.day == 29)]
         day = leaps.index.dayofyear[0]
         leaps.index = leaps.index.year
+        leaps.name = 60
         tm.assert_series_equal(annual[day].dropna(), leaps)
 
     def test_hourly(self):
@@ -57,15 +60,19 @@ def test_hourly(self):
             subset = ts_hourly[hoy == i]
             subset.index = [x.year for x in subset.index]
 
-            tm.assert_series_equal(annual[i].dropna(), subset)
+            result = annual[i].dropna()
+            tm.assert_series_equal(result, subset, check_names=False)
+            self.assertEqual(result.name, i)
 
         leaps = ts_hourly[(ts_hourly.index.month == 2) &
                           (ts_hourly.index.day == 29) &
                           (ts_hourly.index.hour == 0)]
         hour = leaps.index.dayofyear[0] * 24 - 23
         leaps.index = leaps.index.year
+        leaps.name = 1417
         tm.assert_series_equal(annual[hour].dropna(), leaps)
 
+
     def test_weekly(self):
         pass
 
@@ -79,7 +86,9 @@ def test_monthly(self):
         for i in range(1, 13):
             subset = ts[month == i]
             subset.index = [x.year for x in subset.index]
-            tm.assert_series_equal(annual[i].dropna(), subset)
+            result = annual[i].dropna()
+            tm.assert_series_equal(result, subset, check_names=False)
+            self.assertEqual(result.name, i)
 
     def test_period_monthly(self):
         pass
diff --git a/pandas/util/testing.py b/pandas/util/testing.py
index 55f95b602779f..25f5f84b0b1d9 100644
--- a/pandas/util/testing.py
+++ b/pandas/util/testing.py
@@ -24,7 +24,7 @@
 from numpy.testing import assert_array_equal
 
 import pandas as pd
-from pandas.core.common import is_sequence, array_equivalent, is_list_like
+from pandas.core.common import is_sequence, array_equivalent, is_list_like, is_number
 import pandas.compat as compat
 from pandas.compat import(
     filter, map, zip, range, unichr, lrange, lmap, lzip, u, callable, Counter,
@@ -691,6 +691,14 @@ def assert_series_equal(left, right, check_dtype=True,
             assert_isinstance(lindex, type(rindex))
             assert_attr_equal('dtype', lindex, rindex)
             assert_attr_equal('inferred_type', lindex, rindex)
+    if check_names:
+        if is_number(left.name) and np.isnan(left.name):
+            # Series.name can be np.nan in some test cases
+            assert is_number(right.name) and np.isnan(right.name)
+        elif left.name is pd.NaT:
+            assert right.name is pd.NaT
+        else:
+            assert_attr_equal('name', left, right)
 
 
 # This could be refactored to use the NDFrame.equals method