Merge pull request #6267 from bwignall/assert_6175_6

CLN: Converting assert_'s to specialized forms, in pandas/*/tests

Author: jreback

pandas/io/tests/test_cparser.py

@@ -70,7 +70,7 @@ def test_string_factorize(self):
         data = 'a\nb\na\nb\na'
         reader = TextReader(StringIO(data), header=None)
         result = reader.read()
-        self.assert_(len(set(map(id, result[0]))) == 2)
+        self.assertEqual(len(set(map(id, result[0]))), 2)
 
     def test_skipinitialspace(self):
         data = ('a,   b\n'
@@ -91,7 +91,7 @@ def test_parse_booleans(self):
         reader = TextReader(StringIO(data), header=None)
         result = reader.read()
 
-        self.assert_(result[0].dtype == np.bool_)
+        self.assertEqual(result[0].dtype, np.bool_)
 
     def test_delimit_whitespace(self):
         data = 'a  b\na\t\t "b"\n"a"\t \t b'
@@ -233,25 +233,25 @@ def _make_reader(**kwds):
         reader = _make_reader(dtype='S5,i4')
         result = reader.read()
 
-        self.assert_(result[0].dtype == 'S5')
+        self.assertEqual(result[0].dtype, 'S5')
 
         ex_values = np.array(['a', 'aa', 'aaa', 'aaaa', 'aaaaa'], dtype='S5')
         self.assert_((result[0] == ex_values).all())
-        self.assert_(result[1].dtype == 'i4')
+        self.assertEqual(result[1].dtype, 'i4')
 
         reader = _make_reader(dtype='S4')
         result = reader.read()
-        self.assert_(result[0].dtype == 'S4')
+        self.assertEqual(result[0].dtype, 'S4')
         ex_values = np.array(['a', 'aa', 'aaa', 'aaaa', 'aaaa'], dtype='S4')
         self.assert_((result[0] == ex_values).all())
-        self.assert_(result[1].dtype == 'S4')
+        self.assertEqual(result[1].dtype, 'S4')
 
         reader = _make_reader(dtype='S4', as_recarray=True)
         result = reader.read()
-        self.assert_(result['0'].dtype == 'S4')
+        self.assertEqual(result['0'].dtype, 'S4')
         ex_values = np.array(['a', 'aa', 'aaa', 'aaaa', 'aaaa'], dtype='S4')
         self.assert_((result['0'] == ex_values).all())
-        self.assert_(result['1'].dtype == 'S4')
+        self.assertEqual(result['1'].dtype, 'S4')
 
     def test_pass_dtype(self):
         data = """\
@@ -266,19 +266,19 @@ def _make_reader(**kwds):
 
         reader = _make_reader(dtype={'one': 'u1', 1: 'S1'})
         result = reader.read()
-        self.assert_(result[0].dtype == 'u1')
-        self.assert_(result[1].dtype == 'S1')
+        self.assertEqual(result[0].dtype, 'u1')
+        self.assertEqual(result[1].dtype, 'S1')
 
         reader = _make_reader(dtype={'one': np.uint8, 1: object})
         result = reader.read()
-        self.assert_(result[0].dtype == 'u1')
-        self.assert_(result[1].dtype == 'O')
+        self.assertEqual(result[0].dtype, 'u1')
+        self.assertEqual(result[1].dtype, 'O')
 
         reader = _make_reader(dtype={'one': np.dtype('u1'),
                                      1: np.dtype('O')})
         result = reader.read()
-        self.assert_(result[0].dtype == 'u1')
-        self.assert_(result[1].dtype == 'O')
+        self.assertEqual(result[0].dtype, 'u1')
+        self.assertEqual(result[1].dtype, 'O')
 
     def test_usecols(self):
         data = """\

pandas/io/tests/test_date_converters.py

@@ -50,7 +50,7 @@ def test_parse_date_time(self):
         df = read_table(StringIO(data), sep=',', header=0,
                         parse_dates=datecols, date_parser=conv.parse_date_time)
         self.assert_('date_time' in df)
-        self.assert_(df.date_time.ix[0] == datetime(2001, 1, 5, 10, 0, 0))
+        self.assertEqual(df.date_time.ix[0], datetime(2001, 1, 5, 10, 0, 0))
 
         data = ("KORD,19990127, 19:00:00, 18:56:00, 0.8100\n"
                 "KORD,19990127, 20:00:00, 19:56:00, 0.0100\n"
@@ -74,7 +74,7 @@ def test_parse_date_fields(self):
                         parse_dates=datecols,
                         date_parser=conv.parse_date_fields)
         self.assert_('ymd' in df)
-        self.assert_(df.ymd.ix[0] == datetime(2001, 1, 10))
+        self.assertEqual(df.ymd.ix[0], datetime(2001, 1, 10))
 
     def test_datetime_six_col(self):
         result = conv.parse_all_fields(self.years, self.months, self.days,
@@ -91,7 +91,7 @@ def test_datetime_six_col(self):
                         parse_dates=datecols,
                         date_parser=conv.parse_all_fields)
         self.assert_('ymdHMS' in df)
-        self.assert_(df.ymdHMS.ix[0] == datetime(2001, 1, 5, 10, 0, 0))
+        self.assertEqual(df.ymdHMS.ix[0], datetime(2001, 1, 5, 10, 0, 0))
 
     def test_datetime_fractional_seconds(self):
         data = """\
@@ -104,10 +104,10 @@ def test_datetime_fractional_seconds(self):
                         parse_dates=datecols,
                         date_parser=conv.parse_all_fields)
         self.assert_('ymdHMS' in df)
-        self.assert_(df.ymdHMS.ix[0] == datetime(2001, 1, 5, 10, 0, 0,
-                                                 microsecond=123456))
-        self.assert_(df.ymdHMS.ix[1] == datetime(2001, 1, 5, 10, 0, 0,
-                                                 microsecond=500000))
+        self.assertEqual(df.ymdHMS.ix[0], datetime(2001, 1, 5, 10, 0, 0,
+                                                   microsecond=123456))
+        self.assertEqual(df.ymdHMS.ix[1], datetime(2001, 1, 5, 10, 0, 0,
+                                                   microsecond=500000))
 
     def test_generic(self):
         data = "year, month, day, a\n 2001, 01, 10, 10.\n 2001, 02, 1, 11."
@@ -117,7 +117,7 @@ def test_generic(self):
                         parse_dates=datecols,
                         date_parser=dateconverter)
         self.assert_('ym' in df)
-        self.assert_(df.ym.ix[0] == date(2001, 1, 1))
+        self.assertEqual(df.ym.ix[0], date(2001, 1, 1))
 
 
 if __name__ == '__main__':

pandas/io/tests/test_packers.py

@@ -194,7 +194,7 @@ def test_timestamp(self):
             '20130101'), Timestamp('20130101', tz='US/Eastern'),
                 Timestamp('201301010501')]:
             i_rec = self.encode_decode(i)
-            self.assert_(i == i_rec)
+            self.assertEqual(i, i_rec)
 
     def test_datetimes(self):
 
@@ -207,15 +207,15 @@ def test_datetimes(self):
             2013, 1, 1), datetime.datetime(2013, 1, 1, 5, 1),
                 datetime.date(2013, 1, 1), np.datetime64(datetime.datetime(2013, 1, 5, 2, 15))]:
             i_rec = self.encode_decode(i)
-            self.assert_(i == i_rec)
+            self.assertEqual(i, i_rec)
 
     def test_timedeltas(self):
 
         for i in [datetime.timedelta(days=1),
                   datetime.timedelta(days=1, seconds=10),
                   np.timedelta64(1000000)]:
             i_rec = self.encode_decode(i)
-            self.assert_(i == i_rec)
+            self.assertEqual(i, i_rec)
 
 
 class TestIndex(TestPackers):

pandas/io/tests/test_parsers.py

@@ -309,7 +309,7 @@ def func(*date_cols):
         self.assert_('X3' not in df)
 
         d = datetime(1999, 1, 27, 19, 0)
-        self.assert_(df.ix[0, 'nominal'] == d)
+        self.assertEqual(df.ix[0, 'nominal'], d)
 
         df = self.read_csv(StringIO(data), header=None,
                            date_parser=func,
@@ -342,7 +342,7 @@ def func(*date_cols):
         self.assert_('X3' not in df)
 
         d = datetime(1999, 1, 27, 19, 0)
-        self.assert_(df.ix[0, 'X1_X2'] == d)
+        self.assertEqual(df.ix[0, 'X1_X2'], d)
 
         df = read_csv(StringIO(data), header=None,
                       parse_dates=[[1, 2], [1, 3]], keep_date_col=True)
@@ -363,7 +363,7 @@ def func(*date_cols):
         df = self.read_csv(StringIO(data), sep=',', header=None,
                            parse_dates=[1], index_col=1)
         d = datetime(1999, 1, 27, 19, 0)
-        self.assert_(df.index[0] == d)
+        self.assertEqual(df.index[0], d)
 
     def test_multiple_date_cols_int_cast(self):
         data = ("KORD,19990127, 19:00:00, 18:56:00, 0.8100\n"
@@ -473,11 +473,11 @@ def test_index_col_named(self):
                        index=Index(['hello', 'world', 'foo'], name='message'))
         rs = self.read_csv(StringIO(data), names=names, index_col=['message'])
         tm.assert_frame_equal(xp, rs)
-        self.assert_(xp.index.name == rs.index.name)
+        self.assertEqual(xp.index.name, rs.index.name)
 
         rs = self.read_csv(StringIO(data), names=names, index_col='message')
         tm.assert_frame_equal(xp, rs)
-        self.assert_(xp.index.name == rs.index.name)
+        self.assertEqual(xp.index.name, rs.index.name)
 
     def test_converter_index_col_bug(self):
         # 1835
@@ -488,7 +488,7 @@ def test_converter_index_col_bug(self):
 
         xp = DataFrame({'B': [2, 4]}, index=Index([1, 3], name='A'))
         tm.assert_frame_equal(rs, xp)
-        self.assert_(rs.index.name == xp.index.name)
+        self.assertEqual(rs.index.name, xp.index.name)
 
     def test_date_parser_int_bug(self):
         # #3071
@@ -640,7 +640,7 @@ def test_quoting(self):
 
         good_line_small = bad_line_small + '"'
         df = self.read_table(StringIO(good_line_small), sep='\t')
-        self.assert_(len(df) == 3)
+        self.assertEqual(len(df), 3)
 
     def test_non_string_na_values(self):
         # GH3611, na_values that are not a string are an issue
@@ -1005,10 +1005,10 @@ def test_read_csv_dataframe(self):
         df2 = self.read_table(self.csv1, sep=',', index_col=0,
                               parse_dates=True)
         self.assert_(np.array_equal(df.columns, ['A', 'B', 'C', 'D']))
-        self.assert_(df.index.name == 'index')
+        self.assertEqual(df.index.name, 'index')
         self.assert_(isinstance(df.index[0], (datetime, np.datetime64,
                                               Timestamp)))
-        self.assert_(df.values.dtype == np.float64)
+        self.assertEqual(df.values.dtype, np.float64)
         tm.assert_frame_equal(df, df2)
 
     def test_read_csv_no_index_name(self):
@@ -1018,7 +1018,7 @@ def test_read_csv_no_index_name(self):
         self.assert_(np.array_equal(df.columns, ['A', 'B', 'C', 'D', 'E']))
         self.assert_(isinstance(df.index[0], (datetime, np.datetime64,
                                               Timestamp)))
-        self.assert_(df.ix[:, ['A', 'B', 'C', 'D']].values.dtype == np.float64)
+        self.assertEqual(df.ix[:, ['A', 'B', 'C', 'D']].values.dtype, np.float64)
         tm.assert_frame_equal(df, df2)
 
     def test_read_table_unicode(self):
@@ -1070,7 +1070,7 @@ def test_parse_bools(self):
 True,3
 """
         data = self.read_csv(StringIO(data))
-        self.assert_(data['A'].dtype == np.bool_)
+        self.assertEqual(data['A'].dtype, np.bool_)
 
         data = """A,B
 YES,1
@@ -1082,15 +1082,15 @@ def test_parse_bools(self):
         data = self.read_csv(StringIO(data),
                              true_values=['yes', 'Yes', 'YES'],
                              false_values=['no', 'NO', 'No'])
-        self.assert_(data['A'].dtype == np.bool_)
+        self.assertEqual(data['A'].dtype, np.bool_)
 
         data = """A,B
 TRUE,1
 FALSE,2
 TRUE,3
 """
         data = self.read_csv(StringIO(data))
-        self.assert_(data['A'].dtype == np.bool_)
+        self.assertEqual(data['A'].dtype, np.bool_)
 
         data = """A,B
 foo,bar
@@ -1107,8 +1107,8 @@ def test_int_conversion(self):
 3.0,3
 """
         data = self.read_csv(StringIO(data))
-        self.assert_(data['A'].dtype == np.float64)
-        self.assert_(data['B'].dtype == np.int64)
+        self.assertEqual(data['A'].dtype, np.float64)
+        self.assertEqual(data['B'].dtype, np.int64)
 
     def test_infer_index_col(self):
         data = """A,B,C
@@ -1218,7 +1218,7 @@ def test_iterator(self):
         reader = self.read_csv(StringIO(data), chunksize=1)
         result = list(reader)
         expected = DataFrame(dict(A = [1,4,7], B = [2,5,8], C = [3,6,9]), index=['foo','bar','baz'])
-        self.assert_(len(result) == 3)
+        self.assertEqual(len(result), 3)
         tm.assert_frame_equal(pd.concat(result), expected)
 
     def test_header_not_first_line(self):
@@ -1513,7 +1513,7 @@ def test_converters_no_implicit_conv(self):
         f = lambda x: x.strip()
         converter = {0: f}
         df = self.read_csv(StringIO(data), header=None, converters=converter)
-        self.assert_(df[0].dtype == object)
+        self.assertEqual(df[0].dtype, object)
 
     def test_converters_euro_decimal_format(self):
         data = """Id;Number1;Number2;Text1;Text2;Number3
@@ -1523,9 +1523,9 @@ def test_converters_euro_decimal_format(self):
         f = lambda x: float(x.replace(",", "."))
         converter = {'Number1': f, 'Number2': f, 'Number3': f}
         df2 = self.read_csv(StringIO(data), sep=';', converters=converter)
-        self.assert_(df2['Number1'].dtype == float)
-        self.assert_(df2['Number2'].dtype == float)
-        self.assert_(df2['Number3'].dtype == float)
+        self.assertEqual(df2['Number1'].dtype, float)
+        self.assertEqual(df2['Number2'].dtype, float)
+        self.assertEqual(df2['Number3'].dtype, float)
 
     def test_converter_return_string_bug(self):
         # GH #583
@@ -1536,7 +1536,7 @@ def test_converter_return_string_bug(self):
         f = lambda x: float(x.replace(",", "."))
         converter = {'Number1': f, 'Number2': f, 'Number3': f}
         df2 = self.read_csv(StringIO(data), sep=';', converters=converter)
-        self.assert_(df2['Number1'].dtype == float)
+        self.assertEqual(df2['Number1'].dtype, float)
 
     def test_read_table_buglet_4x_multiindex(self):
         text = """                      A       B       C       D        E
@@ -1659,15 +1659,15 @@ def test_parse_tz_aware(self):
         # it works
         result = read_csv(data, index_col=0, parse_dates=True)
         stamp = result.index[0]
-        self.assert_(stamp.minute == 39)
+        self.assertEqual(stamp.minute, 39)
         try:
             self.assert_(result.index.tz is pytz.utc)
         except AssertionError:  # hello Yaroslav
             arr = result.index.to_pydatetime()
             result = tools.to_datetime(arr, utc=True)[0]
-            self.assert_(stamp.minute == result.minute)
-            self.assert_(stamp.hour == result.hour)
-            self.assert_(stamp.day == result.day)
+            self.assertEqual(stamp.minute, result.minute)
+            self.assertEqual(stamp.hour, result.hour)
+            self.assertEqual(stamp.day, result.day)
 
     def test_multiple_date_cols_index(self):
         data = """\
@@ -2364,7 +2364,7 @@ def test_verbose_import(self):
         try:
             # it works!
             df = self.read_csv(StringIO(text), verbose=True)
-            self.assert_(buf.getvalue() == 'Filled 3 NA values in column a\n')
+            self.assertEqual(buf.getvalue(), 'Filled 3 NA values in column a\n')
         finally:
             sys.stdout = sys.__stdout__
 
@@ -2384,7 +2384,7 @@ def test_verbose_import(self):
         try:
             # it works!
             df = self.read_csv(StringIO(text), verbose=True, index_col=0)
-            self.assert_(buf.getvalue() == 'Filled 1 NA values in column a\n')
+            self.assertEqual(buf.getvalue(), 'Filled 1 NA values in column a\n')
         finally:
             sys.stdout = sys.__stdout__
 
@@ -2597,8 +2597,8 @@ def test_pass_dtype(self):
 
         result = self.read_csv(StringIO(data), dtype={'one': 'u1', 1: 'S1'},
                                as_recarray=True)
-        self.assert_(result['one'].dtype == 'u1')
-        self.assert_(result['two'].dtype == 'S1')
+        self.assertEqual(result['one'].dtype, 'u1')
+        self.assertEqual(result['two'].dtype, 'S1')
 
     def test_usecols_dtypes(self):
         data = """\
@@ -2765,9 +2765,9 @@ def test_euro_decimal_format(self):
 3;878,158;108013,434;GHI;rez;2,735694704"""
 
         df2 = self.read_csv(StringIO(data), sep=';', decimal=',')
-        self.assert_(df2['Number1'].dtype == float)
-        self.assert_(df2['Number2'].dtype == float)
-        self.assert_(df2['Number3'].dtype == float)
+        self.assertEqual(df2['Number1'].dtype, float)
+        self.assertEqual(df2['Number2'].dtype, float)
+        self.assertEqual(df2['Number3'].dtype, float)
 
     def test_custom_lineterminator(self):
         data = 'a,b,c~1,2,3~4,5,6'