Refactor numeric tests

pandas/tests/indexes/test_numeric.py

@@ -27,22 +27,22 @@ def full_like(array, value):
 
 
 class Numeric(Base):
-
     def test_numeric_compat(self):
+        pass  # override Base method
 
+    def test_mul_int(self):
         idx = self.create_index()
-        didx = idx * idx
-
         result = idx * 1
         tm.assert_index_equal(result, idx)
 
+    def test_rmul_int(self):
+        idx = self.create_index()
+
         result = 1 * idx
         tm.assert_index_equal(result, idx)
 
-        # in general not true for RangeIndex
-        if not isinstance(idx, RangeIndex):
-            result = idx * idx
-            tm.assert_index_equal(result, idx ** 2)
+    def test_div_int(self):
+        idx = self.create_index()
 
         # truediv under PY3
         result = idx / 1
@@ -57,29 +57,62 @@ def test_numeric_compat(self):
         expected = Index(idx.values / 2)
         tm.assert_index_equal(result, expected)
 
+    def test_floordiv_int(self):
+        idx = self.create_index()
+
         result = idx // 1
         tm.assert_index_equal(result, idx)
 
+    def test_mul_int_array(self):
+        idx = self.create_index()
+        didx = idx * idx
+
         result = idx * np.array(5, dtype='int64')
         tm.assert_index_equal(result, idx * 5)
 
         arr_dtype = 'uint64' if isinstance(idx, UInt64Index) else 'int64'
         result = idx * np.arange(5, dtype=arr_dtype)
         tm.assert_index_equal(result, didx)
 
+    def test_mul_int_series(self):
+        idx = self.create_index()
+        didx = idx * idx
+
+        arr_dtype = 'uint64' if isinstance(idx, UInt64Index) else 'int64'
         result = idx * Series(np.arange(5, dtype=arr_dtype))
         tm.assert_index_equal(result, didx)
 
-        result = idx * Series(np.arange(5, dtype='float64') + 0.1)
-        expected = Float64Index(np.arange(5, dtype='float64') *
-                                (np.arange(5, dtype='float64') + 0.1))
+    def test_mul_float_series(self):
+        idx = self.create_index()
+        rng5 = np.arange(5, dtype='float64')
+
+        result = idx * Series(rng5 + 0.1)
+        expected = Float64Index(rng5 * (rng5 + 0.1))
         tm.assert_index_equal(result, expected)
 
-        # invalid
-        pytest.raises(TypeError,
-                      lambda: idx * date_range('20130101', periods=5))
-        pytest.raises(ValueError, lambda: idx * idx[0:3])
-        pytest.raises(ValueError, lambda: idx * np.array([1, 2]))
+    def test_mul_index(self):
+        idx = self.create_index()
+
+        # in general not true for RangeIndex
+        if not isinstance(idx, RangeIndex):
+            result = idx * idx
+            tm.assert_index_equal(result, idx ** 2)
+
+    def test_mul_datelike_raises(self):
+        idx = self.create_index()
+        with pytest.raises(TypeError):
+            idx * date_range('20130101', periods=5)
+
+    def test_mul_size_mismatch_raises(self):
+        idx = self.create_index()
+
+        with pytest.raises(ValueError):
+            idx * idx[0:3]
+        with pytest.raises(ValueError):
+            idx * np.array([1, 2])
+
+    def test_divmod(self):
+        idx = self.create_index()
 
         result = divmod(idx, 2)
         with np.errstate(all='ignore'):
@@ -97,23 +130,27 @@ def test_numeric_compat(self):
 
         result = divmod(idx, Series(full_like(idx.values, 2)))
         with np.errstate(all='ignore'):
-            div, mod = divmod(
-                idx.values,
-                full_like(idx.values, 2),
-            )
+            div, mod = divmod(idx.values, full_like(idx.values, 2))
             expected = Index(div), Index(mod)
         for r, e in zip(result, expected):
             tm.assert_index_equal(r, e)
 
+    def test_pow_float(self):
         # test power calculations both ways, GH 14973
-        expected = pd.Float64Index(2.0**idx.values)
-        result = 2.0**idx
-        tm.assert_index_equal(result, expected)
+        idx = self.create_index()
 
         expected = pd.Float64Index(idx.values**2.0)
         result = idx**2.0
         tm.assert_index_equal(result, expected)
 
+    def test_rpow_float(self):
+        # test power calculations both ways, GH 14973
+        idx = self.create_index()
+
+        expected = pd.Float64Index(2.0**idx.values)
+        result = 2.0**idx
+        tm.assert_index_equal(result, expected)
+
     def test_explicit_conversions(self):
 
         # GH 8608

pandas/tests/indexes/timedeltas/test_arithmetic.py

@@ -128,40 +128,66 @@ def test_tdi_with_offset_series(self, names):
             with tm.assert_produces_warning(PerformanceWarning):
                 anchored - tdi
 
-    # TODO: Split by ops, better name
-    def test_numeric_compat(self):
+    def test_mul_int(self):
         idx = self._holder(np.arange(5, dtype='int64'))
-        didx = self._holder(np.arange(5, dtype='int64') ** 2)
         result = idx * 1
         tm.assert_index_equal(result, idx)
 
+    def test_rmul_int(self):
+        idx = self._holder(np.arange(5, dtype='int64'))
         result = 1 * idx
         tm.assert_index_equal(result, idx)
 
+    def test_div_int(self):
+        idx = self._holder(np.arange(5, dtype='int64'))
         result = idx / 1
         tm.assert_index_equal(result, idx)
 
+    def test_floordiv_int(self):
+        idx = self._holder(np.arange(5, dtype='int64'))
         result = idx // 1
         tm.assert_index_equal(result, idx)
 
+    def test_mul_int_array_zerodim(self):
+        rng5 = np.arange(5, dtype='int64')
+        idx = self._holder(rng5)
+        expected = self._holder(rng5 * 5)
         result = idx * np.array(5, dtype='int64')
-        tm.assert_index_equal(result,
-                              self._holder(np.arange(5, dtype='int64') * 5))
+        tm.assert_index_equal(result, expected)
+
+    def test_mul_int_array(self):
+        rng5 = np.arange(5, dtype='int64')
+        idx = self._holder(rng5)
+        didx = self._holder(rng5 ** 2)
 
-        result = idx * np.arange(5, dtype='int64')
+        result = idx * rng5
         tm.assert_index_equal(result, didx)
 
+    def test_mul_int_series(self):
+        idx = self._holder(np.arange(5, dtype='int64'))
+        didx = self._holder(np.arange(5, dtype='int64') ** 2)
+
         result = idx * Series(np.arange(5, dtype='int64'))
         tm.assert_index_equal(result, didx)
 
-        result = idx * Series(np.arange(5, dtype='float64') + 0.1)
-        tm.assert_index_equal(result, self._holder(np.arange(
-            5, dtype='float64') * (np.arange(5, dtype='float64') + 0.1)))
+    def test_mul_float_series(self):
+        idx = self._holder(np.arange(5, dtype='int64'))
+
+        rng5f = np.arange(5, dtype='float64')
+        result = idx * Series(rng5f + 0.1)
+        tm.assert_index_equal(result, self._holder(rng5f * (rng5f + 0.1)))
 
-        # invalid
-        pytest.raises(TypeError, lambda: idx * idx)
-        pytest.raises(ValueError, lambda: idx * self._holder(np.arange(3)))
-        pytest.raises(ValueError, lambda: idx * np.array([1, 2]))
+    def test_dti_mul_dti_raises(self):
+        idx = self._holder(np.arange(5, dtype='int64'))
+        with pytest.raises(TypeError):
+            idx * idx
+
+    def test_dti_mul_too_short_raises(self):
+        idx = self._holder(np.arange(5, dtype='int64'))
+        with pytest.raises(ValueError):
+            idx * self._holder(np.arange(3))
+        with pytest.raises(ValueError):
+            idx * np.array([1, 2])
 
     def test_ufunc_coercions(self):
         # normal ops are also tested in tseries/test_timedeltas.py