parametrize a bunch of tests

Author: jbrockmendel

pandas/tests/indexes/datetimes/test_arithmetic.py

@@ -614,19 +614,19 @@ def test_sub_dti_dti(self):
         result = dti2 - dti1
         tm.assert_index_equal(result, expected)
 
-    def test_sub_period(self):
-        # GH 13078
+    @pytest.mark.parametrize('freq', [None, 'D'])
+    def test_sub_period(self, freq):
+        # GH#13078
         # not supported, check TypeError
         p = pd.Period('2011-01-01', freq='D')
 
-        for freq in [None, 'D']:
-            idx = pd.DatetimeIndex(['2011-01-01', '2011-01-02'], freq=freq)
+        idx = pd.DatetimeIndex(['2011-01-01', '2011-01-02'], freq=freq)
 
-            with pytest.raises(TypeError):
-                idx - p
+        with pytest.raises(TypeError):
+            idx - p
 
-            with pytest.raises(TypeError):
-                p - idx
+        with pytest.raises(TypeError):
+            p - idx
 
     def test_ufunc_coercions(self):
         idx = date_range('2011-01-01', periods=3, freq='2D', name='x')

pandas/tests/indexes/datetimes/test_construction.py

@@ -351,52 +351,51 @@ def test_constructor_coverage(self):
                       freq='B')
         pytest.raises(ValueError, DatetimeIndex, periods=10, freq='D')
 
-    def test_constructor_datetime64_tzformat(self):
-        # see gh-6572: ISO 8601 format results in pytz.FixedOffset
-        for freq in ['AS', 'W-SUN']:
-            idx = date_range('2013-01-01T00:00:00-05:00',
-                             '2016-01-01T23:59:59-05:00', freq=freq)
-            expected = date_range('2013-01-01T00:00:00', '2016-01-01T23:59:59',
-                                  freq=freq, tz=pytz.FixedOffset(-300))
-            tm.assert_index_equal(idx, expected)
-            # Unable to use `US/Eastern` because of DST
-            expected_i8 = date_range('2013-01-01T00:00:00',
-                                     '2016-01-01T23:59:59', freq=freq,
-                                     tz='America/Lima')
-            tm.assert_numpy_array_equal(idx.asi8, expected_i8.asi8)
-
-            idx = date_range('2013-01-01T00:00:00+09:00',
-                             '2016-01-01T23:59:59+09:00', freq=freq)
-            expected = date_range('2013-01-01T00:00:00', '2016-01-01T23:59:59',
-                                  freq=freq, tz=pytz.FixedOffset(540))
-            tm.assert_index_equal(idx, expected)
-            expected_i8 = date_range('2013-01-01T00:00:00',
-                                     '2016-01-01T23:59:59', freq=freq,
-                                     tz='Asia/Tokyo')
-            tm.assert_numpy_array_equal(idx.asi8, expected_i8.asi8)
+    @pytest.mark.parametrize('freq', ['AS', 'W-SUN'])
+    def test_constructor_datetime64_tzformat(self, freq):
+        # see GH#6572: ISO 8601 format results in pytz.FixedOffset
+        idx = date_range('2013-01-01T00:00:00-05:00',
+                         '2016-01-01T23:59:59-05:00', freq=freq)
+        expected = date_range('2013-01-01T00:00:00', '2016-01-01T23:59:59',
+                              freq=freq, tz=pytz.FixedOffset(-300))
+        tm.assert_index_equal(idx, expected)
+        # Unable to use `US/Eastern` because of DST
+        expected_i8 = date_range('2013-01-01T00:00:00',
+                                 '2016-01-01T23:59:59', freq=freq,
+                                 tz='America/Lima')
+        tm.assert_numpy_array_equal(idx.asi8, expected_i8.asi8)
+
+        idx = date_range('2013-01-01T00:00:00+09:00',
+                         '2016-01-01T23:59:59+09:00', freq=freq)
+        expected = date_range('2013-01-01T00:00:00', '2016-01-01T23:59:59',
+                              freq=freq, tz=pytz.FixedOffset(540))
+        tm.assert_index_equal(idx, expected)
+        expected_i8 = date_range('2013-01-01T00:00:00',
+                                 '2016-01-01T23:59:59', freq=freq,
+                                 tz='Asia/Tokyo')
+        tm.assert_numpy_array_equal(idx.asi8, expected_i8.asi8)
 
         # Non ISO 8601 format results in dateutil.tz.tzoffset
-        for freq in ['AS', 'W-SUN']:
-            idx = date_range('2013/1/1 0:00:00-5:00', '2016/1/1 23:59:59-5:00',
-                             freq=freq)
-            expected = date_range('2013-01-01T00:00:00', '2016-01-01T23:59:59',
-                                  freq=freq, tz=pytz.FixedOffset(-300))
-            tm.assert_index_equal(idx, expected)
-            # Unable to use `US/Eastern` because of DST
-            expected_i8 = date_range('2013-01-01T00:00:00',
-                                     '2016-01-01T23:59:59', freq=freq,
-                                     tz='America/Lima')
-            tm.assert_numpy_array_equal(idx.asi8, expected_i8.asi8)
-
-            idx = date_range('2013/1/1 0:00:00+9:00',
-                             '2016/1/1 23:59:59+09:00', freq=freq)
-            expected = date_range('2013-01-01T00:00:00', '2016-01-01T23:59:59',
-                                  freq=freq, tz=pytz.FixedOffset(540))
-            tm.assert_index_equal(idx, expected)
-            expected_i8 = date_range('2013-01-01T00:00:00',
-                                     '2016-01-01T23:59:59', freq=freq,
-                                     tz='Asia/Tokyo')
-            tm.assert_numpy_array_equal(idx.asi8, expected_i8.asi8)
+        idx = date_range('2013/1/1 0:00:00-5:00', '2016/1/1 23:59:59-5:00',
+                         freq=freq)
+        expected = date_range('2013-01-01T00:00:00', '2016-01-01T23:59:59',
+                              freq=freq, tz=pytz.FixedOffset(-300))
+        tm.assert_index_equal(idx, expected)
+        # Unable to use `US/Eastern` because of DST
+        expected_i8 = date_range('2013-01-01T00:00:00',
+                                 '2016-01-01T23:59:59', freq=freq,
+                                 tz='America/Lima')
+        tm.assert_numpy_array_equal(idx.asi8, expected_i8.asi8)
+
+        idx = date_range('2013/1/1 0:00:00+9:00',
+                         '2016/1/1 23:59:59+09:00', freq=freq)
+        expected = date_range('2013-01-01T00:00:00', '2016-01-01T23:59:59',
+                              freq=freq, tz=pytz.FixedOffset(540))
+        tm.assert_index_equal(idx, expected)
+        expected_i8 = date_range('2013-01-01T00:00:00',
+                                 '2016-01-01T23:59:59', freq=freq,
+                                 tz='Asia/Tokyo')
+        tm.assert_numpy_array_equal(idx.asi8, expected_i8.asi8)
 
     def test_constructor_dtype(self):
 

pandas/tests/indexes/datetimes/test_date_range.py

@@ -222,16 +222,13 @@ def test_range_misspecified(self):
         with tm.assert_raises_regex(ValueError, msg):
             date_range()
 
-    def test_compat_replace(self):
+    @pytest.mark.parametrize('f', [compat.long, int])
+    def test_compat_replace(self, f):
         # https://github.com/statsmodels/statsmodels/issues/3349
         # replace should take ints/longs for compat
-
-        for f in [compat.long, int]:
-            result = date_range(Timestamp('1960-04-01 00:00:00',
-                                          freq='QS-JAN'),
-                                periods=f(76),
-                                freq='QS-JAN')
-            assert len(result) == 76
+        result = date_range(Timestamp('1960-04-01 00:00:00', freq='QS-JAN'),
+                            periods=f(76), freq='QS-JAN')
+        assert len(result) == 76
 
     def test_catch_infinite_loop(self):
         offset = offsets.DateOffset(minute=5)
@@ -484,24 +481,24 @@ def test_range_tz_dateutil(self):
         assert dr[0] == start
         assert dr[2] == end
 
-    def test_range_closed(self):
+    @pytest.mark.parametrize('freq', ["1D", "3D", "2M", "7W", "3H", "A"])
+    def test_range_closed(self, freq):
         begin = datetime(2011, 1, 1)
         end = datetime(2014, 1, 1)
 
-        for freq in ["1D", "3D", "2M", "7W", "3H", "A"]:
-            closed = date_range(begin, end, closed=None, freq=freq)
-            left = date_range(begin, end, closed="left", freq=freq)
-            right = date_range(begin, end, closed="right", freq=freq)
-            expected_left = left
-            expected_right = right
+        closed = date_range(begin, end, closed=None, freq=freq)
+        left = date_range(begin, end, closed="left", freq=freq)
+        right = date_range(begin, end, closed="right", freq=freq)
+        expected_left = left
+        expected_right = right
 
-            if end == closed[-1]:
-                expected_left = closed[:-1]
-            if begin == closed[0]:
-                expected_right = closed[1:]
+        if end == closed[-1]:
+            expected_left = closed[:-1]
+        if begin == closed[0]:
+            expected_right = closed[1:]
 
-            tm.assert_index_equal(expected_left, left)
-            tm.assert_index_equal(expected_right, right)
+        tm.assert_index_equal(expected_left, left)
+        tm.assert_index_equal(expected_right, right)
 
     def test_range_closed_with_tz_aware_start_end(self):
         # GH12409, GH12684
@@ -546,28 +543,28 @@ def test_range_closed_with_tz_aware_start_end(self):
             tm.assert_index_equal(expected_left, left)
             tm.assert_index_equal(expected_right, right)
 
-    def test_range_closed_boundary(self):
-        # GH 11804
-        for closed in ['right', 'left', None]:
-            right_boundary = date_range('2015-09-12', '2015-12-01',
-                                        freq='QS-MAR', closed=closed)
-            left_boundary = date_range('2015-09-01', '2015-09-12',
-                                       freq='QS-MAR', closed=closed)
-            both_boundary = date_range('2015-09-01', '2015-12-01',
-                                       freq='QS-MAR', closed=closed)
-            expected_right = expected_left = expected_both = both_boundary
-
-            if closed == 'right':
-                expected_left = both_boundary[1:]
-            if closed == 'left':
-                expected_right = both_boundary[:-1]
-            if closed is None:
-                expected_right = both_boundary[1:]
-                expected_left = both_boundary[:-1]
-
-            tm.assert_index_equal(right_boundary, expected_right)
-            tm.assert_index_equal(left_boundary, expected_left)
-            tm.assert_index_equal(both_boundary, expected_both)
+    @pytest.mark.parametrize('closed', ['right', 'left', None])
+    def test_range_closed_boundary(self, closed):
+        # GH#11804
+        right_boundary = date_range('2015-09-12', '2015-12-01',
+                                    freq='QS-MAR', closed=closed)
+        left_boundary = date_range('2015-09-01', '2015-09-12',
+                                   freq='QS-MAR', closed=closed)
+        both_boundary = date_range('2015-09-01', '2015-12-01',
+                                   freq='QS-MAR', closed=closed)
+        expected_right = expected_left = expected_both = both_boundary
+
+        if closed == 'right':
+            expected_left = both_boundary[1:]
+        if closed == 'left':
+            expected_right = both_boundary[:-1]
+        if closed is None:
+            expected_right = both_boundary[1:]
+            expected_left = both_boundary[:-1]
+
+        tm.assert_index_equal(right_boundary, expected_right)
+        tm.assert_index_equal(left_boundary, expected_left)
+        tm.assert_index_equal(both_boundary, expected_both)
 
     def test_years_only(self):
         # GH 6961

pandas/tests/indexes/datetimes/test_datetime.py

@@ -356,12 +356,11 @@ def test_does_not_convert_mixed_integer(self):
         assert cols.dtype == joined.dtype
         tm.assert_numpy_array_equal(cols.values, joined.values)
 
-    def test_join_self(self):
+    @pytest.mark.parametrize('how', ['outer', 'inner', 'left', 'right'])
+    def test_join_self(self, how):
         index = date_range('1/1/2000', periods=10)
-        kinds = 'outer', 'inner', 'left', 'right'
-        for kind in kinds:
-            joined = index.join(index, how=kind)
-            assert index is joined
+        joined = index.join(index, how=how)
+        assert index is joined
 
     def assert_index_parameters(self, index):
         assert index.freq == '40960N'
@@ -381,18 +380,17 @@ def test_ns_index(self):
                                      freq=index.freq)
         self.assert_index_parameters(new_index)
 
-    def test_join_with_period_index(self):
+    @pytest.mark.parametrize('how', ['left', 'right', 'inner', 'outer'])
+    def test_join_with_period_index(self, how):
         df = tm.makeCustomDataframe(
             10, 10, data_gen_f=lambda *args: np.random.randint(2),
             c_idx_type='p', r_idx_type='dt')
         s = df.iloc[:5, 0]
-        joins = 'left', 'right', 'inner', 'outer'
 
-        for join in joins:
-            with tm.assert_raises_regex(ValueError,
-                                        'can only call with other '
-                                        'PeriodIndex-ed objects'):
-                df.columns.join(s.index, how=join)
+        with tm.assert_raises_regex(ValueError,
+                                    'can only call with other '
+                                    'PeriodIndex-ed objects'):
+            df.columns.join(s.index, how=how)
 
     def test_factorize(self):
         idx1 = DatetimeIndex(['2014-01', '2014-01', '2014-02', '2014-02',
@@ -439,18 +437,18 @@ def test_factorize(self):
         tm.assert_numpy_array_equal(arr, exp_arr)
         tm.assert_index_equal(idx, idx3)
 
-    def test_factorize_tz(self):
-        # GH 13750
-        for tz in [None, 'UTC', 'US/Eastern', 'Asia/Tokyo']:
-            base = pd.date_range('2016-11-05', freq='H', periods=100, tz=tz)
-            idx = base.repeat(5)
+    @pytest.mark.parametrize('tz', [None, 'UTC', 'US/Eastern', 'Asia/Tokyo'])
+    def test_factorize_tz(self, tz):
+        # GH#13750
+        base = pd.date_range('2016-11-05', freq='H', periods=100, tz=tz)
+        idx = base.repeat(5)
 
-            exp_arr = np.arange(100, dtype=np.intp).repeat(5)
+        exp_arr = np.arange(100, dtype=np.intp).repeat(5)
 
-            for obj in [idx, pd.Series(idx)]:
-                arr, res = obj.factorize()
-                tm.assert_numpy_array_equal(arr, exp_arr)
-                tm.assert_index_equal(res, base)
+        for obj in [idx, pd.Series(idx)]:
+            arr, res = obj.factorize()
+            tm.assert_numpy_array_equal(arr, exp_arr)
+            tm.assert_index_equal(res, base)
 
     def test_factorize_dst(self):
         # GH 13750

pandas/tests/indexes/datetimes/test_indexing.py

@@ -346,25 +346,25 @@ def test_take_invalid_kwargs(self):
                                indices, mode='clip')
 
     # TODO: This method came from test_datetime; de-dup with version above
-    def test_take2(self):
+    @pytest.mark.parametrize('tz', [None, 'US/Eastern', 'Asia/Tokyo'])
+    def test_take2(self, tz):
         dates = [datetime(2010, 1, 1, 14), datetime(2010, 1, 1, 15),
                  datetime(2010, 1, 1, 17), datetime(2010, 1, 1, 21)]
 
-        for tz in [None, 'US/Eastern', 'Asia/Tokyo']:
-            idx = DatetimeIndex(start='2010-01-01 09:00',
-                                end='2010-02-01 09:00', freq='H', tz=tz,
-                                name='idx')
-            expected = DatetimeIndex(dates, freq=None, name='idx', tz=tz)
+        idx = DatetimeIndex(start='2010-01-01 09:00',
+                            end='2010-02-01 09:00', freq='H', tz=tz,
+                            name='idx')
+        expected = DatetimeIndex(dates, freq=None, name='idx', tz=tz)
 
-            taken1 = idx.take([5, 6, 8, 12])
-            taken2 = idx[[5, 6, 8, 12]]
+        taken1 = idx.take([5, 6, 8, 12])
+        taken2 = idx[[5, 6, 8, 12]]
 
-            for taken in [taken1, taken2]:
-                tm.assert_index_equal(taken, expected)
-                assert isinstance(taken, DatetimeIndex)
-                assert taken.freq is None
-                assert taken.tz == expected.tz
-                assert taken.name == expected.name
+        for taken in [taken1, taken2]:
+            tm.assert_index_equal(taken, expected)
+            assert isinstance(taken, DatetimeIndex)
+            assert taken.freq is None
+            assert taken.tz == expected.tz
+            assert taken.name == expected.name
 
     def test_take_fill_value(self):
         # GH 12631