parametrize a whole mess of tests (#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