diff --git a/pandas/tests/frame/test_alter_axes.py b/pandas/tests/frame/test_alter_axes.py
index f925022b6bd7f..f32e001ea984a 100644
--- a/pandas/tests/frame/test_alter_axes.py
+++ b/pandas/tests/frame/test_alter_axes.py
@@ -500,16 +500,16 @@ def test_rename_nocopy(self):
def test_rename_inplace(self):
self.frame.rename(columns={'C': 'foo'})
- self.assertIn('C', self.frame)
- self.assertNotIn('foo', self.frame)
+ assert 'C' in self.frame
+ assert 'foo' not in self.frame
c_id = id(self.frame['C'])
frame = self.frame.copy()
frame.rename(columns={'C': 'foo'}, inplace=True)
- self.assertNotIn('C', frame)
- self.assertIn('foo', frame)
- self.assertNotEqual(id(frame['foo']), c_id)
+ assert 'C' not in frame
+ assert 'foo' in frame
+ assert id(frame['foo']) != c_id
def test_rename_bug(self):
# GH 5344
@@ -778,8 +778,9 @@ def test_set_index_names(self):
def test_rename_objects(self):
renamed = self.mixed_frame.rename(columns=str.upper)
- self.assertIn('FOO', renamed)
- self.assertNotIn('foo', renamed)
+
+ assert 'FOO' in renamed
+ assert 'foo' not in renamed
def test_assign_columns(self):
self.frame['hi'] = 'there'
diff --git a/pandas/tests/frame/test_analytics.py b/pandas/tests/frame/test_analytics.py
index 703b93b9ec950..cd98460d8609c 100644
--- a/pandas/tests/frame/test_analytics.py
+++ b/pandas/tests/frame/test_analytics.py
@@ -190,10 +190,10 @@ def test_corrwith(self):
dropped = a.corrwith(b, axis=0, drop=True)
tm.assert_almost_equal(dropped['A'], a['A'].corr(b['A']))
- self.assertNotIn('B', dropped)
+ assert 'B' not in dropped
dropped = a.corrwith(b, axis=1, drop=True)
- self.assertNotIn(a.index[-1], dropped.index)
+ assert a.index[-1] not in dropped.index
# non time-series data
index = ['a', 'b', 'c', 'd', 'e']
diff --git a/pandas/tests/frame/test_axis_select_reindex.py b/pandas/tests/frame/test_axis_select_reindex.py
index 2f914472a1152..5b3a0a9e01f35 100644
--- a/pandas/tests/frame/test_axis_select_reindex.py
+++ b/pandas/tests/frame/test_axis_select_reindex.py
@@ -14,9 +14,7 @@
date_range, isnull)
import pandas as pd
-from pandas.util.testing import (assert_series_equal,
- assert_frame_equal,
- assertRaisesRegexp)
+from pandas.util.testing import assert_frame_equal
from pandas.errors import PerformanceWarning
import pandas.util.testing as tm
@@ -287,15 +285,15 @@ def test_reindex_like(self):
assert_frame_equal(other, self.frame.reindex_like(other))
def test_reindex_columns(self):
- newFrame = self.frame.reindex(columns=['A', 'B', 'E'])
+ new_frame = self.frame.reindex(columns=['A', 'B', 'E'])
- assert_series_equal(newFrame['B'], self.frame['B'])
- self.assertTrue(np.isnan(newFrame['E']).all())
- self.assertNotIn('C', newFrame)
+ tm.assert_series_equal(new_frame['B'], self.frame['B'])
+ assert np.isnan(new_frame['E']).all()
+ assert 'C' not in new_frame
- # length zero
- newFrame = self.frame.reindex(columns=[])
- self.assertTrue(newFrame.empty)
+ # Length zero
+ new_frame = self.frame.reindex(columns=[])
+ assert new_frame.empty
def test_reindex_columns_method(self):
@@ -659,33 +657,33 @@ def test_align_series_combinations(self):
tm.assert_frame_equal(res2, exp1)
def test_filter(self):
- # items
+ # Items
filtered = self.frame.filter(['A', 'B', 'E'])
- self.assertEqual(len(filtered.columns), 2)
- self.assertNotIn('E', filtered)
+ assert len(filtered.columns) == 2
+ assert 'E' not in filtered
filtered = self.frame.filter(['A', 'B', 'E'], axis='columns')
- self.assertEqual(len(filtered.columns), 2)
- self.assertNotIn('E', filtered)
+ assert len(filtered.columns) == 2
+ assert 'E' not in filtered
- # other axis
+ # Other axis
idx = self.frame.index[0:4]
filtered = self.frame.filter(idx, axis='index')
expected = self.frame.reindex(index=idx)
- assert_frame_equal(filtered, expected)
+ tm.assert_frame_equal(filtered, expected)
# like
fcopy = self.frame.copy()
fcopy['AA'] = 1
filtered = fcopy.filter(like='A')
- self.assertEqual(len(filtered.columns), 2)
- self.assertIn('AA', filtered)
+ assert len(filtered.columns) == 2
+ assert 'AA' in filtered
# like with ints in column names
df = DataFrame(0., index=[0, 1, 2], columns=[0, 1, '_A', '_B'])
filtered = df.filter(like='_')
- self.assertEqual(len(filtered.columns), 2)
+ assert len(filtered.columns) == 2
# regex with ints in column names
# from PR #10384
@@ -693,41 +691,41 @@ def test_filter(self):
expected = DataFrame(
0., index=[0, 1, 2], columns=pd.Index([1, 2], dtype=object))
filtered = df.filter(regex='^[0-9]+$')
- assert_frame_equal(filtered, expected)
+ tm.assert_frame_equal(filtered, expected)
expected = DataFrame(0., index=[0, 1, 2], columns=[0, '0', 1, '1'])
# shouldn't remove anything
filtered = expected.filter(regex='^[0-9]+$')
- assert_frame_equal(filtered, expected)
+ tm.assert_frame_equal(filtered, expected)
# pass in None
- with assertRaisesRegexp(TypeError, 'Must pass'):
+ with tm.assertRaisesRegexp(TypeError, 'Must pass'):
self.frame.filter()
- with assertRaisesRegexp(TypeError, 'Must pass'):
+ with tm.assertRaisesRegexp(TypeError, 'Must pass'):
self.frame.filter(items=None)
- with assertRaisesRegexp(TypeError, 'Must pass'):
+ with tm.assertRaisesRegexp(TypeError, 'Must pass'):
self.frame.filter(axis=1)
# test mutually exclusive arguments
- with assertRaisesRegexp(TypeError, 'mutually exclusive'):
+ with tm.assertRaisesRegexp(TypeError, 'mutually exclusive'):
self.frame.filter(items=['one', 'three'], regex='e$', like='bbi')
- with assertRaisesRegexp(TypeError, 'mutually exclusive'):
+ with tm.assertRaisesRegexp(TypeError, 'mutually exclusive'):
self.frame.filter(items=['one', 'three'], regex='e$', axis=1)
- with assertRaisesRegexp(TypeError, 'mutually exclusive'):
+ with tm.assertRaisesRegexp(TypeError, 'mutually exclusive'):
self.frame.filter(items=['one', 'three'], regex='e$')
- with assertRaisesRegexp(TypeError, 'mutually exclusive'):
+ with tm.assertRaisesRegexp(TypeError, 'mutually exclusive'):
self.frame.filter(items=['one', 'three'], like='bbi', axis=0)
- with assertRaisesRegexp(TypeError, 'mutually exclusive'):
+ with tm.assertRaisesRegexp(TypeError, 'mutually exclusive'):
self.frame.filter(items=['one', 'three'], like='bbi')
# objects
filtered = self.mixed_frame.filter(like='foo')
- self.assertIn('foo', filtered)
+ assert 'foo' in filtered
# unicode columns, won't ascii-encode
df = self.frame.rename(columns={'B': u('\u2202')})
filtered = df.filter(like='C')
- self.assertTrue('C' in filtered)
+ assert 'C' in filtered
def test_filter_regex_search(self):
fcopy = self.frame.copy()
@@ -857,10 +855,10 @@ def test_reindex_boolean(self):
def test_reindex_objects(self):
reindexed = self.mixed_frame.reindex(columns=['foo', 'A', 'B'])
- self.assertIn('foo', reindexed)
+ assert 'foo' in reindexed
reindexed = self.mixed_frame.reindex(columns=['A', 'B'])
- self.assertNotIn('foo', reindexed)
+ assert 'foo' not in reindexed
def test_reindex_corner(self):
index = Index(['a', 'b', 'c'])
diff --git a/pandas/tests/frame/test_constructors.py b/pandas/tests/frame/test_constructors.py
index d253fc2049462..3bcc058316f77 100644
--- a/pandas/tests/frame/test_constructors.py
+++ b/pandas/tests/frame/test_constructors.py
@@ -210,8 +210,8 @@ def test_constructor_dict(self):
'col2': self.ts2})
# col2 is padded with NaN
- self.assertEqual(len(self.ts1), 30)
- self.assertEqual(len(self.ts2), 25)
+ assert len(self.ts1) == 30
+ assert len(self.ts2) == 25
tm.assert_series_equal(self.ts1, frame['col1'], check_names=False)
@@ -223,12 +223,12 @@ def test_constructor_dict(self):
'col2': self.ts2},
columns=['col2', 'col3', 'col4'])
- self.assertEqual(len(frame), len(self.ts2))
- self.assertNotIn('col1', frame)
- self.assertTrue(isnull(frame['col3']).all())
+ assert len(frame) == len(self.ts2)
+ assert 'col1' not in frame
+ assert isnull(frame['col3']).all()
# Corner cases
- self.assertEqual(len(DataFrame({})), 0)
+ assert len(DataFrame({})) == 0
# mix dict and array, wrong size - no spec for which error should raise
# first
@@ -242,14 +242,14 @@ def test_constructor_dict(self):
# empty dict plus index
idx = Index([0, 1, 2])
frame = DataFrame({}, index=idx)
- self.assertIs(frame.index, idx)
+ assert frame.index is idx
# empty with index and columns
idx = Index([0, 1, 2])
frame = DataFrame({}, index=idx, columns=idx)
- self.assertIs(frame.index, idx)
- self.assertIs(frame.columns, idx)
- self.assertEqual(len(frame._series), 3)
+ assert frame.index is idx
+ assert frame.columns is idx
+ assert len(frame._series) == 3
# with dict of empty list and Series
frame = DataFrame({'A': [], 'B': []}, columns=['A', 'B'])
@@ -1533,11 +1533,11 @@ def test_from_records_to_records(self):
# what to do?
records = indexed_frame.to_records()
- self.assertEqual(len(records.dtype.names), 3)
+ assert len(records.dtype.names) == 3
records = indexed_frame.to_records(index=False)
- self.assertEqual(len(records.dtype.names), 2)
- self.assertNotIn('index', records.dtype.names)
+ assert len(records.dtype.names) == 2
+ assert 'index' not in records.dtype.names
def test_from_records_nones(self):
tuples = [(1, 2, None, 3),
diff --git a/pandas/tests/frame/test_mutate_columns.py b/pandas/tests/frame/test_mutate_columns.py
index a7da704e73764..dfaeaea49cf75 100644
--- a/pandas/tests/frame/test_mutate_columns.py
+++ b/pandas/tests/frame/test_mutate_columns.py
@@ -7,9 +7,7 @@
from pandas import DataFrame, Series, Index, MultiIndex
-from pandas.util.testing import (assert_series_equal,
- assert_frame_equal,
- assertRaisesRegexp)
+from pandas.util.testing import assert_frame_equal, assertRaisesRegexp
import pandas.util.testing as tm
@@ -163,7 +161,7 @@ def test_insert(self):
def test_delitem(self):
del self.frame['A']
- self.assertNotIn('A', self.frame)
+ assert 'A' not in self.frame
def test_delitem_multiindex(self):
midx = MultiIndex.from_product([['A', 'B'], [1, 2]])
@@ -194,15 +192,14 @@ def test_pop(self):
self.frame.columns.name = 'baz'
self.frame.pop('A')
- self.assertNotIn('A', self.frame)
+ assert 'A' not in self.frame
self.frame['foo'] = 'bar'
self.frame.pop('foo')
- self.assertNotIn('foo', self.frame)
+ assert 'foo' not in self.frame
# TODO self.assertEqual(self.frame.columns.name, 'baz')
- # 10912
- # inplace ops cause caching issue
+ # gh-10912: inplace ops cause caching issue
a = DataFrame([[1, 2, 3], [4, 5, 6]], columns=[
'A', 'B', 'C'], index=['X', 'Y'])
b = a.pop('B')
@@ -211,11 +208,11 @@ def test_pop(self):
# original frame
expected = DataFrame([[1, 3], [4, 6]], columns=[
'A', 'C'], index=['X', 'Y'])
- assert_frame_equal(a, expected)
+ tm.assert_frame_equal(a, expected)
# result
expected = Series([2, 5], index=['X', 'Y'], name='B') + 1
- assert_series_equal(b, expected)
+ tm.assert_series_equal(b, expected)
def test_pop_non_unique_cols(self):
df = DataFrame({0: [0, 1], 1: [0, 1], 2: [4, 5]})
diff --git a/pandas/tests/indexes/test_base.py b/pandas/tests/indexes/test_base.py
index 695d3aa7ebe3a..9a166aa3340e3 100644
--- a/pandas/tests/indexes/test_base.py
+++ b/pandas/tests/indexes/test_base.py
@@ -851,8 +851,8 @@ def test_add_string(self):
index = Index(['a', 'b', 'c'])
index2 = index + 'foo'
- self.assertNotIn('a', index2)
- self.assertIn('afoo', index2)
+ assert 'a' not in index2
+ assert 'afoo' in index2
def test_iadd_string(self):
index = pd.Index(['a', 'b', 'c'])
diff --git a/pandas/tests/indexes/test_interval.py b/pandas/tests/indexes/test_interval.py
index 53b5c01c40899..c34d93cb21b0f 100644
--- a/pandas/tests/indexes/test_interval.py
+++ b/pandas/tests/indexes/test_interval.py
@@ -458,20 +458,20 @@ def test_get_indexer_subintervals(self):
tm.assert_numpy_array_equal(actual, expected)
def test_contains(self):
- # only endpoints are valid
+ # Only endpoints are valid.
i = IntervalIndex.from_arrays([0, 1], [1, 2])
- # invalid
- self.assertNotIn(0, i)
- self.assertNotIn(1, i)
- self.assertNotIn(2, i)
+ # Invalid
+ assert 0 not in i
+ assert 1 not in i
+ assert 2 not in i
- # valid
- self.assertIn(Interval(0, 1), i)
- self.assertIn(Interval(0, 2), i)
- self.assertIn(Interval(0, 0.5), i)
- self.assertNotIn(Interval(3, 5), i)
- self.assertNotIn(Interval(-1, 0, closed='left'), i)
+ # Valid
+ assert Interval(0, 1) in i
+ assert Interval(0, 2) in i
+ assert Interval(0, 0.5) in i
+ assert Interval(3, 5) not in i
+ assert Interval(-1, 0, closed='left') not in i
def testcontains(self):
# can select values that are IN the range of a value
@@ -509,7 +509,7 @@ def test_non_contiguous(self):
expected = np.array([0, -1, 1], dtype='intp')
tm.assert_numpy_array_equal(actual, expected)
- self.assertNotIn(1.5, index)
+ assert 1.5 not in index
def test_union(self):
other = IntervalIndex.from_arrays([2], [3])
@@ -651,11 +651,12 @@ def test_datetime(self):
expected = pd.date_range('2000-01-01T12:00', periods=2)
tm.assert_index_equal(idx.mid, expected)
- self.assertNotIn(pd.Timestamp('2000-01-01T12'), idx)
- self.assertNotIn(pd.Timestamp('2000-01-01T12'), idx)
+ assert pd.Timestamp('2000-01-01T12') not in idx
+ assert pd.Timestamp('2000-01-01T12') not in idx
target = pd.date_range('1999-12-31T12:00', periods=7, freq='12H')
actual = idx.get_indexer(target)
+
expected = np.array([-1, -1, 0, 0, 1, 1, -1], dtype='intp')
tm.assert_numpy_array_equal(actual, expected)
diff --git a/pandas/tests/indexes/test_multi.py b/pandas/tests/indexes/test_multi.py
index c671a33e2f171..5000a71dfc756 100644
--- a/pandas/tests/indexes/test_multi.py
+++ b/pandas/tests/indexes/test_multi.py
@@ -1058,9 +1058,9 @@ def test_from_tuples_index_values(self):
self.assertTrue((result.values == self.index.values).all())
def test_contains(self):
- self.assertIn(('foo', 'two'), self.index)
- self.assertNotIn(('bar', 'two'), self.index)
- self.assertNotIn(None, self.index)
+ assert ('foo', 'two') in self.index
+ assert ('bar', 'two') not in self.index
+ assert None not in self.index
def test_contains_top_level(self):
midx = MultiIndex.from_product([['A', 'B'], [1, 2]])
@@ -1287,15 +1287,15 @@ def test_truncate(self):
labels=[major_labels, minor_labels])
result = index.truncate(before=1)
- self.assertNotIn('foo', result.levels[0])
- self.assertIn(1, result.levels[0])
+ assert 'foo' not in result.levels[0]
+ assert 1 in result.levels[0]
result = index.truncate(after=1)
- self.assertNotIn(2, result.levels[0])
- self.assertIn(1, result.levels[0])
+ assert 2 not in result.levels[0]
+ assert 1 in result.levels[0]
result = index.truncate(before=1, after=2)
- self.assertEqual(len(result.levels[0]), 2)
+ assert len(result.levels[0]) == 2
# after < before
pytest.raises(ValueError, index.truncate, 3, 1)
diff --git a/pandas/tests/indexes/timedeltas/test_ops.py b/pandas/tests/indexes/timedeltas/test_ops.py
index 97c4a1df95963..5201af3af3531 100644
--- a/pandas/tests/indexes/timedeltas/test_ops.py
+++ b/pandas/tests/indexes/timedeltas/test_ops.py
@@ -564,10 +564,10 @@ def test_nonunique_contains(self):
tm.assertIn(idx[0], idx)
def test_unknown_attribute(self):
- # GH 9680
+ # see gh-9680
tdi = pd.timedelta_range(start=0, periods=10, freq='1s')
ts = pd.Series(np.random.normal(size=10), index=tdi)
- self.assertNotIn('foo', ts.__dict__.keys())
+ assert 'foo' not in ts.__dict__.keys()
pytest.raises(AttributeError, lambda: ts.foo)
def test_order(self):
diff --git a/pandas/tests/indexing/test_indexing_slow.py b/pandas/tests/indexing/test_indexing_slow.py
index 42b50e37f0492..21cdbb17f52ce 100644
--- a/pandas/tests/indexing/test_indexing_slow.py
+++ b/pandas/tests/indexing/test_indexing_slow.py
@@ -27,10 +27,10 @@ def validate(mi, df, key):
mask &= df.iloc[:, i] == k
if not mask.any():
- self.assertNotIn(key[:i + 1], mi.index)
+ assert key[:i + 1] not in mi.index
continue
- self.assertIn(key[:i + 1], mi.index)
+ assert key[:i + 1] in mi.index
right = df[mask].copy()
if i + 1 != len(key): # partial key
diff --git a/pandas/tests/io/formats/test_format.py b/pandas/tests/io/formats/test_format.py
index 3784840fbfd28..ea796a497bd19 100644
--- a/pandas/tests/io/formats/test_format.py
+++ b/pandas/tests/io/formats/test_format.py
@@ -183,15 +183,15 @@ def test_repr_truncation(self):
for line, value in lzip(r.split('\n'), df['B']):
if adj.len(value) + 1 > max_len:
- self.assertIn('...', line)
+ assert '...' in line
else:
- self.assertNotIn('...', line)
+ assert '...' not in line
with option_context("display.max_colwidth", 999999):
- self.assertNotIn('...', repr(df))
+ assert '...' not in repr(df)
with option_context("display.max_colwidth", max_len + 2):
- self.assertNotIn('...', repr(df))
+ assert '...' not in repr(df)
def test_repr_chop_threshold(self):
df = DataFrame([[0.1, 0.5], [0.5, -0.1]])
diff --git a/pandas/tests/io/formats/test_to_html.py b/pandas/tests/io/formats/test_to_html.py
index 8b71fb047456e..90c6db1dcc7fb 100644
--- a/pandas/tests/io/formats/test_to_html.py
+++ b/pandas/tests/io/formats/test_to_html.py
@@ -1466,7 +1466,7 @@ def test_to_html_with_no_bold(self):
def test_to_html_columns_arg(self):
frame = DataFrame(tm.getSeriesData())
result = frame.to_html(columns=['A'])
- self.assertNotIn('| B | ', result)
+ assert 'B | ' not in result
def test_to_html_multiindex(self):
columns = MultiIndex.from_tuples(list(zip(np.arange(2).repeat(2),
@@ -1660,7 +1660,7 @@ def test_to_html_index(self):
' \n'
' \n'
'')
- self.assertEqual(df.to_html(), expected_with_index)
+ assert df.to_html() == expected_with_index
expected_without_index = ('\n'
' \n'
@@ -1690,8 +1690,8 @@ def test_to_html_index(self):
'
')
result = df.to_html(index=False)
for i in index:
- self.assertNotIn(i, result)
- self.assertEqual(result, expected_without_index)
+ assert i not in result
+ assert result == expected_without_index
df.index = Index(['foo', 'bar', 'baz'], name='idx')
expected_with_index = ('\n'
' \n'
@@ -1729,8 +1729,8 @@ def test_to_html_index(self):
' \n'
' \n'
'
')
- self.assertEqual(df.to_html(), expected_with_index)
- self.assertEqual(df.to_html(index=False), expected_without_index)
+ assert df.to_html() == expected_with_index
+ assert df.to_html(index=False) == expected_without_index
tuples = [('foo', 'car'), ('foo', 'bike'), ('bar', 'car')]
df.index = MultiIndex.from_tuples(tuples)
@@ -1768,13 +1768,13 @@ def test_to_html_index(self):
' \n'
' \n'
'')
- self.assertEqual(df.to_html(), expected_with_index)
+ assert df.to_html() == expected_with_index
result = df.to_html(index=False)
for i in ['foo', 'bar', 'car', 'bike']:
- self.assertNotIn(i, result)
+ assert i not in result
# must be the same result as normal index
- self.assertEqual(result, expected_without_index)
+ assert result == expected_without_index
df.index = MultiIndex.from_tuples(tuples, names=['idx1', 'idx2'])
expected_with_index = ('\n'
@@ -1817,8 +1817,8 @@ def test_to_html_index(self):
' \n'
' \n'
'
')
- self.assertEqual(df.to_html(), expected_with_index)
- self.assertEqual(df.to_html(index=False), expected_without_index)
+ assert df.to_html() == expected_with_index
+ assert df.to_html(index=False) == expected_without_index
def test_to_html_with_classes(self):
df = DataFrame()
diff --git a/pandas/tests/io/parser/parse_dates.py b/pandas/tests/io/parser/parse_dates.py
index 6dd92783eac60..cdc4f9fa9d84f 100644
--- a/pandas/tests/io/parser/parse_dates.py
+++ b/pandas/tests/io/parser/parse_dates.py
@@ -60,26 +60,26 @@ def func(*date_cols):
prefix='X',
parse_dates={'nominal': [1, 2],
'actual': [1, 3]})
- self.assertIn('nominal', df)
- self.assertIn('actual', df)
- self.assertNotIn('X1', df)
- self.assertNotIn('X2', df)
- self.assertNotIn('X3', df)
+ assert 'nominal' in df
+ assert 'actual' in df
+ assert 'X1' not in df
+ assert 'X2' not in df
+ assert 'X3' not in df
d = datetime(1999, 1, 27, 19, 0)
- self.assertEqual(df.loc[0, 'nominal'], d)
+ assert df.loc[0, 'nominal'] == d
df = self.read_csv(StringIO(data), header=None,
date_parser=func,
parse_dates={'nominal': [1, 2],
'actual': [1, 3]},
keep_date_col=True)
- self.assertIn('nominal', df)
- self.assertIn('actual', df)
+ assert 'nominal' in df
+ assert 'actual' in df
- self.assertIn(1, df)
- self.assertIn(2, df)
- self.assertIn(3, df)
+ assert 1 in df
+ assert 2 in df
+ assert 3 in df
data = """\
KORD,19990127, 19:00:00, 18:56:00, 0.8100, 2.8100, 7.2000, 0.0000, 280.0000
@@ -92,23 +92,23 @@ def func(*date_cols):
df = self.read_csv(StringIO(data), header=None,
prefix='X', parse_dates=[[1, 2], [1, 3]])
- self.assertIn('X1_X2', df)
- self.assertIn('X1_X3', df)
- self.assertNotIn('X1', df)
- self.assertNotIn('X2', df)
- self.assertNotIn('X3', df)
+ assert 'X1_X2' in df
+ assert 'X1_X3' in df
+ assert 'X1' not in df
+ assert 'X2' not in df
+ assert 'X3' not in df
d = datetime(1999, 1, 27, 19, 0)
- self.assertEqual(df.loc[0, 'X1_X2'], d)
+ assert df.loc[0, 'X1_X2'] == d
df = self.read_csv(StringIO(data), header=None,
parse_dates=[[1, 2], [1, 3]], keep_date_col=True)
- self.assertIn('1_2', df)
- self.assertIn('1_3', df)
- self.assertIn(1, df)
- self.assertIn(2, df)
- self.assertIn(3, df)
+ assert '1_2' in df
+ assert '1_3' in df
+ assert 1 in df
+ assert 2 in df
+ assert 3 in df
data = '''\
KORD,19990127 19:00:00, 18:56:00, 0.8100, 2.8100, 7.2000, 0.0000, 280.0000
@@ -120,7 +120,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.assertEqual(df.index[0], d)
+ assert df.index[0] == d
def test_multiple_date_cols_int_cast(self):
data = ("KORD,19990127, 19:00:00, 18:56:00, 0.8100\n"
@@ -402,7 +402,7 @@ def test_multiple_date_cols_chunked(self):
chunks = list(reader)
- self.assertNotIn('nominalTime', df)
+ assert 'nominalTime' not in df
tm.assert_frame_equal(chunks[0], df[:2])
tm.assert_frame_equal(chunks[1], df[2:4])
diff --git a/pandas/tests/io/test_pytables.py b/pandas/tests/io/test_pytables.py
index 153ac749b4b17..d077dd879d44a 100644
--- a/pandas/tests/io/test_pytables.py
+++ b/pandas/tests/io/test_pytables.py
@@ -439,19 +439,18 @@ def test_contains(self):
store['a'] = tm.makeTimeSeries()
store['b'] = tm.makeDataFrame()
store['foo/bar'] = tm.makeDataFrame()
- self.assertIn('a', store)
- self.assertIn('b', store)
- self.assertNotIn('c', store)
- self.assertIn('foo/bar', store)
- self.assertIn('/foo/bar', store)
- self.assertNotIn('/foo/b', store)
- self.assertNotIn('bar', store)
-
- # GH 2694
- # tables.NaturalNameWarning
+ assert 'a' in store
+ assert 'b' in store
+ assert 'c' not in store
+ assert 'foo/bar' in store
+ assert '/foo/bar' in store
+ assert '/foo/b' not in store
+ assert 'bar' not in store
+
+ # gh-2694: tables.NaturalNameWarning
with catch_warnings(record=True):
store['node())'] = tm.makeDataFrame()
- self.assertIn('node())', store)
+ assert 'node())' in store
def test_versioning(self):
@@ -4288,7 +4287,7 @@ def _check_roundtrip_table(self, obj, comparator, compression=False):
comparator(retrieved, obj)
def test_multiple_open_close(self):
- # GH 4409, open & close multiple times
+ # gh-4409: open & close multiple times
with ensure_clean_path(self.path) as path:
@@ -4297,11 +4296,12 @@ def test_multiple_open_close(self):
# single
store = HDFStore(path)
- self.assertNotIn('CLOSED', str(store))
- self.assertTrue(store.is_open)
+ assert 'CLOSED' not in str(store)
+ assert store.is_open
+
store.close()
- self.assertIn('CLOSED', str(store))
- self.assertFalse(store.is_open)
+ assert 'CLOSED' in str(store)
+ assert not store.is_open
with ensure_clean_path(self.path) as path:
@@ -4321,22 +4321,22 @@ def f():
store1 = HDFStore(path)
store2 = HDFStore(path)
- self.assertNotIn('CLOSED', str(store1))
- self.assertNotIn('CLOSED', str(store2))
- self.assertTrue(store1.is_open)
- self.assertTrue(store2.is_open)
+ assert 'CLOSED' not in str(store1)
+ assert 'CLOSED' not in str(store2)
+ assert store1.is_open
+ assert store2.is_open
store1.close()
- self.assertIn('CLOSED', str(store1))
- self.assertFalse(store1.is_open)
- self.assertNotIn('CLOSED', str(store2))
- self.assertTrue(store2.is_open)
+ assert 'CLOSED' in str(store1)
+ assert not store1.is_open
+ assert 'CLOSED' not in str(store2)
+ assert store2.is_open
store2.close()
- self.assertIn('CLOSED', str(store1))
- self.assertIn('CLOSED', str(store2))
- self.assertFalse(store1.is_open)
- self.assertFalse(store2.is_open)
+ assert 'CLOSED' in str(store1)
+ assert 'CLOSED' in str(store2)
+ assert not store1.is_open
+ assert not store2.is_open
# nested close
store = HDFStore(path, mode='w')
@@ -4345,12 +4345,12 @@ def f():
store2 = HDFStore(path)
store2.append('df2', df)
store2.close()
- self.assertIn('CLOSED', str(store2))
- self.assertFalse(store2.is_open)
+ assert 'CLOSED' in str(store2)
+ assert not store2.is_open
store.close()
- self.assertIn('CLOSED', str(store))
- self.assertFalse(store.is_open)
+ assert 'CLOSED' in str(store)
+ assert not store.is_open
# double closing
store = HDFStore(path, mode='w')
@@ -4358,12 +4358,12 @@ def f():
store2 = HDFStore(path)
store.close()
- self.assertIn('CLOSED', str(store))
- self.assertFalse(store.is_open)
+ assert 'CLOSED' in str(store)
+ assert not store.is_open
store2.close()
- self.assertIn('CLOSED', str(store2))
- self.assertFalse(store2.is_open)
+ assert 'CLOSED' in str(store2)
+ assert not store2.is_open
# ops on a closed store
with ensure_clean_path(self.path) as path:
diff --git a/pandas/tests/scalar/test_interval.py b/pandas/tests/scalar/test_interval.py
index 717ef38a5b447..bd73a7d173962 100644
--- a/pandas/tests/scalar/test_interval.py
+++ b/pandas/tests/scalar/test_interval.py
@@ -26,19 +26,19 @@ def test_repr(self):
self.assertEqual(str(interval_left), "[0, 1)")
def test_contains(self):
- self.assertIn(0.5, self.interval)
- self.assertIn(1, self.interval)
- self.assertNotIn(0, self.interval)
+ assert 0.5 in self.interval
+ assert 1 in self.interval
+ assert 0 not in self.interval
pytest.raises(TypeError, lambda: self.interval in self.interval)
interval = Interval(0, 1, closed='both')
- self.assertIn(0, interval)
- self.assertIn(1, interval)
+ assert 0 in interval
+ assert 1 in interval
interval = Interval(0, 1, closed='neither')
- self.assertNotIn(0, interval)
- self.assertIn(0.5, interval)
- self.assertNotIn(1, interval)
+ assert 0 not in interval
+ assert 0.5 in interval
+ assert 1 not in interval
def test_equal(self):
self.assertEqual(Interval(0, 1), Interval(0, 1, closed='right'))
diff --git a/pandas/tests/scalar/test_timestamp.py b/pandas/tests/scalar/test_timestamp.py
index ae351b9d1cab9..055da8b2cc07f 100644
--- a/pandas/tests/scalar/test_timestamp.py
+++ b/pandas/tests/scalar/test_timestamp.py
@@ -310,40 +310,40 @@ def test_repr(self):
tz_repr = tz
date_only = Timestamp(date)
- self.assertIn(date, repr(date_only))
- self.assertNotIn(tz_repr, repr(date_only))
- self.assertNotIn(freq_repr, repr(date_only))
- self.assertEqual(date_only, eval(repr(date_only)))
+ assert date in repr(date_only)
+ assert tz_repr not in repr(date_only)
+ assert freq_repr not in repr(date_only)
+ assert date_only == eval(repr(date_only))
date_tz = Timestamp(date, tz=tz)
- self.assertIn(date, repr(date_tz))
- self.assertIn(tz_repr, repr(date_tz))
- self.assertNotIn(freq_repr, repr(date_tz))
- self.assertEqual(date_tz, eval(repr(date_tz)))
+ assert date in repr(date_tz)
+ assert tz_repr in repr(date_tz)
+ assert freq_repr not in repr(date_tz)
+ assert date_tz == eval(repr(date_tz))
date_freq = Timestamp(date, freq=freq)
- self.assertIn(date, repr(date_freq))
- self.assertNotIn(tz_repr, repr(date_freq))
- self.assertIn(freq_repr, repr(date_freq))
- self.assertEqual(date_freq, eval(repr(date_freq)))
+ assert date in repr(date_freq)
+ assert tz_repr not in repr(date_freq)
+ assert freq_repr in repr(date_freq)
+ assert date_freq == eval(repr(date_freq))
date_tz_freq = Timestamp(date, tz=tz, freq=freq)
- self.assertIn(date, repr(date_tz_freq))
- self.assertIn(tz_repr, repr(date_tz_freq))
- self.assertIn(freq_repr, repr(date_tz_freq))
- self.assertEqual(date_tz_freq, eval(repr(date_tz_freq)))
+ assert date in repr(date_tz_freq)
+ assert tz_repr in repr(date_tz_freq)
+ assert freq_repr in repr(date_tz_freq)
+ assert date_tz_freq == eval(repr(date_tz_freq))
- # this can cause the tz field to be populated, but it's redundant to
- # information in the datestring
+ # This can cause the tz field to be populated, but it's redundant to
+ # include this information in the date-string.
tm._skip_if_no_pytz()
import pytz # noqa
date_with_utc_offset = Timestamp('2014-03-13 00:00:00-0400', tz=None)
- self.assertIn('2014-03-13 00:00:00-0400', repr(date_with_utc_offset))
- self.assertNotIn('tzoffset', repr(date_with_utc_offset))
- self.assertIn('pytz.FixedOffset(-240)', repr(date_with_utc_offset))
+ assert '2014-03-13 00:00:00-0400' in repr(date_with_utc_offset)
+ assert 'tzoffset' not in repr(date_with_utc_offset)
+ assert 'pytz.FixedOffset(-240)' in repr(date_with_utc_offset)
expr = repr(date_with_utc_offset).replace("'pytz.FixedOffset(-240)'",
'pytz.FixedOffset(-240)')
- self.assertEqual(date_with_utc_offset, eval(expr))
+ assert date_with_utc_offset == eval(expr)
def test_bounds_with_different_units(self):
out_of_bounds_dates = ('1677-09-21', '2262-04-12', )
diff --git a/pandas/tests/series/test_indexing.py b/pandas/tests/series/test_indexing.py
index 1003e84a1a942..1181e3a44f295 100644
--- a/pandas/tests/series/test_indexing.py
+++ b/pandas/tests/series/test_indexing.py
@@ -653,22 +653,20 @@ def test_slice(self):
numSliceEnd = self.series[-10:]
objSlice = self.objSeries[10:20]
- self.assertNotIn(self.series.index[9], numSlice.index)
- self.assertNotIn(self.objSeries.index[9], objSlice.index)
+ assert self.series.index[9] not in numSlice.index
+ assert self.objSeries.index[9] not in objSlice.index
- self.assertEqual(len(numSlice), len(numSlice.index))
- self.assertEqual(self.series[numSlice.index[0]],
- numSlice[numSlice.index[0]])
+ assert len(numSlice) == len(numSlice.index)
+ assert self.series[numSlice.index[0]] == numSlice[numSlice.index[0]]
- self.assertEqual(numSlice.index[1], self.series.index[11])
+ assert numSlice.index[1] == self.series.index[11]
+ assert tm.equalContents(numSliceEnd, np.array(self.series)[-10:])
- self.assertTrue(tm.equalContents(numSliceEnd, np.array(self.series)[
- -10:]))
-
- # test return view
+ # Test return view.
sl = self.series[10:20]
sl[:] = 0
- self.assertTrue((self.series[10:20] == 0).all())
+
+ assert (self.series[10:20] == 0).all()
def test_slice_can_reorder_not_uniquely_indexed(self):
s = Series(1, index=['a', 'a', 'b', 'b', 'c'])
diff --git a/pandas/tests/series/test_repr.py b/pandas/tests/series/test_repr.py
index 188b96638344c..a80c5edcc21bd 100644
--- a/pandas/tests/series/test_repr.py
+++ b/pandas/tests/series/test_repr.py
@@ -37,21 +37,26 @@ def test_multilevel_name_print(self):
self.assertEqual(repr(s), expected)
def test_name_printing(self):
- # test small series
+ # Test small Series.
s = Series([0, 1, 2])
+
s.name = "test"
- self.assertIn("Name: test", repr(s))
+ assert "Name: test" in repr(s)
+
s.name = None
- self.assertNotIn("Name:", repr(s))
- # test big series (diff code path)
+ assert "Name:" not in repr(s)
+
+ # Test big Series (diff code path).
s = Series(lrange(0, 1000))
+
s.name = "test"
- self.assertIn("Name: test", repr(s))
+ assert "Name: test" in repr(s)
+
s.name = None
- self.assertNotIn("Name:", repr(s))
+ assert "Name:" not in repr(s)
s = Series(index=date_range('20010101', '20020101'), name='test')
- self.assertIn("Name: test", repr(s))
+ assert "Name: test" in repr(s)
def test_repr(self):
str(self.ts)
diff --git a/pandas/tests/sparse/test_frame.py b/pandas/tests/sparse/test_frame.py
index d5df744648ff3..ccb72d1f0d788 100644
--- a/pandas/tests/sparse/test_frame.py
+++ b/pandas/tests/sparse/test_frame.py
@@ -545,15 +545,15 @@ def test_delitem(self):
C = self.frame['C']
del self.frame['B']
- self.assertNotIn('B', self.frame)
+ assert 'B' not in self.frame
tm.assert_sp_series_equal(self.frame['A'], A)
tm.assert_sp_series_equal(self.frame['C'], C)
del self.frame['D']
- self.assertNotIn('D', self.frame)
+ assert 'D' not in self.frame
del self.frame['A']
- self.assertNotIn('A', self.frame)
+ assert 'A' not in self.frame
def test_set_columns(self):
self.frame.columns = self.frame.columns
@@ -829,22 +829,22 @@ def _check_frame(frame):
# length zero
length_zero = frame.reindex([])
- self.assertEqual(len(length_zero), 0)
- self.assertEqual(len(length_zero.columns), len(frame.columns))
- self.assertEqual(len(length_zero['A']), 0)
+ assert len(length_zero) == 0
+ assert len(length_zero.columns) == len(frame.columns)
+ assert len(length_zero['A']) == 0
# frame being reindexed has length zero
length_n = length_zero.reindex(index)
- self.assertEqual(len(length_n), len(frame))
- self.assertEqual(len(length_n.columns), len(frame.columns))
- self.assertEqual(len(length_n['A']), len(frame))
+ assert len(length_n) == len(frame)
+ assert len(length_n.columns) == len(frame.columns)
+ assert len(length_n['A']) == len(frame)
# reindex columns
reindexed = frame.reindex(columns=['A', 'B', 'Z'])
- self.assertEqual(len(reindexed.columns), 3)
+ assert len(reindexed.columns) == 3
tm.assert_almost_equal(reindexed['Z'].fill_value,
frame.default_fill_value)
- self.assertTrue(np.isnan(reindexed['Z'].sp_values).all())
+ assert np.isnan(reindexed['Z'].sp_values).all()
_check_frame(self.frame)
_check_frame(self.iframe)
@@ -854,11 +854,11 @@ def _check_frame(frame):
# with copy=False
reindexed = self.frame.reindex(self.frame.index, copy=False)
reindexed['F'] = reindexed['A']
- self.assertIn('F', self.frame)
+ assert 'F' in self.frame
reindexed = self.frame.reindex(self.frame.index)
reindexed['G'] = reindexed['A']
- self.assertNotIn('G', self.frame)
+ assert 'G' not in self.frame
def test_reindex_fill_value(self):
rng = bdate_range('20110110', periods=20)
diff --git a/pandas/tests/test_base.py b/pandas/tests/test_base.py
index d91aab6bc3ceb..5814ae3494b44 100644
--- a/pandas/tests/test_base.py
+++ b/pandas/tests/test_base.py
@@ -45,8 +45,8 @@ class CheckImmutable(object):
mutable_regex = re.compile('does not support mutable operations')
def check_mutable_error(self, *args, **kwargs):
- # pass whatever functions you normally would to assertRaises (after the
- # Exception kind)
+ # Pass whatever function you normally would to assertRaisesRegexp
+ # (after the Exception kind).
tm.assertRaisesRegexp(TypeError, self.mutable_regex, *args, **kwargs)
def test_no_mutable_funcs(self):
@@ -70,6 +70,7 @@ def delslice():
self.check_mutable_error(delslice)
mutable_methods = getattr(self, "mutable_methods", [])
+
for meth in mutable_methods:
self.check_mutable_error(getattr(self.container, meth))
diff --git a/pandas/tests/test_panel.py b/pandas/tests/test_panel.py
index 703c8cc80e8f9..af56f0c33df2e 100644
--- a/pandas/tests/test_panel.py
+++ b/pandas/tests/test_panel.py
@@ -205,22 +205,22 @@ def test_set_axis(self):
self.panel.items = new_items
if hasattr(self.panel, '_item_cache'):
- self.assertNotIn('ItemA', self.panel._item_cache)
- self.assertIs(self.panel.items, new_items)
+ assert 'ItemA' not in self.panel._item_cache
+ assert self.panel.items is new_items
# TODO: unused?
item = self.panel[0] # noqa
self.panel.major_axis = new_major
- self.assertIs(self.panel[0].index, new_major)
- self.assertIs(self.panel.major_axis, new_major)
+ assert self.panel[0].index is new_major
+ assert self.panel.major_axis is new_major
# TODO: unused?
item = self.panel[0] # noqa
self.panel.minor_axis = new_minor
- self.assertIs(self.panel[0].columns, new_minor)
- self.assertIs(self.panel.minor_axis, new_minor)
+ assert self.panel[0].columns is new_minor
+ assert self.panel.minor_axis is new_minor
def test_get_axis_number(self):
self.assertEqual(self.panel._get_axis_number('items'), 0)
@@ -447,10 +447,10 @@ def test_delitem_and_pop(self):
expected = self.panel['ItemA']
result = self.panel.pop('ItemA')
assert_frame_equal(expected, result)
- self.assertNotIn('ItemA', self.panel.items)
+ assert 'ItemA' not in self.panel.items
del self.panel['ItemB']
- self.assertNotIn('ItemB', self.panel.items)
+ assert 'ItemB' not in self.panel.items
pytest.raises(Exception, self.panel.__delitem__, 'ItemB')
values = np.empty((3, 3, 3))
@@ -464,18 +464,18 @@ def test_delitem_and_pop(self):
panelc = panel.copy()
del panelc[0]
- assert_frame_equal(panelc[1], panel[1])
- assert_frame_equal(panelc[2], panel[2])
+ tm.assert_frame_equal(panelc[1], panel[1])
+ tm.assert_frame_equal(panelc[2], panel[2])
panelc = panel.copy()
del panelc[1]
- assert_frame_equal(panelc[0], panel[0])
- assert_frame_equal(panelc[2], panel[2])
+ tm.assert_frame_equal(panelc[0], panel[0])
+ tm.assert_frame_equal(panelc[2], panel[2])
panelc = panel.copy()
del panelc[2]
- assert_frame_equal(panelc[1], panel[1])
- assert_frame_equal(panelc[0], panel[0])
+ tm.assert_frame_equal(panelc[1], panel[1])
+ tm.assert_frame_equal(panelc[0], panel[0])
def test_setitem(self):
with catch_warnings(record=True):
diff --git a/pandas/tests/test_panel4d.py b/pandas/tests/test_panel4d.py
index f55452b44731c..33b17bc04cd79 100644
--- a/pandas/tests/test_panel4d.py
+++ b/pandas/tests/test_panel4d.py
@@ -182,16 +182,16 @@ def test_set_axis(self):
self.panel4d.labels = new_labels
if hasattr(self.panel4d, '_item_cache'):
- self.assertNotIn('l1', self.panel4d._item_cache)
- self.assertIs(self.panel4d.labels, new_labels)
+ assert 'l1' not in self.panel4d._item_cache
+ assert self.panel4d.labels is new_labels
self.panel4d.major_axis = new_major
- self.assertIs(self.panel4d[0].major_axis, new_major)
- self.assertIs(self.panel4d.major_axis, new_major)
+ assert self.panel4d[0].major_axis is new_major
+ assert self.panel4d.major_axis is new_major
self.panel4d.minor_axis = new_minor
- self.assertIs(self.panel4d[0].minor_axis, new_minor)
- self.assertIs(self.panel4d.minor_axis, new_minor)
+ assert self.panel4d[0].minor_axis is new_minor
+ assert self.panel4d.minor_axis is new_minor
def test_get_axis_number(self):
self.assertEqual(self.panel4d._get_axis_number('labels'), 0)
@@ -315,10 +315,10 @@ def test_delitem_and_pop(self):
expected = self.panel4d['l2']
result = self.panel4d.pop('l2')
assert_panel_equal(expected, result)
- self.assertNotIn('l2', self.panel4d.labels)
+ assert 'l2' not in self.panel4d.labels
del self.panel4d['l3']
- self.assertNotIn('l3', self.panel4d.labels)
+ assert 'l3' not in self.panel4d.labels
pytest.raises(Exception, self.panel4d.__delitem__, 'l3')
values = np.empty((4, 4, 4, 4))
@@ -333,27 +333,27 @@ def test_delitem_and_pop(self):
# did we delete the right row?
panel4dc = panel4d.copy()
del panel4dc[0]
- assert_panel_equal(panel4dc[1], panel4d[1])
- assert_panel_equal(panel4dc[2], panel4d[2])
- assert_panel_equal(panel4dc[3], panel4d[3])
+ tm.assert_panel_equal(panel4dc[1], panel4d[1])
+ tm.assert_panel_equal(panel4dc[2], panel4d[2])
+ tm.assert_panel_equal(panel4dc[3], panel4d[3])
panel4dc = panel4d.copy()
del panel4dc[1]
- assert_panel_equal(panel4dc[0], panel4d[0])
- assert_panel_equal(panel4dc[2], panel4d[2])
- assert_panel_equal(panel4dc[3], panel4d[3])
+ tm.assert_panel_equal(panel4dc[0], panel4d[0])
+ tm.assert_panel_equal(panel4dc[2], panel4d[2])
+ tm.assert_panel_equal(panel4dc[3], panel4d[3])
panel4dc = panel4d.copy()
del panel4dc[2]
- assert_panel_equal(panel4dc[1], panel4d[1])
- assert_panel_equal(panel4dc[0], panel4d[0])
- assert_panel_equal(panel4dc[3], panel4d[3])
+ tm.assert_panel_equal(panel4dc[1], panel4d[1])
+ tm.assert_panel_equal(panel4dc[0], panel4d[0])
+ tm.assert_panel_equal(panel4dc[3], panel4d[3])
panel4dc = panel4d.copy()
del panel4dc[3]
- assert_panel_equal(panel4dc[1], panel4d[1])
- assert_panel_equal(panel4dc[2], panel4d[2])
- assert_panel_equal(panel4dc[0], panel4d[0])
+ tm.assert_panel_equal(panel4dc[1], panel4d[1])
+ tm.assert_panel_equal(panel4dc[2], panel4d[2])
+ tm.assert_panel_equal(panel4dc[0], panel4d[0])
def test_setitem(self):
with catch_warnings(record=True):
diff --git a/pandas/util/testing.py b/pandas/util/testing.py
index 7f62d319aa096..7565cbb859201 100644
--- a/pandas/util/testing.py
+++ b/pandas/util/testing.py
@@ -1072,12 +1072,6 @@ def assertIn(first, second, msg=''):
assert a in b, "%s: %r is not in %r" % (msg.format(a, b), a, b)
-def assertNotIn(first, second, msg=''):
- """Checks that 'first' is not in 'second'"""
- a, b = first, second
- assert a not in b, "%s: %r is in %r" % (msg.format(a, b), a, b)
-
-
def assertIsNone(expr, msg=''):
"""Checks that 'expr' is None"""
return assertIs(expr, None, msg)
@@ -2500,40 +2494,79 @@ def assertRaisesRegexp(_exception, _regexp, _callable=None, *args, **kwargs):
class _AssertRaisesContextmanager(object):
"""
- Handles the behind the scenes work
- for assertRaises and assertRaisesRegexp
+ Context manager behind assertRaisesRegexp.
"""
- def __init__(self, exception, regexp=None, *args, **kwargs):
+ def __init__(self, exception, regexp=None):
+ """
+ Initialize an _AssertRaisesContextManager instance.
+
+ Parameters
+ ----------
+ exception : class
+ The expected Exception class.
+ regexp : str, default None
+ The regex to compare against the Exception message.
+ """
+
self.exception = exception
+
if regexp is not None and not hasattr(regexp, "search"):
regexp = re.compile(regexp, re.DOTALL)
+
self.regexp = regexp
def __enter__(self):
return self
- def __exit__(self, exc_type, exc_value, traceback):
+ def __exit__(self, exc_type, exc_value, trace_back):
expected = self.exception
- if not exc_type:
- name = getattr(expected, "__name__", str(expected))
- raise AssertionError("{0} not raised.".format(name))
- if issubclass(exc_type, expected):
- return self.handle_success(exc_type, exc_value, traceback)
- return self.handle_failure(exc_type, exc_value, traceback)
-
- def handle_failure(*args, **kwargs):
- # Failed, so allow Exception to bubble up
- return False
- def handle_success(self, exc_type, exc_value, traceback):
- if self.regexp is not None:
- val = str(exc_value)
- if not self.regexp.search(val):
- e = AssertionError('"%s" does not match "%s"' %
- (self.regexp.pattern, str(val)))
- raise_with_traceback(e, traceback)
- return True
+ if not exc_type:
+ exp_name = getattr(expected, "__name__", str(expected))
+ raise AssertionError("{0} not raised.".format(exp_name))
+
+ return self.exception_matches(exc_type, exc_value, trace_back)
+
+ def exception_matches(self, exc_type, exc_value, trace_back):
+ """
+ Check that the Exception raised matches the expected Exception
+ and expected error message regular expression.
+
+ Parameters
+ ----------
+ exc_type : class
+ The type of Exception raised.
+ exc_value : Exception
+ The instance of `exc_type` raised.
+ trace_back : stack trace object
+ The traceback object associated with `exc_value`.
+
+ Returns
+ -------
+ is_matched : bool
+ Whether or not the Exception raised matches the expected
+ Exception class and expected error message regular expression.
+
+ Raises
+ ------
+ AssertionError : The error message provided does not match
+ the expected error message regular expression.
+ """
+
+ if issubclass(exc_type, self.exception):
+ if self.regexp is not None:
+ val = str(exc_value)
+
+ if not self.regexp.search(val):
+ e = AssertionError('"%s" does not match "%s"' %
+ (self.regexp.pattern, str(val)))
+ raise_with_traceback(e, trace_back)
+
+ return True
+ else:
+ # Failed, so allow Exception to bubble up.
+ return False
@contextmanager