parametrize a whole mess of tests (pandas-dev#19785)

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):
 
@@ -451,36 +450,35 @@ def test_dti_constructor_preserve_dti_freq(self):
         rng2 = DatetimeIndex(rng)
         assert rng.freq == rng2.freq
 
-    def test_dti_constructor_years_only(self):
+    @pytest.mark.parametrize('tz', [None, 'UTC', 'Asia/Tokyo',
+                                    'dateutil/US/Pacific'])
+    def test_dti_constructor_years_only(self, tz):
         # GH 6961
-        for tz in [None, 'UTC', 'Asia/Tokyo', 'dateutil/US/Pacific']:
-            rng1 = date_range('2014', '2015', freq='M', tz=tz)
-            expected1 = date_range('2014-01-31', '2014-12-31', freq='M', tz=tz)
+        rng1 = date_range('2014', '2015', freq='M', tz=tz)
+        expected1 = date_range('2014-01-31', '2014-12-31', freq='M', tz=tz)
 
-            rng2 = date_range('2014', '2015', freq='MS', tz=tz)
-            expected2 = date_range('2014-01-01', '2015-01-01', freq='MS',
-                                   tz=tz)
+        rng2 = date_range('2014', '2015', freq='MS', tz=tz)
+        expected2 = date_range('2014-01-01', '2015-01-01', freq='MS', tz=tz)
 
-            rng3 = date_range('2014', '2020', freq='A', tz=tz)
-            expected3 = date_range('2014-12-31', '2019-12-31', freq='A', tz=tz)
+        rng3 = date_range('2014', '2020', freq='A', tz=tz)
+        expected3 = date_range('2014-12-31', '2019-12-31', freq='A', tz=tz)
 
-            rng4 = date_range('2014', '2020', freq='AS', tz=tz)
-            expected4 = date_range('2014-01-01', '2020-01-01', freq='AS',
-                                   tz=tz)
+        rng4 = date_range('2014', '2020', freq='AS', tz=tz)
+        expected4 = date_range('2014-01-01', '2020-01-01', freq='AS', tz=tz)
 
-            for rng, expected in [(rng1, expected1), (rng2, expected2),
-                                  (rng3, expected3), (rng4, expected4)]:
-                tm.assert_index_equal(rng, expected)
+        for rng, expected in [(rng1, expected1), (rng2, expected2),
+                              (rng3, expected3), (rng4, expected4)]:
+            tm.assert_index_equal(rng, expected)
 
-    def test_dti_constructor_small_int(self):
+    @pytest.mark.parametrize('dtype', [np.int64, np.int32, np.int16, np.int8])
+    def test_dti_constructor_small_int(self, dtype):
         # GH 13721
         exp = DatetimeIndex(['1970-01-01 00:00:00.00000000',
                              '1970-01-01 00:00:00.00000001',
                              '1970-01-01 00:00:00.00000002'])
 
-        for dtype in [np.int64, np.int32, np.int16, np.int8]:
-            arr = np.array([0, 10, 20], dtype=dtype)
-            tm.assert_index_equal(DatetimeIndex(arr), exp)
+        arr = np.array([0, 10, 20], dtype=dtype)
+        tm.assert_index_equal(DatetimeIndex(arr), exp)
 
     def test_ctor_str_intraday(self):
         rng = DatetimeIndex(['1-1-2000 00:00:01'])
@@ -499,7 +497,7 @@ def test_index_cast_datetime64_other_units(self):
         assert (idx.values == conversion.ensure_datetime64ns(arr)).all()
 
     def test_constructor_int64_nocopy(self):
-        # #1624
+        # GH#1624
         arr = np.arange(1000, dtype=np.int64)
         index = DatetimeIndex(arr)
 
@@ -512,19 +510,17 @@ def test_constructor_int64_nocopy(self):
         arr[50:100] = -1
         assert (index.asi8[50:100] != -1).all()
 
-    def test_from_freq_recreate_from_data(self):
-        freqs = ['M', 'Q', 'A', 'D', 'B', 'BH', 'T', 'S', 'L', 'U', 'H', 'N',
-                 'C']
-
-        for f in freqs:
-            org = DatetimeIndex(start='2001/02/01 09:00', freq=f, periods=1)
-            idx = DatetimeIndex(org, freq=f)
-            tm.assert_index_equal(idx, org)
-
-            org = DatetimeIndex(start='2001/02/01 09:00', freq=f,
-                                tz='US/Pacific', periods=1)
-            idx = DatetimeIndex(org, freq=f, tz='US/Pacific')
-            tm.assert_index_equal(idx, org)
+    @pytest.mark.parametrize('freq', ['M', 'Q', 'A', 'D', 'B', 'BH',
+                                      'T', 'S', 'L', 'U', 'H', 'N', 'C'])
+    def test_from_freq_recreate_from_data(self, freq):
+        org = DatetimeIndex(start='2001/02/01 09:00', freq=freq, periods=1)
+        idx = DatetimeIndex(org, freq=freq)
+        tm.assert_index_equal(idx, org)
+
+        org = DatetimeIndex(start='2001/02/01 09:00', freq=freq,
+                            tz='US/Pacific', periods=1)
+        idx = DatetimeIndex(org, freq=freq, tz='US/Pacific')
+        tm.assert_index_equal(idx, org)
 
     def test_datetimeindex_constructor_misc(self):
         arr = ['1/1/2005', '1/2/2005', 'Jn 3, 2005', '2005-01-04']

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