Repository: cupy/cupy

Issue:
Drop support of older NumPy (<=1.14)?
According to [NEP 29](https://numpy.org/neps/nep-0029-deprecation_policy.html), an unusual NumPy Enhancement Proposal that declares a community-wide policy instead of merely proposing changes to NumPy itself, the support of NumPy <=1.14 will be dropped in early January, 2020, which is a few days later:
> Drop Schedule
> ...
> On Jan 07, 2020 drop support for Numpy 1.14 (initially released on Jan 06, 2018)

Would CuPy consider following NEP 29 so that some test codes can be simplified without worrying too much about backward compatibilities? I've seen this caused hard time for a few PRs.


Discussion:
Sounds good to follow it!

Resolving patch:
diff --git a/setup.py b/setup.py
--- a/setup.py
+++ b/setup.py
@@ -24,7 +24,7 @@
         'fastrlock>=0.3',
     ],
     'install': [
-        'numpy>=1.9.0',
+        'numpy>=1.15',
         'fastrlock>=0.3',
     ],
     'stylecheck': [


Test patch:
diff --git a/cupy/testing/helper.py b/cupy/testing/helper.py
--- a/cupy/testing/helper.py
+++ b/cupy/testing/helper.py
@@ -1040,12 +1040,12 @@ def with_requires(*requirements):
 
     .. admonition:: Example
 
-       This test case runs only when `numpy>=1.10` is installed.
+       This test case runs only when `numpy>=1.18` is installed.
 
        >>> from cupy import testing
        ... class Test(unittest.TestCase):
-       ...     @testing.with_requires('numpy>=1.10')
-       ...     def test_for_numpy_1_10(self):
+       ...     @testing.with_requires('numpy>=1.18')
+       ...     def test_for_numpy_1_18(self):
        ...         pass
 
     Args:
diff --git a/tests/cupy_tests/binary_tests/test_packing.py b/tests/cupy_tests/binary_tests/test_packing.py
--- a/tests/cupy_tests/binary_tests/test_packing.py
+++ b/tests/cupy_tests/binary_tests/test_packing.py
@@ -7,7 +7,6 @@
 @testing.gpu
 class TestPacking(unittest.TestCase):
 
-    @testing.with_requires('numpy>=1.10')
     @testing.for_int_dtypes()
     @testing.numpy_cupy_array_equal()
     def check_packbits(self, data, xp, dtype):
@@ -29,7 +28,6 @@ def test_packbits(self):
         self.check_packbits([1, 0, 1, 1, 0, 1, 1, 1, 1])
         self.check_packbits(numpy.arange(24).reshape((2, 3, 4)) % 2)
 
-    @testing.with_requires('numpy>=1.12')
     def test_packbits_empty(self):
         # Note packbits of numpy <= 1.11 has a bug against empty arrays.
         # See https://github.com/numpy/numpy/issues/8324
diff --git a/tests/cupy_tests/core_tests/fusion_tests/test_array.py b/tests/cupy_tests/core_tests/fusion_tests/test_array.py
--- a/tests/cupy_tests/core_tests/fusion_tests/test_array.py
+++ b/tests/cupy_tests/core_tests/fusion_tests/test_array.py
@@ -166,7 +166,6 @@ def func(x, y):
 
         return func
 
-    @testing.with_requires('numpy>=1.10')
     @testing.for_int_dtypes(no_bool=True)
     @fusion_utils.check_fusion(accept_error=(TypeError,))
     def test_int_itruediv_py3_raises(self, xp, dtype):
diff --git a/tests/cupy_tests/core_tests/fusion_tests/test_function.py b/tests/cupy_tests/core_tests/fusion_tests/test_function.py
--- a/tests/cupy_tests/core_tests/fusion_tests/test_function.py
+++ b/tests/cupy_tests/core_tests/fusion_tests/test_function.py
@@ -34,7 +34,6 @@ def generate_inputs(self, xp, dtype1, dtype2):
     @testing.for_all_dtypes_combination(
         names=('dtype1', 'dtype2'), full=True, no_complex=True)
     @fusion_utils.check_fusion(accept_error=TypeError)
-    @testing.with_requires('numpy>=1.13')
     def test_outarg_add(self, xp, dtype1, dtype2):
         def func(x, y, z):
             xp.add(x, y, out=z)
diff --git a/tests/cupy_tests/core_tests/fusion_tests/test_ufunc.py b/tests/cupy_tests/core_tests/fusion_tests/test_ufunc.py
--- a/tests/cupy_tests/core_tests/fusion_tests/test_ufunc.py
+++ b/tests/cupy_tests/core_tests/fusion_tests/test_ufunc.py
@@ -311,7 +311,6 @@ def generate_inputs(self, xp, dtype1, dtype2):
         y[y == 0] = 1
         return (x, y), {}
 
-    @testing.with_requires('numpy>=1.13')
     @testing.for_all_dtypes_combination(
         names=('dtype1', 'dtype2'), no_complex=True)
     @fusion_utils.check_fusion()
@@ -322,13 +321,11 @@ def test_divmod(self, xp, dtype1, dtype2):
 @testing.gpu
 class TestFusionMisc(FusionUnaryUfuncTestBase):
 
-    @testing.with_requires('numpy>=1.11.2')
     @testing.for_all_dtypes(no_complex=True)
     @fusion_utils.check_fusion()
     def test_sqrt(self, xp, dtype):
         return lambda x: xp.sqrt(x)
 
-    @testing.with_requires('numpy>=1.10')
     @testing.for_all_dtypes(no_complex=True)
     @fusion_utils.check_fusion()
     def test_cbrt(self, xp, dtype):
diff --git a/tests/cupy_tests/core_tests/test_elementwise.py b/tests/cupy_tests/core_tests/test_elementwise.py
--- a/tests/cupy_tests/core_tests/test_elementwise.py
+++ b/tests/cupy_tests/core_tests/test_elementwise.py
@@ -1,4 +1,3 @@
-import sys
 import unittest
 
 import numpy
@@ -82,11 +81,6 @@ def test_invalid_kernel_name(self):
 @testing.gpu
 class TestElementwiseType(unittest.TestCase):
 
-    # Skip this test due to NumPy bug on Windows (fixed in NumPy 1.14.0).
-    # https://github.com/numpy/numpy/pull/9778
-    @unittest.skipIf(
-        sys.platform == 'win32' and testing.numpy_satisfies('<1.14'),
-        'This test requires 1.14.0 when running on Windows.')
     @testing.for_int_dtypes(no_bool=True)
     @testing.numpy_cupy_array_equal()
     def test_large_int_upper_1(self, xp, dtype):
diff --git a/tests/cupy_tests/core_tests/test_internal.py b/tests/cupy_tests/core_tests/test_internal.py
--- a/tests/cupy_tests/core_tests/test_internal.py
+++ b/tests/cupy_tests/core_tests/test_internal.py
@@ -196,7 +196,6 @@ def test_complete_slice(self):
             slice(*self.expect))
 
 
-@testing.with_requires('numpy>=1.12')
 class TestCompleteSliceError(unittest.TestCase):
 
     def test_invalid_step_value(self):
diff --git a/tests/cupy_tests/core_tests/test_ndarray.py b/tests/cupy_tests/core_tests/test_ndarray.py
--- a/tests/cupy_tests/core_tests/test_ndarray.py
+++ b/tests/cupy_tests/core_tests/test_ndarray.py
@@ -337,7 +337,6 @@ def test_take(self, xp, dtype):
 @testing.gpu
 class TestNdarrayTakeErrorAxisOverRun(unittest.TestCase):
 
-    @testing.with_requires('numpy>=1.13')
     @testing.numpy_cupy_raises()
     def test_axis_overrun1(self, xp):
         a = testing.shaped_arange(self.shape, xp)
diff --git a/tests/cupy_tests/core_tests/test_ndarray_adv_indexing.py b/tests/cupy_tests/core_tests/test_ndarray_adv_indexing.py
--- a/tests/cupy_tests/core_tests/test_ndarray_adv_indexing.py
+++ b/tests/cupy_tests/core_tests/test_ndarray_adv_indexing.py
@@ -128,7 +128,6 @@ def test_adv_getitem(self, xp, dtype):
     {'shape': (0,), 'indexes': numpy.zeros((), dtype=numpy.bool_)},
 )
 @testing.gpu
-@testing.with_requires('numpy>=1.13')
 class TestArrayAdvancedIndexingGetitemParametrized2(unittest.TestCase):
 
     @testing.for_all_dtypes()
@@ -300,7 +299,6 @@ def test_invalid_adv_getitem(self, xp):
      'indexes': numpy.random.choice([False, True], (1, 3))},
 )
 @testing.gpu
-@testing.with_requires('numpy>=1.13')
 class TestArrayInvalidIndexAdvGetitem2(unittest.TestCase):
 
     @testing.numpy_cupy_raises(accept_error=IndexError)
@@ -473,7 +471,6 @@ def test_adv_setitem(self, xp, dtype):
     {'shape': (0,), 'indexes': numpy.zeros((), dtype=numpy.bool_), 'value': 1},
 )
 @testing.gpu
-@testing.with_requires('numpy>=1.13')
 class TestArrayAdvancedIndexingSetitemScalarValue2(unittest.TestCase):
 
     @testing.for_all_dtypes()
diff --git a/tests/cupy_tests/core_tests/test_ndarray_complex_ops.py b/tests/cupy_tests/core_tests/test_ndarray_complex_ops.py
--- a/tests/cupy_tests/core_tests/test_ndarray_complex_ops.py
+++ b/tests/cupy_tests/core_tests/test_ndarray_complex_ops.py
@@ -159,7 +159,6 @@ def test_imag_inplace(self, dtype):
 class TestScalarConversion(unittest.TestCase):
 
     @testing.for_all_dtypes()
-    @testing.with_requires('numpy>=1.12.0')
     def test_scalar_conversion(self, dtype):
         scalar = 1 + 1j if numpy.dtype(dtype).kind == 'c' else 1
         x_1d = cupy.array([scalar]).astype(dtype)
diff --git a/tests/cupy_tests/core_tests/test_ndarray_elementwise_op.py b/tests/cupy_tests/core_tests/test_ndarray_elementwise_op.py
--- a/tests/cupy_tests/core_tests/test_ndarray_elementwise_op.py
+++ b/tests/cupy_tests/core_tests/test_ndarray_elementwise_op.py
@@ -32,7 +32,6 @@ def test_add_scalar(self):
     def test_radd_scalar(self):
         self.check_array_scalar_op(operator.add, swap=True)
 
-    @testing.with_requires('numpy>=1.10')
     def test_iadd_scalar(self):
         self.check_array_scalar_op(operator.iadd)
 
@@ -42,7 +41,6 @@ def test_sub_scalar(self):
     def test_rsub_scalar(self):
         self.check_array_scalar_op(operator.sub, swap=True, no_bool=True)
 
-    @testing.with_requires('numpy>=1.10')
     def test_isub_scalar(self):
         self.check_array_scalar_op(operator.isub, no_bool=True)
 
@@ -52,7 +50,6 @@ def test_mul_scalar(self):
     def test_rmul_scalar(self):
         self.check_array_scalar_op(operator.mul, swap=True)
 
-    @testing.with_requires('numpy>=1.10')
     def test_imul_scalar(self):
         self.check_array_scalar_op(operator.imul)
 
@@ -64,7 +61,6 @@ def test_rtruediv_scalar(self):
         with testing.NumpyError(divide='ignore'):
             self.check_array_scalar_op(operator.truediv, swap=True)
 
-    @testing.with_requires('numpy>=1.10')
     def test_itruediv_scalar(self):
         with testing.NumpyError(divide='ignore'):
             self.check_array_scalar_op(operator.itruediv)
@@ -78,7 +74,6 @@ def test_rfloordiv_scalar(self):
             self.check_array_scalar_op(operator.floordiv, swap=True,
                                        no_complex=True)
 
-    @testing.with_requires('numpy>=1.10')
     def test_ifloordiv_scalar(self):
         with testing.NumpyError(divide='ignore'):
             self.check_array_scalar_op(operator.ifloordiv, no_complex=True)
@@ -95,7 +90,6 @@ def check_ipow_scalar(self, xp, x_type, y_type):
         a = xp.array([[1, 2, 3], [4, 5, 6]], x_type)
         return operator.ipow(a, y_type(3))
 
-    @testing.with_requires('numpy>=1.10')
     def test_ipow_scalar(self):
         self.check_ipow_scalar()
 
@@ -154,21 +148,18 @@ def check_array_array_op(self, op, xp, x_type, y_type,
     def test_add_array(self):
         self.check_array_array_op(operator.add)
 
-    @testing.with_requires('numpy>=1.10')
     def test_iadd_array(self):
         self.check_array_array_op(operator.iadd)
 
     def test_sub_array(self):
         self.check_array_array_op(operator.sub, no_bool=True)
 
-    @testing.with_requires('numpy>=1.10')
     def test_isub_array(self):
         self.check_array_array_op(operator.isub, no_bool=True)
 
     def test_mul_array(self):
         self.check_array_array_op(operator.mul)
 
-    @testing.with_requires('numpy>=1.10')
     def test_imul_array(self):
         self.check_array_array_op(operator.imul)
 
@@ -176,7 +167,6 @@ def test_truediv_array(self):
         with testing.NumpyError(divide='ignore'):
             self.check_array_array_op(operator.truediv)
 
-    @testing.with_requires('numpy>=1.10')
     def test_itruediv_array(self):
         with testing.NumpyError(divide='ignore'):
             self.check_array_array_op(operator.itruediv)
@@ -185,7 +175,6 @@ def test_floordiv_array(self):
         with testing.NumpyError(divide='ignore'):
             self.check_array_array_op(operator.floordiv, no_complex=True)
 
-    @testing.with_requires('numpy>=1.10')
     def test_ifloordiv_array(self):
         if '1.16.1' <= numpy.lib.NumpyVersion(numpy.__version__) < '1.18.0':
             self.skipTest("NumPy Issue #12927")
@@ -202,7 +191,6 @@ def check_ipow_array(self, xp, x_type, y_type):
         b = xp.array([[6, 5, 4], [3, 2, 1]], y_type)
         return operator.ipow(a, b)
 
-    @testing.with_requires('numpy>=1.10')
     def test_ipow_array(self):
         self.check_ipow_array()
 
@@ -249,7 +237,6 @@ def check_array_broadcasted_op(self, op, xp, x_type, y_type,
     def test_broadcasted_add(self):
         self.check_array_broadcasted_op(operator.add)
 
-    @testing.with_requires('numpy>=1.10')
     def test_broadcasted_iadd(self):
         self.check_array_broadcasted_op(operator.iadd)
 
@@ -257,7 +244,6 @@ def test_broadcasted_sub(self):
         # TODO(unno): sub for boolean array is deprecated in numpy>=1.13
         self.check_array_broadcasted_op(operator.sub, no_bool=True)
 
-    @testing.with_requires('numpy>=1.10')
     def test_broadcasted_isub(self):
         # TODO(unno): sub for boolean array is deprecated in numpy>=1.13
         self.check_array_broadcasted_op(operator.isub, no_bool=True)
@@ -265,7 +251,6 @@ def test_broadcasted_isub(self):
     def test_broadcasted_mul(self):
         self.check_array_broadcasted_op(operator.mul)
 
-    @testing.with_requires('numpy>=1.10')
     def test_broadcasted_imul(self):
         self.check_array_broadcasted_op(operator.imul)
 
@@ -273,7 +258,6 @@ def test_broadcasted_truediv(self):
         with testing.NumpyError(divide='ignore'):
             self.check_array_broadcasted_op(operator.truediv)
 
-    @testing.with_requires('numpy>=1.10')
     def test_broadcasted_itruediv(self):
         with testing.NumpyError(divide='ignore'):
             self.check_array_broadcasted_op(operator.itruediv)
@@ -282,7 +266,6 @@ def test_broadcasted_floordiv(self):
         with testing.NumpyError(divide='ignore'):
             self.check_array_broadcasted_op(operator.floordiv, no_complex=True)
 
-    @testing.with_requires('numpy>=1.10')
     def test_broadcasted_ifloordiv(self):
         if '1.16.1' <= numpy.lib.NumpyVersion(numpy.__version__) < '1.18.0':
             self.skipTest("NumPy Issue #12927")
@@ -293,7 +276,6 @@ def test_broadcasted_ifloordiv(self):
     def test_broadcasted_pow(self):
         self.check_array_broadcasted_op(operator.pow)
 
-    @testing.with_requires('numpy>=1.10')
     @testing.for_all_dtypes_combination(names=['x_type', 'y_type'])
     @testing.numpy_cupy_allclose(atol=1.0, accept_error=TypeError)
     def check_broadcasted_ipow(self, xp, x_type, y_type):
@@ -301,7 +283,6 @@ def check_broadcasted_ipow(self, xp, x_type, y_type):
         b = xp.array([[1], [2]], y_type)
         return operator.ipow(a, b)
 
-    @testing.with_requires('numpy>=1.10')
     def test_broadcasted_ipow(self):
         self.check_broadcasted_ipow()
 
@@ -568,35 +549,30 @@ def check_array_array_op(self, op, xp, x_type, y_type):
     def test_lshift_array(self):
         self.check_array_array_op(operator.lshift)
 
-    @testing.with_requires('numpy>=1.10')
     def test_ilshift_array(self):
         self.check_array_array_op(operator.ilshift)
 
     def test_rshift_array(self):
         self.check_array_array_op(operator.rshift)
 
-    @testing.with_requires('numpy>=1.10')
     def test_irshift_array(self):
         self.check_array_array_op(operator.irshift)
 
     def test_and_array(self):
         self.check_array_array_op(operator.and_)
 
-    @testing.with_requires('numpy>=1.10')
     def test_iand_array(self):
         self.check_array_array_op(operator.iand)
 
     def test_or_array(self):
         self.check_array_array_op(operator.or_)
 
-    @testing.with_requires('numpy>=1.10')
     def test_ior_array(self):
         self.check_array_array_op(operator.ior)
 
     def test_xor_array(self):
         self.check_array_array_op(operator.xor)
 
-    @testing.with_requires('numpy>=1.10')
     def test_ixor_array(self):
         self.check_array_array_op(operator.ixor)
 
@@ -604,7 +580,6 @@ def test_mod_array(self):
         with testing.NumpyError(divide='ignore', invalid='ignore'):
             self.check_array_array_op(operator.mod)
 
-    @testing.with_requires('numpy>=1.10')
     def test_imod_array(self):
         with testing.NumpyError(divide='ignore', invalid='ignore'):
             self.check_array_array_op(operator.imod)
@@ -619,35 +594,30 @@ def check_array_broadcasted_op(self, op, xp, x_type, y_type):
     def test_broadcasted_lshift(self):
         self.check_array_broadcasted_op(operator.lshift)
 
-    @testing.with_requires('numpy>=1.10')
     def test_broadcasted_ilshift(self):
         self.check_array_broadcasted_op(operator.ilshift)
 
     def test_broadcasted_rshift(self):
         self.check_array_broadcasted_op(operator.rshift)
 
-    @testing.with_requires('numpy>=1.10')
     def test_broadcasted_irshift(self):
         self.check_array_broadcasted_op(operator.irshift)
 
     def test_broadcasted_and(self):
         self.check_array_broadcasted_op(operator.and_)
 
-    @testing.with_requires('numpy>=1.10')
     def test_broadcasted_iand(self):
         self.check_array_broadcasted_op(operator.iand)
 
     def test_broadcasted_or(self):
         self.check_array_broadcasted_op(operator.or_)
 
-    @testing.with_requires('numpy>=1.10')
     def test_broadcasted_ior(self):
         self.check_array_broadcasted_op(operator.ior)
 
     def test_broadcasted_xor(self):
         self.check_array_broadcasted_op(operator.xor)
 
-    @testing.with_requires('numpy>=1.10')
     def test_broadcasted_ixor(self):
         self.check_array_broadcasted_op(operator.ixor)
 
@@ -655,7 +625,6 @@ def test_broadcasted_mod(self):
         with testing.NumpyError(divide='ignore', invalid='ignore'):
             self.check_array_broadcasted_op(operator.mod)
 
-    @testing.with_requires('numpy>=1.10')
     def test_broadcasted_imod(self):
         with testing.NumpyError(divide='ignore', invalid='ignore'):
             self.check_array_broadcasted_op(operator.imod)
diff --git a/tests/cupy_tests/core_tests/test_ndarray_indexing.py b/tests/cupy_tests/core_tests/test_ndarray_indexing.py
--- a/tests/cupy_tests/core_tests/test_ndarray_indexing.py
+++ b/tests/cupy_tests/core_tests/test_ndarray_indexing.py
@@ -102,7 +102,6 @@ def test_getitem(self, xp, dtype):
     {'shape': (2, 3, 4), 'transpose': None,
      'indexes': (slice(None, None, (0, 0)), )},
 )
-@testing.with_requires('numpy>=1.12.0')
 @testing.gpu
 class TestArrayInvalidIndex(unittest.TestCase):
 
diff --git a/tests/cupy_tests/core_tests/test_ndarray_ufunc.py b/tests/cupy_tests/core_tests/test_ndarray_ufunc.py
--- a/tests/cupy_tests/core_tests/test_ndarray_ufunc.py
+++ b/tests/cupy_tests/core_tests/test_ndarray_ufunc.py
@@ -9,7 +9,6 @@
 @testing.gpu
 class TestArrayUfunc(unittest.TestCase):
 
-    @testing.with_requires('numpy>=1.13')
     @testing.for_all_dtypes()
     def test_unary_op(self, dtype):
         a = cupy.array(np.array([0, 1, 2]), dtype=dtype)
@@ -20,7 +19,6 @@ def test_unary_op(self, dtype):
         outb = np.sin(b)
         self.assertTrue(np.allclose(outa.get(), outb))
 
-    @testing.with_requires('numpy>=1.13')
     @testing.for_all_dtypes()
     def test_unary_op_out(self, dtype):
         a = cupy.array(np.array([0, 1, 2]), dtype=dtype)
@@ -31,7 +29,6 @@ def test_unary_op_out(self, dtype):
         np.sin(a, out=outa)
         self.assertTrue(np.allclose(outa.get(), outb))
 
-    @testing.with_requires('numpy>=1.13')
     @testing.for_all_dtypes()
     def test_binary_op(self, dtype):
         a1 = cupy.array(np.array([0, 1, 2]), dtype=dtype)
@@ -44,7 +41,6 @@ def test_binary_op(self, dtype):
         outb = np.add(b1, b2)
         self.assertTrue(np.allclose(outa.get(), outb))
 
-    @testing.with_requires('numpy>=1.13')
     @testing.for_all_dtypes()
     def test_binary_op_out(self, dtype):
         a1 = cupy.array(np.array([0, 1, 2]), dtype=dtype)
@@ -56,7 +52,6 @@ def test_binary_op_out(self, dtype):
         outb = np.add(b1, b2)
         self.assertTrue(np.allclose(outa.get(), outb))
 
-    @testing.with_requires('numpy>=1.13')
     @testing.for_all_dtypes()
     def test_binary_mixed_op(self, dtype):
         a1 = cupy.array(np.array([0, 1, 2]), dtype=dtype)
@@ -88,7 +83,6 @@ def test_indexing(self, xp):
         b = cupy.testing.shaped_arange((3, 2), xp)[:, None, :]
         return a * b
 
-    @testing.with_requires('numpy>=1.13')
     @testing.numpy_cupy_array_equal()
     def test_shares_memory(self, xp):
         a = cupy.testing.shaped_arange((1000, 1000), xp, 'int64')
diff --git a/tests/cupy_tests/core_tests/test_ndarray_unary_op.py b/tests/cupy_tests/core_tests/test_ndarray_unary_op.py
--- a/tests/cupy_tests/core_tests/test_ndarray_unary_op.py
+++ b/tests/cupy_tests/core_tests/test_ndarray_unary_op.py
@@ -94,7 +94,6 @@ def test_pos_zerodim(self):
     def test_abs_zerodim(self):
         self.check_zerodim_op_full(operator.abs)
 
-    @testing.with_requires('numpy<1.16')
     def test_abs_zerodim_full(self):
         self.check_zerodim_op_full(operator.abs)
 
diff --git a/tests/cupy_tests/creation_tests/test_basic.py b/tests/cupy_tests/creation_tests/test_basic.py
--- a/tests/cupy_tests/creation_tests/test_basic.py
+++ b/tests/cupy_tests/creation_tests/test_basic.py
@@ -231,13 +231,11 @@ def test_full(self, xp, dtype):
 
     @testing.for_all_dtypes()
     @testing.numpy_cupy_array_equal()
-    @testing.with_requires('numpy>=1.12.0')
     def test_full_default_dtype(self, xp, dtype):
         return xp.full((2, 3, 4), xp.array(1, dtype=dtype))
 
     @testing.for_all_dtypes()
     @testing.numpy_cupy_array_equal()
-    @testing.with_requires('numpy>=1.12.0')
     def test_full_default_dtype_cpu_input(self, xp, dtype):
         return xp.full((2, 3, 4), numpy.array(1, dtype=dtype))
 
diff --git a/tests/cupy_tests/creation_tests/test_from_data.py b/tests/cupy_tests/creation_tests/test_from_data.py
--- a/tests/cupy_tests/creation_tests/test_from_data.py
+++ b/tests/cupy_tests/creation_tests/test_from_data.py
@@ -46,7 +46,6 @@ def test_array_from_numpy_scalar(self, xp, dtype, order):
 
     @testing.for_orders('CFAK')
     @testing.for_all_dtypes()
-    @testing.with_requires('numpy>=1.10')
     @testing.numpy_cupy_array_equal()
     def test_array_from_numpy_broad_cast(self, xp, dtype, order):
         a = testing.shaped_arange((2, 1, 4), numpy, dtype)
diff --git a/tests/cupy_tests/creation_tests/test_ranges.py b/tests/cupy_tests/creation_tests/test_ranges.py
--- a/tests/cupy_tests/creation_tests/test_ranges.py
+++ b/tests/cupy_tests/creation_tests/test_ranges.py
@@ -80,7 +80,6 @@ def test_linspace2(self, xp, dtype):
     def test_linspace_zero_num(self, xp, dtype):
         return xp.linspace(0, 10, 0, dtype=dtype)
 
-    @testing.with_requires('numpy>=1.10')
     @testing.for_all_dtypes(no_bool=True)
     @testing.numpy_cupy_array_equal()
     def test_linspace_zero_num_no_endopoint_with_retstep(self, xp, dtype):
@@ -128,7 +127,6 @@ def test_linspace_no_dtype_float(self, xp):
     def test_linspace_float_args_with_int_dtype(self, xp):
         return xp.linspace(0.1, 9.1, 11, dtype=int)
 
-    @testing.with_requires('numpy>=1.10')
     @testing.numpy_cupy_raises()
     def test_linspace_neg_num(self, xp):
         return xp.linspace(0, 10, -1)
@@ -137,7 +135,6 @@ def test_linspace_neg_num(self, xp):
     def test_linspace_float_overflow(self, xp):
         return xp.linspace(0., sys.float_info.max / 5, 10, dtype=float)
 
-    @testing.with_requires('numpy>=1.10')
     @testing.numpy_cupy_array_equal()
     def test_linspace_float_underflow(self, xp):
         # find minimum subnormal number
@@ -183,7 +180,6 @@ def test_logspace_no_dtype_float(self, xp):
     def test_logspace_float_args_with_int_dtype(self, xp):
         return xp.logspace(0.1, 2.1, 11, dtype=int)
 
-    @testing.with_requires('numpy>=1.10')
     @testing.numpy_cupy_raises()
     def test_logspace_neg_num(self, xp):
         return xp.logspace(0, 10, -1)
diff --git a/tests/cupy_tests/fft_tests/test_fft.py b/tests/cupy_tests/fft_tests/test_fft.py
--- a/tests/cupy_tests/fft_tests/test_fft.py
+++ b/tests/cupy_tests/fft_tests/test_fft.py
@@ -63,7 +63,6 @@ def _size_last_transform_axis(shape, s, axes):
     'norm': [None, 'ortho', ''],
 }))
 @testing.gpu
-@testing.with_requires('numpy>=1.10.0')
 class TestFft(unittest.TestCase):
 
     @testing.for_all_dtypes()
@@ -101,7 +100,6 @@ def test_ifft(self, xp, dtype):
     'axis': [0, 1, -1],
 }))
 @testing.gpu
-@testing.with_requires('numpy>=1.10.0')
 class TestFftOrder(unittest.TestCase):
 
     @testing.for_all_dtypes()
@@ -201,7 +199,6 @@ def test_fft_allocate(self):
     {'shape': (2, 3, 4, 5), 's': None, 'axes': None, 'norm': None},
 )
 @testing.gpu
-@testing.with_requires('numpy>=1.10.0')
 class TestFft2(unittest.TestCase):
 
     @nd_planning_states()
@@ -256,7 +253,6 @@ def test_ifft2(self, xp, dtype, enable_nd):
     {'shape': (2, 3, 4, 5), 's': None, 'axes': None, 'norm': None},
 )
 @testing.gpu
-@testing.with_requires('numpy>=1.10.0')
 class TestFftn(unittest.TestCase):
 
     @nd_planning_states()
@@ -313,7 +309,6 @@ def test_ifftn(self, xp, dtype, enable_nd):
     {'shape': (2, 3, 4), 's': (2, 3), 'axes': (0, 1, 2), 'norm': 'ortho'},
 )
 @testing.gpu
-@testing.with_requires('numpy>=1.10.0')
 class TestPlanCtxManagerFftn(unittest.TestCase):
 
     @nd_planning_states()
@@ -394,7 +389,6 @@ def test_fftn_error_on_wrong_plan(self, dtype, enable_nd):
     'norm': [None, 'ortho'],
 }))
 @testing.gpu
-@testing.with_requires('numpy>=1.10.0')
 class TestPlanCtxManagerFft(unittest.TestCase):
 
     @testing.for_complex_dtypes()
@@ -518,7 +512,6 @@ def test_ifftn_orders(self, dtype, enable_nd):
     'norm': [None, 'ortho'],
 }))
 @testing.gpu
-@testing.with_requires('numpy>=1.10.0')
 class TestRfft(unittest.TestCase):
 
     @testing.for_all_dtypes(no_complex=True)
@@ -568,7 +561,6 @@ def test_irfft(self, xp, dtype):
     {'shape': (2, 3, 4, 5), 's': None, 'axes': None, 'norm': None},
 )
 @testing.gpu
-@testing.with_requires('numpy>=1.10.0')
 class TestRfft2(unittest.TestCase):
 
     @testing.for_all_dtypes(no_complex=True)
@@ -618,7 +610,6 @@ def test_irfft2(self, xp, dtype):
     {'shape': (2, 3, 4, 5), 's': None, 'axes': None, 'norm': None},
 )
 @testing.gpu
-@testing.with_requires('numpy>=1.10.0')
 class TestRfftn(unittest.TestCase):
 
     @testing.for_all_dtypes(no_complex=True)
@@ -658,7 +649,6 @@ def test_irfftn(self, xp, dtype):
     'norm': [None, 'ortho'],
 }))
 @testing.gpu
-@testing.with_requires('numpy>=1.10.0')
 class TestHfft(unittest.TestCase):
 
     @testing.for_all_dtypes()
@@ -690,7 +680,6 @@ def test_ihfft(self, xp, dtype):
     {'n': 100, 'd': 2},
 )
 @testing.gpu
-@testing.with_requires('numpy>=1.10.0')
 class TestFftfreq(unittest.TestCase):
 
     @testing.for_all_dtypes()
@@ -718,7 +707,6 @@ def test_rfftfreq(self, xp, dtype):
     {'shape': (10, 10), 'axes': (0, 1)},
 )
 @testing.gpu
-@testing.with_requires('numpy>=1.10.0')
 class TestFftshift(unittest.TestCase):
 
     @testing.for_all_dtypes()
diff --git a/tests/cupy_tests/indexing_tests/test_indexing.py b/tests/cupy_tests/indexing_tests/test_indexing.py
--- a/tests/cupy_tests/indexing_tests/test_indexing.py
+++ b/tests/cupy_tests/indexing_tests/test_indexing.py
@@ -29,14 +29,12 @@ def test_take_no_axis(self, xp):
         b = xp.array([[10, 5], [3, 20]])
         return a.take(b)
 
-    @testing.with_requires('numpy>=1.15')
     @testing.numpy_cupy_array_equal()
     def test_take_along_axis(self, xp):
         a = testing.shaped_random((2, 4, 3), xp, dtype='float32')
         b = testing.shaped_random((2, 6, 3), xp, dtype='int64', scale=4)
         return xp.take_along_axis(a, b, axis=-2)
 
-    @testing.with_requires('numpy>=1.15')
     @testing.numpy_cupy_array_equal()
     def test_take_along_axis_none_axis(self, xp):
         a = testing.shaped_random((2, 4, 3), xp, dtype='float32')
@@ -85,13 +83,11 @@ def test_diagonal_negative5(self, xp, dtype):
         a = testing.shaped_arange((3, 3, 3), xp, dtype)
         return a.diagonal(0, -1, -3)
 
-    @testing.with_requires('numpy>=1.15')
     @testing.numpy_cupy_raises()
     def test_diagonal_invalid1(self, xp):
         a = testing.shaped_arange((3, 3, 3), xp)
         a.diagonal(0, 1, 3)
 
-    @testing.with_requires('numpy>=1.15')
     @testing.numpy_cupy_raises()
     def test_diagonal_invalid2(self, xp):
         a = testing.shaped_arange((3, 3, 3), xp)
diff --git a/tests/cupy_tests/indexing_tests/test_insert.py b/tests/cupy_tests/indexing_tests/test_insert.py
--- a/tests/cupy_tests/indexing_tests/test_insert.py
+++ b/tests/cupy_tests/indexing_tests/test_insert.py
@@ -14,7 +14,6 @@ class TestPlace(unittest.TestCase):
 
     # NumPy 1.9 don't wraps values.
     # https://github.com/numpy/numpy/pull/5821
-    @testing.with_requires('numpy>=1.10')
     @testing.for_all_dtypes()
     @testing.numpy_cupy_array_equal()
     def test_place(self, xp, dtype):
@@ -47,7 +46,6 @@ def test_place_empty_value_error(self, xp, dtype):
 
     # Before NumPy 1.12 it was TypeError.
     # https://github.com/numpy/numpy/pull/7003
-    @testing.with_requires('numpy>=1.12')
     @testing.for_all_dtypes()
     @testing.numpy_cupy_raises(accept_error=ValueError)
     def test_place_shape_unmatch_error(self, xp, dtype):
diff --git a/tests/cupy_tests/io_tests/test_npz.py b/tests/cupy_tests/io_tests/test_npz.py
--- a/tests/cupy_tests/io_tests/test_npz.py
+++ b/tests/cupy_tests/io_tests/test_npz.py
@@ -23,7 +23,6 @@ def test_save_load(self, dtype):
 
         testing.assert_array_equal(a, b)
 
-    @testing.with_requires('numpy>=1.10')
     def test_save_pickle(self):
         data = object()
 
@@ -36,7 +35,6 @@ def test_save_pickle(self):
         cupy.save(sio, data, allow_pickle=True)
         sio.close()
 
-    @testing.with_requires('numpy>=1.10')
     def test_load_pickle(self):
         a = testing.shaped_arange((2, 3, 4), dtype=cupy.float32)
 
@@ -88,7 +86,6 @@ def test_pickle(self, dtype):
         testing.assert_array_equal(a, b)
 
     @testing.for_all_dtypes()
-    @testing.with_requires('numpy>=1.10')
     def test_dump(self, dtype):
         a = testing.shaped_arange((2, 3, 4), dtype=dtype)
 
diff --git a/tests/cupy_tests/linalg_tests/test_einsum.py b/tests/cupy_tests/linalg_tests/test_einsum.py
--- a/tests/cupy_tests/linalg_tests/test_einsum.py
+++ b/tests/cupy_tests/linalg_tests/test_einsum.py
@@ -6,11 +6,6 @@
 from cupy import testing
 
 
-_bool_ok = testing.numpy_satisfies('>=1.10')  # after numpy PR #5946
-_float16_ok = testing.numpy_satisfies('>=1.15')  # after numpy PR #10911
-# require numpy!=1.14.0 because of numpy issue #10343
-
-
 def _dec_shape(shape, dec):
     # Test smaller shape
     return tuple(1 if s == 1 else max(0, s - dec) for s in shape)
@@ -61,7 +56,6 @@ def augument_einsum_testcases(*params):
                 yield param_new
 
 
-@testing.with_requires('numpy!=1.14.0')
 class TestEinSumError(unittest.TestCase):
 
     @testing.numpy_cupy_raises()
@@ -200,7 +194,6 @@ def test_invalid_arrow4(self, xp):
         xp.einsum('i-', xp.array([0, 0]))
 
 
-@testing.with_requires('numpy!=1.14.0')
 class TestListArgEinSumError(unittest.TestCase):
 
     @testing.numpy_cupy_raises()
@@ -273,10 +266,9 @@ def test_too_many_dims3(self, xp):
     {'shape_a': (), 'subscripts': ''},  # do nothing
     {'shape_a': (), 'subscripts': '->'},  # do nothing
 ))
-@testing.with_requires('numpy!=1.14.0')
 class TestEinSumUnaryOperation(unittest.TestCase):
 
-    @testing.for_all_dtypes(no_bool=not _bool_ok)
+    @testing.for_all_dtypes(no_bool=False)
     @testing.numpy_cupy_allclose(contiguous_check=False)
     def test_einsum_unary(self, xp, dtype):
         a = testing.shaped_arange(self.shape_a, xp, dtype)
@@ -286,7 +278,7 @@ def test_einsum_unary(self, xp, dtype):
             testing.assert_allclose(optimized_out, out)
         return out
 
-    @testing.for_all_dtypes(no_bool=not _bool_ok)
+    @testing.for_all_dtypes(no_bool=False)
     @testing.numpy_cupy_equal()
     def test_einsum_unary_views(self, xp, dtype):
         a = testing.shaped_arange(self.shape_a, xp, dtype)
@@ -296,7 +288,7 @@ def test_einsum_unary_views(self, xp, dtype):
 
     @testing.for_all_dtypes_combination(
         ['dtype_a', 'dtype_out'],
-        no_bool=not _bool_ok,
+        no_bool=False,
         no_complex=True)  # avoid ComplexWarning
     @testing.numpy_cupy_allclose(contiguous_check=False)
     def test_einsum_unary_dtype(self, xp, dtype_a, dtype_out):
@@ -371,12 +363,11 @@ def test_scalar_float(self, xp, dtype):
     {'shape_a': (1, 1, 1, 2, 3, 2), 'shape_b': (2, 3, 2, 2),
      'subscripts': '...lmn,lmno->...o'},
 ))
-@testing.with_requires('numpy!=1.14.0')
 class TestEinSumBinaryOperation(unittest.TestCase):
     @testing.for_all_dtypes_combination(
         ['dtype_a', 'dtype_b'],
-        no_bool=not _bool_ok,
-        no_float16=not _float16_ok)
+        no_bool=False,
+        no_float16=False)
     @testing.numpy_cupy_allclose(contiguous_check=False)
     def test_einsum_binary(self, xp, dtype_a, dtype_b):
         a = testing.shaped_arange(self.shape_a, xp, dtype_a)
@@ -418,12 +409,11 @@ def test_scalar_2(self, xp, dtype):
     {'shape_a': (3, 3, 4), 'shape_b': (3, 4), 'shape_c': (2, 3, 4),
      'subscripts': 'a...,...,c...->ac...'},
 ))
-@testing.with_requires('numpy!=1.14.0')
 class TestEinSumTernaryOperation(unittest.TestCase):
     @testing.for_all_dtypes_combination(
         ['dtype_a', 'dtype_b', 'dtype_c'],
-        no_bool=not _bool_ok,
-        no_float16=not _float16_ok)
+        no_bool=False,
+        no_float16=False)
     @testing.numpy_cupy_allclose(contiguous_check=False)
     def test_einsum_ternary(self, xp, dtype_a, dtype_b, dtype_c):
         a = testing.shaped_arange(self.shape_a, xp, dtype_a)
@@ -466,7 +456,6 @@ def test_einsum_ternary(self, xp, dtype_a, dtype_b, dtype_c):
     'a,ac,ab,ad,cd,bd,bc->',
 ], 'opt': ['greedy', 'optimal'],
 })))
-@testing.with_requires('numpy>=1.12,!=1.14.0')
 class TestEinSumLarge(unittest.TestCase):
 
     def setUp(self):
diff --git a/tests/cupy_tests/linalg_tests/test_norms.py b/tests/cupy_tests/linalg_tests/test_norms.py
--- a/tests/cupy_tests/linalg_tests/test_norms.py
+++ b/tests/cupy_tests/linalg_tests/test_norms.py
@@ -46,7 +46,6 @@ def test_external_trace(self, xp, dtype):
 })
 )
 @testing.gpu
-@testing.with_requires('numpy>=1.11.2')  # The old version dtype is strange
 class TestNorm(unittest.TestCase):
 
     # TODO(kmaehashi) Currently dtypes returned from CuPy is not compatible
@@ -74,11 +73,8 @@ def test_norm(self, xp, dtype):
 @testing.gpu
 class TestMatrixRank(unittest.TestCase):
 
-    # matrix_rank of CuPy returns in dtype compatible with NumPy 1.14.
-    type_check = testing.numpy_satisfies('>=1.14')
-
     @testing.for_all_dtypes(no_float16=True, no_complex=True)
-    @testing.numpy_cupy_array_equal(type_check=type_check)
+    @testing.numpy_cupy_array_equal(type_check=True)
     def test_matrix_rank(self, xp, dtype):
         a = xp.array(self.array, dtype=dtype)
         y = xp.linalg.matrix_rank(a, tol=self.tol)
@@ -118,14 +114,12 @@ def test_det_empty_batch(self, xp, dtype):
         a = xp.empty((2, 0, 3, 3), dtype)
         return xp.linalg.det(a)
 
-    @testing.with_requires('numpy>=1.13')
     @testing.for_float_dtypes(no_float16=True)
     @testing.numpy_cupy_allclose(rtol=1e-3, atol=1e-4)
     def test_det_empty_matrix(self, xp, dtype):
         a = xp.empty((0, 0), dtype)
         return xp.linalg.det(a)
 
-    @testing.with_requires('numpy>=1.13')
     @testing.for_float_dtypes(no_float16=True)
     @testing.numpy_cupy_allclose(rtol=1e-3, atol=1e-4)
     def test_det_empty_matrices(self, xp, dtype):
diff --git a/tests/cupy_tests/linalg_tests/test_product.py b/tests/cupy_tests/linalg_tests/test_product.py
--- a/tests/cupy_tests/linalg_tests/test_product.py
+++ b/tests/cupy_tests/linalg_tests/test_product.py
@@ -90,7 +90,6 @@ def test_dot_with_out(self, xp, dtype_a, dtype_b, dtype_c):
 @testing.gpu
 class TestCrossProduct(unittest.TestCase):
 
-    @testing.with_requires('numpy>=1.10')
     @testing.for_all_dtypes_combination(['dtype_a', 'dtype_b'])
     @testing.numpy_cupy_allclose()
     def test_cross(self, xp, dtype_a, dtype_b):
@@ -230,7 +229,6 @@ def test_inner(self, xp, dtype):
         return xp.inner(a, b)
 
     @testing.for_all_dtypes()
-    @testing.with_requires('numpy>=1.10.2')
     @testing.numpy_cupy_allclose()
     def test_reversed_inner(self, xp, dtype):
         a = testing.shaped_arange((5,), xp, dtype)[::-1]
@@ -392,7 +390,6 @@ def test_zerodim_kron(self, xp, dtype):
     ],
 }))
 @testing.gpu
-@testing.with_requires('numpy>=1.14.0')
 class TestProductZeroLength(unittest.TestCase):
 
     @testing.for_all_dtypes()
diff --git a/tests/cupy_tests/linalg_tests/test_solve.py b/tests/cupy_tests/linalg_tests/test_solve.py
--- a/tests/cupy_tests/linalg_tests/test_solve.py
+++ b/tests/cupy_tests/linalg_tests/test_solve.py
@@ -45,7 +45,6 @@ def test_invalid_shape(self):
         self.check_shape((3, 3), (2, 2))
         self.check_shape((3, 3, 4), (3,))
 
-    @testing.with_requires('numpy>=1.10')
     def test_invalid_shape2(self):
         # numpy 1.9 does not raise an error for this type of inputs
         self.check_shape((2, 3, 3), (3,))
diff --git a/tests/cupy_tests/logic_tests/test_comparison.py b/tests/cupy_tests/logic_tests/test_comparison.py
--- a/tests/cupy_tests/logic_tests/test_comparison.py
+++ b/tests/cupy_tests/logic_tests/test_comparison.py
@@ -76,7 +76,6 @@ def test_binary_array_pyscalar(self, xp, dtype):
 
 class TestAllclose(unittest.TestCase):
 
-    @testing.with_requires('numpy>=1.10')
     @testing.for_all_dtypes()
     @testing.numpy_cupy_equal()
     def test_allclose_finite(self, xp, dtype):
@@ -84,7 +83,6 @@ def test_allclose_finite(self, xp, dtype):
         b = xp.array([0, 0, 1000, 1000], dtype=dtype)
         return xp.allclose(a, b)
 
-    @testing.with_requires('numpy>=1.10')
     @testing.for_all_dtypes()
     @testing.numpy_cupy_equal()
     def test_allclose_min_int(self, xp, dtype):
@@ -102,7 +100,6 @@ def test_allclose_infinite(self, xp, dtype):
         b = xp.array([0, nan, 0, nan, inf, ninf], dtype=dtype)
         return xp.allclose(a, b)
 
-    @testing.with_requires('numpy>=1.10')
     @testing.for_float_dtypes()
     @testing.numpy_cupy_equal()
     def test_allclose_infinite_equal_nan(self, xp, dtype):
@@ -123,7 +120,6 @@ def test_allclose_array_scalar(self, xp, dtype):
 
 class TestIsclose(unittest.TestCase):
 
-    @testing.with_requires('numpy>=1.10')
     @testing.for_all_dtypes(no_complex=True)
     @testing.numpy_cupy_array_equal()
     def test_is_close_finite(self, xp, dtype):
@@ -132,7 +128,6 @@ def test_is_close_finite(self, xp, dtype):
         b = xp.array([0, 0, 1000, 1000], dtype=dtype)
         return xp.isclose(a, b)
 
-    @testing.with_requires('numpy>=1.10')
     @testing.for_all_dtypes(no_complex=True)
     @testing.numpy_cupy_array_equal()
     def test_is_close_min_int(self, xp, dtype):
diff --git a/tests/cupy_tests/manipulation_tests/test_dims.py b/tests/cupy_tests/manipulation_tests/test_dims.py
--- a/tests/cupy_tests/manipulation_tests/test_dims.py
+++ b/tests/cupy_tests/manipulation_tests/test_dims.py
@@ -44,7 +44,6 @@ def test_atleast_3d2(self, xp):
         a = testing.shaped_arange((1, 3, 2), xp)
         return xp.atleast_3d(a)
 
-    @testing.with_requires('numpy>=1.10')
     @testing.for_all_dtypes()
     @testing.numpy_cupy_array_equal()
     def test_broadcast_to(self, xp, dtype):
@@ -53,7 +52,6 @@ def test_broadcast_to(self, xp, dtype):
         b = xp.broadcast_to(a, (2, 3, 3, 4))
         return b
 
-    @testing.with_requires('numpy>=1.10')
     @testing.for_all_dtypes()
     @testing.numpy_cupy_raises()
     def test_broadcast_to_fail(self, xp, dtype):
@@ -61,7 +59,6 @@ def test_broadcast_to_fail(self, xp, dtype):
         a = testing.shaped_arange((3, 1, 4), xp, dtype)
         xp.broadcast_to(a, (1, 3, 4))
 
-    @testing.with_requires('numpy>=1.10')
     @testing.for_all_dtypes()
     @testing.numpy_cupy_raises()
     def test_broadcast_to_short_shape(self, xp, dtype):
@@ -176,7 +173,6 @@ def test_squeeze_int_axis2(self, xp):
         a = testing.shaped_arange((1, 2, 1, 3, 1, 1, 4, 1), xp)
         return a.squeeze(axis=-3)
 
-    @testing.with_requires('numpy>=1.13')
     @testing.numpy_cupy_raises()
     def test_squeeze_int_axis_failure1(self, xp):
         a = testing.shaped_arange((1, 2, 1, 3, 1, 1, 4, 1), xp)
@@ -207,7 +203,6 @@ def test_squeeze_tuple_axis4(self, xp):
         a = testing.shaped_arange((1, 2, 1, 3, 1, 1, 4, 1), xp)
         return a.squeeze(axis=())
 
-    @testing.with_requires('numpy>=1.13')
     @testing.numpy_cupy_raises()
     def test_squeeze_tuple_axis_failure1(self, xp):
         a = testing.shaped_arange((1, 2, 1, 3, 1, 1, 4, 1), xp)
@@ -233,13 +228,11 @@ def test_squeeze_scalar2(self, xp):
         a = testing.shaped_arange((), xp)
         return a.squeeze(axis=-1)
 
-    @testing.with_requires('numpy>=1.13')
     @testing.numpy_cupy_raises()
     def test_squeeze_scalar_failure1(self, xp):
         a = testing.shaped_arange((), xp)
         a.squeeze(axis=-2)
 
-    @testing.with_requires('numpy>=1.13')
     @testing.numpy_cupy_raises()
     def test_squeeze_scalar_failure2(self, xp):
         a = testing.shaped_arange((), xp)
diff --git a/tests/cupy_tests/manipulation_tests/test_join.py b/tests/cupy_tests/manipulation_tests/test_join.py
--- a/tests/cupy_tests/manipulation_tests/test_join.py
+++ b/tests/cupy_tests/manipulation_tests/test_join.py
@@ -197,7 +197,6 @@ def test_vstack_wrong_ndim(self):
         with self.assertRaises(ValueError):
             cupy.vstack((a, b))
 
-    @testing.with_requires('numpy>=1.10')
     @testing.numpy_cupy_array_equal()
     def test_stack(self, xp):
         a = testing.shaped_arange((2, 3), xp)
@@ -215,19 +214,16 @@ def test_stack_value(self):
         cupy.testing.assert_array_equal(s[1], b)
         cupy.testing.assert_array_equal(s[2], c)
 
-    @testing.with_requires('numpy>=1.10')
     @testing.numpy_cupy_array_equal()
     def test_stack_with_axis1(self, xp):
         a = testing.shaped_arange((2, 3), xp)
         return xp.stack((a, a), axis=1)
 
-    @testing.with_requires('numpy>=1.10')
     @testing.numpy_cupy_array_equal()
     def test_stack_with_axis2(self, xp):
         a = testing.shaped_arange((2, 3), xp)
         return xp.stack((a, a), axis=2)
 
-    @testing.with_requires('numpy>=1.10')
     @testing.numpy_cupy_raises()
     def test_stack_with_axis_over(self, xp):
         a = testing.shaped_arange((2, 3), xp)
@@ -241,7 +237,6 @@ def test_stack_with_axis_value(self):
         cupy.testing.assert_array_equal(s[:, 0, :], a)
         cupy.testing.assert_array_equal(s[:, 1, :], a)
 
-    @testing.with_requires('numpy>=1.10')
     @testing.numpy_cupy_array_equal()
     def test_stack_with_negative_axis(self, xp):
         a = testing.shaped_arange((2, 3), xp)
@@ -255,14 +250,12 @@ def test_stack_with_negative_axis_value(self):
         cupy.testing.assert_array_equal(s[:, :, 0], a)
         cupy.testing.assert_array_equal(s[:, :, 1], a)
 
-    @testing.with_requires('numpy>=1.10')
     @testing.numpy_cupy_raises()
     def test_stack_different_shape(self, xp):
         a = testing.shaped_arange((2, 3), xp)
         b = testing.shaped_arange((2, 4), xp)
         return xp.stack([a, b])
 
-    @testing.with_requires('numpy>=1.13')
     @testing.numpy_cupy_raises()
     def test_stack_out_of_bounds1(self, xp):
         a = testing.shaped_arange((2, 3), xp)
diff --git a/tests/cupy_tests/manipulation_tests/test_rearrange.py b/tests/cupy_tests/manipulation_tests/test_rearrange.py
--- a/tests/cupy_tests/manipulation_tests/test_rearrange.py
+++ b/tests/cupy_tests/manipulation_tests/test_rearrange.py
@@ -56,56 +56,48 @@ def test_roll_zero_array(self, xp, dtype):
         return xp.roll(x, 5)
 
     @testing.for_all_dtypes()
-    @testing.with_requires('numpy>=1.12')
     @testing.numpy_cupy_array_equal()
     def test_roll_scalar_shift_multi_axis(self, xp, dtype):
         x = testing.shaped_arange((5, 2), xp, dtype)
         return xp.roll(x, 1, axis=(0, 1))
 
     @testing.for_all_dtypes()
-    @testing.with_requires('numpy>=1.12')
     @testing.numpy_cupy_array_equal()
     def test_roll_scalar_shift_duplicate_axis(self, xp, dtype):
         x = testing.shaped_arange((5, 2), xp, dtype)
         return xp.roll(x, 1, axis=(0, 0))
 
     @testing.for_all_dtypes()
-    @testing.with_requires('numpy>=1.12')
     @testing.numpy_cupy_array_equal()
     def test_roll_large_shift(self, xp, dtype):
         x = testing.shaped_arange((5, 2), xp, dtype)
         return xp.roll(x, 50, axis=0)
 
     @testing.for_all_dtypes()
-    @testing.with_requires('numpy>=1.12')
     @testing.numpy_cupy_array_equal()
     def test_roll_multi_shift_multi_axis(self, xp, dtype):
         x = testing.shaped_arange((5, 2), xp, dtype)
         return xp.roll(x, (2, 1), axis=(0, 1))
 
     @testing.for_all_dtypes()
-    @testing.with_requires('numpy>=1.12')
     @testing.numpy_cupy_array_equal()
     def test_roll_multi_shift_multi_axis2(self, xp, dtype):
         x = testing.shaped_arange((5, 2), xp, dtype)
         return xp.roll(x, (2, 1), axis=(0, -1))
 
     @testing.for_all_dtypes()
-    @testing.with_requires('numpy>=1.12')
     @testing.numpy_cupy_array_equal()
     def test_roll_multi_shift_multi_axis3(self, xp, dtype):
         x = testing.shaped_arange((5, 2), xp, dtype)
         return xp.roll(x, (2, 1), axis=(1, -1))
 
     @testing.for_all_dtypes()
-    @testing.with_requires('numpy>=1.12')
     @testing.numpy_cupy_array_equal()
     def test_roll_multi_shift_scalar_axis(self, xp, dtype):
         x = testing.shaped_arange((5, 2), xp, dtype)
         return xp.roll(x, (2, 1, 3), axis=0)
 
     @testing.for_all_dtypes()
-    @testing.with_requires('numpy>=1.12')
     @testing.numpy_cupy_array_equal()
     def test_roll_multi_shift_axis_none(self, xp, dtype):
         x = testing.shaped_arange((5, 2), xp, dtype)
@@ -116,7 +108,6 @@ def test_roll_invalid_shift(self, xp):
         x = testing.shaped_arange((5, 2), xp)
         return xp.roll(x, '0', axis=0)
 
-    @testing.with_requires('numpy>=1.12')
     @testing.numpy_cupy_raises()
     def test_roll_shape_mismatch(self, xp):
         x = testing.shaped_arange((5, 2, 3), xp)
@@ -132,13 +123,11 @@ def test_roll_invalid_axis2(self, xp):
         x = testing.shaped_arange((5, 2), xp)
         return xp.roll(x, 1, axis=-3)
 
-    @testing.with_requires('numpy>=1.12')
     @testing.numpy_cupy_raises()
     def test_roll_invalid_axis_length(self, xp):
         x = testing.shaped_arange((5, 2, 2), xp)
         return cupy.roll(x, shift=(1, 0), axis=(0, 1, 2))
 
-    @testing.with_requires('numpy>=1.13')  # issue #2125
     @testing.numpy_cupy_raises()
     def test_roll_invalid_axis_type(self, xp):
         x = testing.shaped_arange((5, 2), xp)
@@ -149,7 +138,6 @@ def test_roll_invalid_negative_axis1(self, xp):
         x = testing.shaped_arange((5, 2), xp)
         return xp.roll(x, 1, axis=-3)
 
-    @testing.with_requires('numpy>=1.12')
     @testing.numpy_cupy_raises()
     def test_roll_invalid_negative_axis2(self, xp):
         x = testing.shaped_arange((5, 2), xp)
@@ -201,7 +189,6 @@ def test_flipud_insufficient_ndim(self, xp, dtype):
 
 
 @testing.gpu
-@testing.with_requires('numpy>=1.12')
 class TestFlip(unittest.TestCase):
 
     @testing.for_all_dtypes()
@@ -240,21 +227,18 @@ def test_flip_empty_dim_3(self, xp, dtype):
         x = xp.array([], dtype).reshape((1, 0, 1))
         return xp.flip(x, 1)
 
-    @testing.with_requires('numpy>=1.15')
     @testing.for_all_dtypes()
     @testing.numpy_cupy_raises()
     def test_flip_insufficient_ndim(self, xp, dtype):
         x = testing.shaped_arange((), xp, dtype)
         return xp.flip(x, 0)
 
-    @testing.with_requires('numpy>=1.15')
     @testing.for_all_dtypes()
     @testing.numpy_cupy_raises()
     def test_flip_invalid_axis(self, xp, dtype):
         x = testing.shaped_arange((3, 4), xp, dtype)
         return xp.flip(x, 2)
 
-    @testing.with_requires('numpy>=1.15')
     @testing.for_all_dtypes()
     @testing.numpy_cupy_raises()
     def test_flip_invalid_negative_axis(self, xp, dtype):
@@ -283,14 +267,12 @@ def test_rot90_negative(self, xp, dtype):
         x = testing.shaped_arange((3, 4, 2), xp, dtype)
         return xp.rot90(x, -1)
 
-    @testing.with_requires('numpy>=1.12')
     @testing.for_all_dtypes()
     @testing.numpy_cupy_array_equal()
     def test_rot90_with_axes(self, xp, dtype):
         x = testing.shaped_arange((3, 4, 2), xp, dtype)
         return xp.rot90(x, 1, axes=(1, 2))
 
-    @testing.with_requires('numpy>=1.12')
     @testing.for_all_dtypes()
     @testing.numpy_cupy_array_equal()
     def test_rot90_with_negative_axes(self, xp, dtype):
@@ -303,21 +285,18 @@ def test_rot90_insufficient_ndim(self, xp, dtype):
         x = testing.shaped_arange((3,), xp, dtype)
         return xp.rot90(x)
 
-    @testing.with_requires('numpy>=1.12')
     @testing.for_all_dtypes()
     @testing.numpy_cupy_raises()
     def test_rot90_too_much_axes(self, xp, dtype):
         x = testing.shaped_arange((3, 4, 2), xp, dtype)
         return xp.rot90(x, 1, axes=(0, 1, 2))
 
-    @testing.with_requires('numpy>=1.12')
     @testing.for_all_dtypes()
     @testing.numpy_cupy_raises()
     def test_rot90_invalid_axes(self, xp, dtype):
         x = testing.shaped_arange((3, 4, 2), xp, dtype)
         return xp.rot90(x, 1, axes=(1, 3))
 
-    @testing.with_requires('numpy>=1.12')
     @testing.for_all_dtypes()
     @testing.numpy_cupy_raises()
     def test_rot90_invalid_negative_axes(self, xp, dtype):
diff --git a/tests/cupy_tests/manipulation_tests/test_shape.py b/tests/cupy_tests/manipulation_tests/test_shape.py
--- a/tests/cupy_tests/manipulation_tests/test_shape.py
+++ b/tests/cupy_tests/manipulation_tests/test_shape.py
@@ -119,7 +119,6 @@ def test_external_ravel(self, xp):
 @testing.gpu
 class TestReshapeOrder(unittest.TestCase):
 
-    @testing.with_requires('numpy>=1.12')
     def test_reshape_contiguity(self):
         shape_init, shape_final = self.shape_in_out
 
diff --git a/tests/cupy_tests/manipulation_tests/test_split.py b/tests/cupy_tests/manipulation_tests/test_split.py
--- a/tests/cupy_tests/manipulation_tests/test_split.py
+++ b/tests/cupy_tests/manipulation_tests/test_split.py
@@ -16,7 +16,6 @@ def test_array_split2(self, xp):
         a = testing.shaped_arange((3, 11), xp)
         return xp.array_split(a, 4, -1)
 
-    @testing.with_requires('numpy>=1.11')
     @testing.numpy_cupy_array_list_equal()
     def test_array_split_empty_array(self, xp):
         a = testing.shaped_arange((5, 0), xp)
@@ -27,7 +26,6 @@ def test_array_split_empty_sections(self, xp):
         a = testing.shaped_arange((3, 11), xp)
         return xp.array_split(a, [])
 
-    @testing.with_requires('numpy>=1.11')
     @testing.numpy_cupy_array_list_equal()
     def test_array_split_out_of_bound1(self, xp):
         a = testing.shaped_arange((2, 3), xp)
@@ -78,7 +76,6 @@ def test_split_by_sections3(self, xp):
         a = testing.shaped_arange((3, 11), xp)
         return xp.split(a, (-9, 4, -2), 1)
 
-    @testing.with_requires('numpy>=1.11')
     @testing.numpy_cupy_array_list_equal()
     def test_split_out_of_bound1(self, xp):
         a = testing.shaped_arange((2, 3), xp)
diff --git a/tests/cupy_tests/manipulation_tests/test_tiling.py b/tests/cupy_tests/manipulation_tests/test_tiling.py
--- a/tests/cupy_tests/manipulation_tests/test_tiling.py
+++ b/tests/cupy_tests/manipulation_tests/test_tiling.py
@@ -44,7 +44,6 @@ def test_method(self):
     {'repeats': [2], 'axis': 1},
 )
 @testing.gpu
-@testing.with_requires('numpy>=1.10')
 class TestRepeatListBroadcast(unittest.TestCase):
 
     """Test for `repeats` argument using single element list.
@@ -79,7 +78,6 @@ def test_array_repeat(self, xp):
     {'repeats': [2], 'axis': 0},
 )
 @testing.gpu
-@testing.with_requires('numpy>=1.10')
 class TestRepeat1DListBroadcast(unittest.TestCase):
 
     """See comment in TestRepeatListBroadcast class."""
diff --git a/tests/cupy_tests/manipulation_tests/test_transpose.py b/tests/cupy_tests/manipulation_tests/test_transpose.py
--- a/tests/cupy_tests/manipulation_tests/test_transpose.py
+++ b/tests/cupy_tests/manipulation_tests/test_transpose.py
@@ -8,44 +8,37 @@
 class TestTranspose(unittest.TestCase):
 
     @testing.numpy_cupy_array_equal()
-    @testing.with_requires('numpy>=1.11')
     def test_moveaxis1(self, xp):
         a = testing.shaped_arange((2, 3, 4), xp)
         return xp.moveaxis(a, [0, 1], [1, 2])
 
     @testing.numpy_cupy_array_equal()
-    @testing.with_requires('numpy>=1.11')
     def test_moveaxis2(self, xp):
         a = testing.shaped_arange((2, 3, 4), xp)
         return xp.moveaxis(a, 1, -1)
 
     @testing.numpy_cupy_array_equal()
-    @testing.with_requires('numpy>=1.11')
     def test_moveaxis3(self, xp):
         a = testing.shaped_arange((2, 3, 4), xp)
         return xp.moveaxis(a, [0, 2], [1, 0])
 
     @testing.numpy_cupy_array_equal()
-    @testing.with_requires('numpy>=1.11')
     def test_moveaxis4(self, xp):
         a = testing.shaped_arange((2, 3, 4), xp)
         return xp.moveaxis(a, [2, 0], [1, 0])
 
     @testing.numpy_cupy_array_equal()
-    @testing.with_requires('numpy>=1.11')
     def test_moveaxis5(self, xp):
         a = testing.shaped_arange((2, 3, 4), xp)
         return xp.moveaxis(a, [2, 0], [0, 1])
 
     @testing.numpy_cupy_array_equal()
-    @testing.with_requires('numpy>=1.11')
     def test_moveaxis6(self, xp):
         a = testing.shaped_arange((2, 3, 4, 5, 6), xp)
         return xp.moveaxis(a, [0, 2, 1], [3, 4, 0])
 
     # dim is too large
     @testing.numpy_cupy_raises()
-    @testing.with_requires('numpy>=1.13')
     def test_moveaxis_invalid1_1(self, xp):
         a = testing.shaped_arange((2, 3, 4), xp)
         return xp.moveaxis(a, [0, 1], [1, 3])
@@ -57,7 +50,6 @@ def test_moveaxis_invalid1_2(self):
 
     # dim is too small
     @testing.numpy_cupy_raises()
-    @testing.with_requires('numpy>=1.13')
     def test_moveaxis_invalid2_1(self, xp):
         a = testing.shaped_arange((2, 3, 4), xp)
         return xp.moveaxis(a, [0, -4], [1, 2])
@@ -69,14 +61,12 @@ def test_moveaxis_invalid2_2(self):
 
     # len(source) != len(destination)
     @testing.numpy_cupy_raises()
-    @testing.with_requires('numpy>=1.11')
     def test_moveaxis_invalid3(self, xp):
         a = testing.shaped_arange((2, 3, 4), xp)
         return xp.moveaxis(a, [0, 1, 2], [1, 2])
 
     # len(source) != len(destination)
     @testing.numpy_cupy_raises()
-    @testing.with_requires('numpy>=1.11')
     def test_moveaxis_invalid4(self, xp):
         a = testing.shaped_arange((2, 3, 4), xp)
         return xp.moveaxis(a, [0, 1], [1, 2, 0])
diff --git a/tests/cupy_tests/math_tests/test_arithmetic.py b/tests/cupy_tests/math_tests/test_arithmetic.py
--- a/tests/cupy_tests/math_tests/test_arithmetic.py
+++ b/tests/cupy_tests/math_tests/test_arithmetic.py
@@ -77,10 +77,9 @@ def test_unary(self, xp):
             arg1 = xp.asarray(arg1)
         y = getattr(xp, self.name)(arg1)
 
-        is_over_1_13 = testing.numpy_satisfies('>=1.13.0')
-        if is_over_1_13 and self.name in ('real', 'imag'):
-            # From NumPy>=1.13, some functions return Python scalars for Python
-            # scalar inputs.
+        if self.name in ('real', 'imag'):
+            # Some NumPy functions return Python scalars for Python scalar
+            # inputs.
             # We need to convert them to arrays to compare with CuPy outputs.
             if xp is numpy and isinstance(arg1, (bool, int, float, complex)):
                 y = xp.asarray(y)
@@ -218,7 +217,7 @@ def check_binary(self, xp):
         if isinstance(arg2, numpy.ndarray):
             arg2 = xp.asarray(arg2)
 
-        # Subtraction between booleans is not allowed (NumPy>=1.13.0).
+        # Subtraction between booleans is not allowed.
         if (self.name == 'subtract'
                 and dtype1 == numpy.bool_
                 and dtype2 == numpy.bool_):
diff --git a/tests/cupy_tests/math_tests/test_matmul.py b/tests/cupy_tests/math_tests/test_matmul.py
--- a/tests/cupy_tests/math_tests/test_matmul.py
+++ b/tests/cupy_tests/math_tests/test_matmul.py
@@ -55,7 +55,6 @@
 @testing.gpu
 class TestMatmul(unittest.TestCase):
 
-    @testing.with_requires('numpy>=1.10')
     @testing.for_all_dtypes(name='dtype1')
     @testing.for_all_dtypes(name='dtype2')
     @testing.numpy_cupy_allclose(rtol=1e-3, atol=1e-3)  # required for uint8
@@ -64,7 +63,6 @@ def test_operator_matmul(self, xp, dtype1, dtype2):
         x2 = testing.shaped_arange(self.shape_pair[1], xp, dtype2)
         return operator.matmul(x1, x2)
 
-    @testing.with_requires('numpy>=1.10')
     @testing.for_all_dtypes(name='dtype1')
     @testing.for_all_dtypes(name='dtype2')
     @testing.numpy_cupy_allclose(rtol=1e-3, atol=1e-3)  # required for uint8
@@ -105,7 +103,6 @@ class TestMatmulLarge(unittest.TestCase):
         (numpy.uint16, numpy.uint16),
     }
 
-    @testing.with_requires('numpy>=1.10')
     @testing.for_all_dtypes(name='dtype1')
     @testing.for_all_dtypes(name='dtype2')
     @testing.numpy_cupy_allclose(rtol=1e-3, atol=1e-3)  # required for uint8
@@ -117,7 +114,6 @@ def test_operator_matmul(self, xp, dtype1, dtype2):
         x2 = testing.shaped_arange(self.shape_pair[1], xp, dtype2)
         return operator.matmul(x1, x2)
 
-    @testing.with_requires('numpy>=1.10')
     @testing.for_all_dtypes(name='dtype1')
     @testing.for_all_dtypes(name='dtype2')
     @testing.numpy_cupy_allclose(rtol=1e-3, atol=1e-3)  # required for uint8
@@ -147,7 +143,6 @@ def test_cupy_matmul(self, xp, dtype1, dtype2):
 @testing.gpu
 class TestMatmulInvalidShape(unittest.TestCase):
 
-    @testing.with_requires('numpy>=1.10')
     @testing.numpy_cupy_raises(accept_error=ValueError)
     def test_invalid_shape(self, xp):
         shape1, shape2 = self.shape_pair
diff --git a/tests/cupy_tests/math_tests/test_misc.py b/tests/cupy_tests/math_tests/test_misc.py
--- a/tests/cupy_tests/math_tests/test_misc.py
+++ b/tests/cupy_tests/math_tests/test_misc.py
@@ -105,11 +105,6 @@ def test_clip_min_none(self, xp, dtype):
         a = testing.shaped_arange((2, 3, 4), xp, dtype)
         return a.clip(None, 3)
 
-    # Skip this test due to NumPy bug on Windows (fixed in NumPy 1.14.0).
-    # https://github.com/numpy/numpy/pull/9778
-    @unittest.skipIf(
-        sys.platform == 'win32' and testing.numpy_satisfies('<1.14'),
-        'This test requires 1.14.0 when running on Windows.')
     @testing.for_all_dtypes(no_bool=True, no_complex=True)
     @testing.numpy_cupy_array_equal()
     def test_clip_max_none(self, xp, dtype):
@@ -144,12 +139,9 @@ def test_clip2(self, xp, dtype):
         a_max = xp.array([[10], [9], [8]], dtype=dtype)
         return a.clip(a_min, a_max)
 
-    @testing.with_requires('numpy>=1.11.2')
     def test_sqrt(self):
-        # numpy.sqrt is broken in numpy<1.11.2
         self.check_unary('sqrt')
 
-    @testing.with_requires('numpy>=1.10')
     @testing.for_all_dtypes(no_complex=True)
     @testing.numpy_cupy_allclose(atol=1e-5)
     def test_cbrt(self, xp, dtype):
@@ -195,19 +187,15 @@ def test_fmin(self):
     def test_fmin_nan(self):
         self.check_binary_nan('fmin')
 
-    @testing.with_requires('numpy>=1.10')
     def test_nan_to_num(self):
         self.check_unary('nan_to_num')
 
-    @testing.with_requires('numpy>=1.10')
     def test_nan_to_num_negative(self):
         self.check_unary_negative('nan_to_num')
 
-    @testing.with_requires('numpy<1.10')
     def test_nan_to_num_for_old_numpy(self):
         self.check_unary('nan_to_num', no_bool=True)
 
-    @testing.with_requires('numpy<1.10')
     def test_nan_to_num_negative_for_old_numpy(self):
         self.check_unary_negative('nan_to_num', no_bool=True)
 
diff --git a/tests/cupy_tests/math_tests/test_sumprod.py b/tests/cupy_tests/math_tests/test_sumprod.py
--- a/tests/cupy_tests/math_tests/test_sumprod.py
+++ b/tests/cupy_tests/math_tests/test_sumprod.py
@@ -57,7 +57,6 @@ def test_sum_axis(self, xp, dtype):
         return a.sum(axis=1)
 
     @testing.slow
-    @testing.with_requires('numpy>=1.10')
     @testing.numpy_cupy_allclose()
     def test_sum_axis_huge(self, xp):
         a = testing.shaped_random((2048, 1, 1024), xp, 'b')
@@ -302,14 +301,12 @@ def _test(self, xp, nan_slice):
         return xp.nansum(a, axis=2)
 
     @testing.slow
-    @testing.with_requires('numpy>=1.10')
     @testing.numpy_cupy_allclose(atol=1e-1)
     def test_nansum_axis_huge(self, xp):
         return self._test(
             xp, (slice(None, None), slice(None, None), slice(1, 2)))
 
     @testing.slow
-    @testing.with_requires('numpy>=1.10')
     @testing.numpy_cupy_allclose(atol=1e-2)
     def test_nansum_axis_huge_halfnan(self, xp):
         return self._test(
@@ -357,7 +354,6 @@ def test_cumsum_axis_empty(self, xp, dtype):
         return xp.cumsum(a, axis=self.axis)
 
     @testing.for_all_dtypes()
-    @testing.with_requires('numpy>=1.13')
     @testing.numpy_cupy_raises()
     def test_invalid_axis_lower1(self, xp, dtype):
         a = testing.shaped_arange((4, 5), xp, dtype)
@@ -370,7 +366,6 @@ def test_invalid_axis_lower2(self, dtype):
             return cupy.cumsum(a, axis=-a.ndim - 1)
 
     @testing.for_all_dtypes()
-    @testing.with_requires('numpy>=1.13')
     @testing.numpy_cupy_raises()
     def test_invalid_axis_upper1(self, xp, dtype):
         a = testing.shaped_arange((4, 5), xp, dtype)
@@ -434,7 +429,6 @@ def test_cumprod_huge_array(self):
         cupy.get_default_memory_pool().free_all_blocks()
 
     @testing.for_all_dtypes()
-    @testing.with_requires('numpy>=1.13')
     @testing.numpy_cupy_raises()
     def test_invalid_axis_lower1(self, xp, dtype):
         a = testing.shaped_arange((4, 5), xp, dtype)
@@ -447,7 +441,6 @@ def test_invalid_axis_lower2(self, dtype):
             return cupy.cumprod(a, axis=-a.ndim - 1)
 
     @testing.for_all_dtypes()
-    @testing.with_requires('numpy>=1.13')
     @testing.numpy_cupy_raises()
     def test_invalid_axis_upper1(self, xp, dtype):
         a = testing.shaped_arange((4, 5), xp, dtype)
@@ -471,7 +464,6 @@ def test_cumprod_numpy_array(self, xp, dtype):
 
 
 @testing.gpu
-@testing.with_requires('numpy>=1.14')  # NumPy issue #9251
 class TestDiff(unittest.TestCase):
 
     @testing.for_all_dtypes()
diff --git a/tests/cupy_tests/math_tests/test_trigonometric.py b/tests/cupy_tests/math_tests/test_trigonometric.py
--- a/tests/cupy_tests/math_tests/test_trigonometric.py
+++ b/tests/cupy_tests/math_tests/test_trigonometric.py
@@ -57,7 +57,6 @@ def test_rad2deg(self):
 
 
 @testing.gpu
-@testing.with_requires('numpy>=1.14')  # NumPy issue #9251
 class TestUnwrap(unittest.TestCase):
 
     @testing.for_all_dtypes(no_complex=True)
diff --git a/tests/cupy_tests/misc_tests/test_memory_ranges.py b/tests/cupy_tests/misc_tests/test_memory_ranges.py
--- a/tests/cupy_tests/misc_tests/test_memory_ranges.py
+++ b/tests/cupy_tests/misc_tests/test_memory_ranges.py
@@ -6,7 +6,6 @@
 
 
 @testing.gpu
-@testing.with_requires('numpy>=1.11')
 class TestMayShareMemory(unittest.TestCase):
 
     @testing.numpy_cupy_equal()
diff --git a/tests/cupy_tests/padding_tests/test_pad.py b/tests/cupy_tests/padding_tests/test_pad.py
--- a/tests/cupy_tests/padding_tests/test_pad.py
+++ b/tests/cupy_tests/padding_tests/test_pad.py
@@ -127,7 +127,6 @@ def f():
 )
 @testing.gpu
 # Old numpy does not work with multi-dimensional constant_values
-@testing.with_requires('numpy>=1.11.1')
 class TestPad(unittest.TestCase):
 
     @testing.for_all_dtypes(no_bool=True)
@@ -170,7 +169,6 @@ def f():
 )
 @testing.gpu
 # Old numpy does not work with multi-dimensional constant_values
-@testing.with_requires('numpy>=1.11.1')
 class TestPadMean(unittest.TestCase):
 
     @testing.for_all_dtypes(no_bool=True)
@@ -198,7 +196,6 @@ def f():
 @testing.gpu
 class TestPadNumpybug(unittest.TestCase):
 
-    @testing.with_requires('numpy>=1.11.2')
     @testing.for_all_dtypes(no_bool=True, no_complex=True)
     @testing.numpy_cupy_array_equal()
     def test_pad_highdim_default(self, xp, dtype):
@@ -227,10 +224,9 @@ def test_pad_empty(self, xp, dtype):
 @testing.gpu
 class TestPadCustomFunction(unittest.TestCase):
 
-    @testing.with_requires('numpy>=1.12')
     @testing.for_all_dtypes(no_bool=True)
     @testing.numpy_cupy_array_equal()
-    def test_pad_via_func_modifying_inplace(self, xp, dtype):
+    def test_pad_via_func(self, xp, dtype):
         def _padwithtens(vector, pad_width, iaxis, kwargs):
             vector[:pad_width[0]] = 10
             vector[-pad_width[1]:] = 10
@@ -238,17 +234,6 @@ def _padwithtens(vector, pad_width, iaxis, kwargs):
         a = xp.pad(a, 2, _padwithtens)
         return a
 
-    @testing.for_all_dtypes(no_bool=True)
-    @testing.numpy_cupy_array_equal()
-    def test_pad_via_func_returning_vector(self, xp, dtype):
-        def _padwithtens(vector, pad_width, iaxis, kwargs):
-            vector[:pad_width[0]] = 10
-            vector[-pad_width[1]:] = 10
-            return vector  # returning vector required by old NumPy (<=1.12)
-        a = xp.arange(6, dtype=dtype).reshape(2, 3)
-        a = xp.pad(a, 2, _padwithtens)
-        return a
-
 
 @testing.parameterize(
     # mode='constant'
@@ -307,7 +292,6 @@ def test_pad_special(self, xp):
      'notallowedkeyword': 3},
 )
 @testing.gpu
-@testing.with_requires('numpy>=1.11.1')  # Old numpy fails differently
 class TestPadFailure(unittest.TestCase):
 
     @testing.numpy_cupy_raises()
diff --git a/tests/cupy_tests/random_tests/test_distributions.py b/tests/cupy_tests/random_tests/test_distributions.py
--- a/tests/cupy_tests/random_tests/test_distributions.py
+++ b/tests/cupy_tests/random_tests/test_distributions.py
@@ -384,7 +384,6 @@ def test_negative_binomial_for_noninteger_n(self, n_dtype, p_dtype):
     'dtype': _int_dtypes,  # to escape timeout
 })
 )
-@testing.with_requires('numpy>=1.10')
 @testing.gpu
 class TestDistributionsNoncentralChisquare(RandomDistributionsTestCase):
 
@@ -419,7 +418,6 @@ def test_noncentral_chisquare_for_invalid_params(self, param_dtype):
     'dtype': _int_dtypes,  # to escape timeout
 })
 )
-@testing.with_requires('numpy>=1.14')
 @testing.gpu
 class TestDistributionsNoncentralF(RandomDistributionsTestCase):
 
@@ -557,7 +555,6 @@ def test_rayleigh(self, scale_dtype, dtype):
         self.check_distribution('rayleigh',
                                 {'scale': scale}, dtype)
 
-    @testing.with_requires('numpy>=1.12')
     @cupy.testing.for_float_dtypes('dtype', no_float16=True)
     @cupy.testing.for_float_dtypes('scale_dtype')
     def test_rayleigh_for_zero_scale(self, scale_dtype, dtype):
diff --git a/tests/cupy_tests/random_tests/test_generator.py b/tests/cupy_tests/random_tests/test_generator.py
--- a/tests/cupy_tests/random_tests/test_generator.py
+++ b/tests/cupy_tests/random_tests/test_generator.py
@@ -577,7 +577,6 @@ def test_negative_binomial(self):
     {'df': 2.0, 'nonc': 0.0},
 )
 @testing.gpu
-@testing.with_requires('numpy>=1.11')
 @testing.fix_random()
 class TestNoncentralChisquare(RandomGeneratorTestCase):
 
diff --git a/tests/cupy_tests/sorting_tests/test_count.py b/tests/cupy_tests/sorting_tests/test_count.py
--- a/tests/cupy_tests/sorting_tests/test_count.py
+++ b/tests/cupy_tests/sorting_tests/test_count.py
@@ -38,7 +38,6 @@ def func(xp):
             return int(c)
         self.assertEqual(func(numpy), func(cupy))
 
-    @testing.with_requires('numpy>=1.12')
     @testing.for_all_dtypes()
     def test_count_nonzero_int_axis(self, dtype):
         for ax in range(3):
@@ -48,7 +47,6 @@ def func(xp):
                 return xp.count_nonzero(a, axis=ax)
             testing.assert_allclose(func(numpy), func(cupy))
 
-    @testing.with_requires('numpy>=1.12')
     @testing.for_all_dtypes()
     def test_count_nonzero_tuple_axis(self, dtype):
         for ax in range(3):
diff --git a/tests/cupy_tests/sorting_tests/test_search.py b/tests/cupy_tests/sorting_tests/test_search.py
--- a/tests/cupy_tests/sorting_tests/test_search.py
+++ b/tests/cupy_tests/sorting_tests/test_search.py
@@ -478,7 +478,6 @@ def test_nanargmax_zero_size_axis1(self, xp, dtype):
 )
 class TestSearchSorted(unittest.TestCase):
 
-    @testing.with_requires('numpy>=1.10.0')
     @testing.for_all_dtypes(no_bool=True)
     @testing.numpy_cupy_array_list_equal()
     def test_searchsorted(self, xp, dtype):
@@ -494,7 +493,6 @@ def test_searchsorted(self, xp, dtype):
     {'side': 'right'})
 class TestSearchSortedNanInf(unittest.TestCase):
 
-    @testing.with_requires('numpy>=1.10.0')
     @testing.numpy_cupy_array_list_equal()
     def test_searchsorted_nanbins(self, xp):
         x = testing.shaped_arange((10,), xp, xp.float64)
@@ -502,7 +500,6 @@ def test_searchsorted_nanbins(self, xp):
         y = xp.searchsorted(bins, x, side=self.side)
         return y,
 
-    @testing.with_requires('numpy>=1.10.0')
     @testing.numpy_cupy_array_list_equal()
     def test_searchsorted_nan(self, xp):
         x = testing.shaped_arange((10,), xp, xp.float64)
@@ -511,7 +508,6 @@ def test_searchsorted_nan(self, xp):
         y = xp.searchsorted(bins, x, side=self.side)
         return y,
 
-    @testing.with_requires('numpy>=1.10.0')
     @testing.numpy_cupy_array_list_equal()
     def test_searchsorted_nan_last(self, xp):
         x = testing.shaped_arange((10,), xp, xp.float64)
@@ -520,7 +516,6 @@ def test_searchsorted_nan_last(self, xp):
         y = xp.searchsorted(bins, x, side=self.side)
         return y,
 
-    @testing.with_requires('numpy>=1.10.0')
     @testing.numpy_cupy_array_list_equal()
     def test_searchsorted_nan_last_repeat(self, xp):
         x = testing.shaped_arange((10,), xp, xp.float64)
@@ -529,7 +524,6 @@ def test_searchsorted_nan_last_repeat(self, xp):
         y = xp.searchsorted(bins, x, side=self.side)
         return y,
 
-    @testing.with_requires('numpy>=1.10.0')
     @testing.numpy_cupy_array_list_equal()
     def test_searchsorted_all_nans(self, xp):
         x = testing.shaped_arange((10,), xp, xp.float64)
@@ -539,7 +533,6 @@ def test_searchsorted_all_nans(self, xp):
         y = xp.searchsorted(bins, x, side=self.side)
         return y,
 
-    @testing.with_requires('numpy>=1.10.0')
     @testing.numpy_cupy_array_list_equal()
     def test_searchsorted_inf(self, xp):
         x = testing.shaped_arange((10,), xp, xp.float64)
@@ -548,7 +541,6 @@ def test_searchsorted_inf(self, xp):
         y = xp.searchsorted(bins, x, side=self.side)
         return y,
 
-    @testing.with_requires('numpy>=1.10.0')
     @testing.numpy_cupy_array_list_equal()
     def test_searchsorted_minf(self, xp):
         x = testing.shaped_arange((10,), xp, xp.float64)
@@ -564,7 +556,6 @@ class TestSearchSortedInvalid(unittest.TestCase):
     # Cant test unordered bins due to numpy undefined
     # behavior for searchsorted
 
-    @testing.with_requires('numpy>=1.10.0')
     @testing.numpy_cupy_raises(accept_error=ValueError)
     def test_searchsorted_ndbins(self, xp):
         x = testing.shaped_arange((10,), xp, xp.float64)
@@ -576,7 +567,6 @@ def test_searchsorted_ndbins(self, xp):
 @testing.gpu
 class TestSearchSortedWithSorter(unittest.TestCase):
 
-    @testing.with_requires('numpy>=1.10.0')
     @testing.numpy_cupy_array_list_equal()
     def test_sorter(self, xp):
         x = testing.shaped_arange((12,), xp, xp.float64)
@@ -585,7 +575,6 @@ def test_sorter(self, xp):
         y = xp.searchsorted(bins, x, sorter=sorter)
         return y,
 
-    @testing.with_requires('numpy>=1.10.0')
     @testing.numpy_cupy_raises(accept_error=ValueError)
     def test_invalid_sorter(self, xp):
         x = testing.shaped_arange((12,), xp, xp.float64)
@@ -593,7 +582,6 @@ def test_invalid_sorter(self, xp):
         sorter = xp.array([0])
         xp.searchsorted(bins, x, sorter=sorter)
 
-    @testing.with_requires('numpy>=1.10.0')
     @testing.numpy_cupy_raises(accept_error=TypeError)
     def test_nonint_sorter(self, xp):
         x = testing.shaped_arange((12,), xp, xp.float64)
diff --git a/tests/cupy_tests/sorting_tests/test_sort.py b/tests/cupy_tests/sorting_tests/test_sort.py
--- a/tests/cupy_tests/sorting_tests/test_sort.py
+++ b/tests/cupy_tests/sorting_tests/test_sort.py
@@ -116,7 +116,6 @@ def test_external_sort_none_axis(self, xp):
         a = testing.shaped_random((2, 3, 3), xp)
         return xp.sort(a, axis=None)
 
-    @testing.with_requires('numpy>=1.13')
     @testing.numpy_cupy_raises()
     def test_sort_invalid_axis1(self, xp):
         a = testing.shaped_random((2, 3, 3), xp)
@@ -127,7 +126,6 @@ def test_sort_invalid_axis2(self):
         with self.assertRaises(cupy.core._AxisError):
             a.sort(axis=3)
 
-    @testing.with_requires('numpy>=1.13')
     @testing.numpy_cupy_raises()
     def test_external_sort_invalid_axis1(self, xp):
         a = testing.shaped_random((2, 3, 3), xp)
@@ -138,7 +136,6 @@ def test_external_sort_invalid_axis2(self):
         with self.assertRaises(cupy.core._AxisError):
             cupy.sort(a, axis=3)
 
-    @testing.with_requires('numpy>=1.13')
     @testing.numpy_cupy_raises()
     def test_sort_invalid_negative_axis1(self, xp):
         a = testing.shaped_random((2, 3, 3), xp)
@@ -149,7 +146,6 @@ def test_sort_invalid_negative_axis2(self):
         with self.assertRaises(cupy.core._AxisError):
             a.sort(axis=-4)
 
-    @testing.with_requires('numpy>=1.13')
     @testing.numpy_cupy_raises()
     def test_external_sort_invalid_negative_axis1(self, xp):
         a = testing.shaped_random((2, 3, 3), xp)
@@ -269,7 +265,6 @@ def test_argsort_none_axis(self, xp):
         a = testing.shaped_random((2, 3, 3), xp)
         return self.argsort(a, axis=None)
 
-    @testing.with_requires('numpy>=1.13')
     @testing.numpy_cupy_raises()
     def test_argsort_invalid_axis1(self, xp):
         a = testing.shaped_random((2, 3, 3), xp)
@@ -280,7 +275,6 @@ def test_argsort_invalid_axis2(self):
         with self.assertRaises(cupy.core._AxisError):
             return self.argsort(a, axis=3)
 
-    @testing.with_requires('numpy>=1.13')
     @testing.numpy_cupy_raises()
     def test_argsort_invalid_negative_axis1(self, xp):
         a = testing.shaped_random((2, 3, 3), xp)
@@ -477,7 +471,6 @@ def test_partition_none_axis(self, xp):
         else:
             return None
 
-    @testing.with_requires('numpy>=1.13')
     @testing.numpy_cupy_raises()
     def test_partition_invalid_axis1(self, xp):
         a = testing.shaped_random((2, 2, self.length), xp)
@@ -492,7 +485,6 @@ def test_partition_invalid_axis2(self):
             axis = 3
             return self.partition(a, kth, axis=axis)
 
-    @testing.with_requires('numpy>=1.13')
     @testing.numpy_cupy_raises()
     def test_partition_invalid_negative_axis1(self, xp):
         a = testing.shaped_random((2, 2, self.length), xp)
@@ -649,7 +641,6 @@ def test_argpartition_none_axis(self, xp):
         self.assertTrue((a1[idx[kth]] < a1[idx[kth + 1:]]).all())
         return idx[kth]
 
-    @testing.with_requires('numpy>=1.13')
     @testing.numpy_cupy_raises()
     def test_argpartition_invalid_axis1(self, xp):
         a = testing.shaped_random((2, 2, 2), xp, scale=100)
@@ -664,7 +655,6 @@ def test_argpartition_invalid_axis2(self):
         with self.assertRaises(cupy.core._AxisError):
             self.argpartition(a, kth, axis=axis)
 
-    @testing.with_requires('numpy>=1.13')
     @testing.numpy_cupy_raises()
     def test_argpartition_invalid_negative_axis1(self, xp):
         a = testing.shaped_random((2, 2, 2), xp, scale=100)
diff --git a/tests/cupy_tests/statics_tests/test_correlation.py b/tests/cupy_tests/statics_tests/test_correlation.py
--- a/tests/cupy_tests/statics_tests/test_correlation.py
+++ b/tests/cupy_tests/statics_tests/test_correlation.py
@@ -77,6 +77,5 @@ def test_cov_raises(self):
         self.check_raises((3, 4, 2))
         self.check_raises((2, 3), (3, 4, 2))
 
-    @testing.with_requires('numpy>=1.10')
     def test_cov_empty(self):
         self.check((0, 1))
diff --git a/tests/cupy_tests/statics_tests/test_histogram.py b/tests/cupy_tests/statics_tests/test_histogram.py
--- a/tests/cupy_tests/statics_tests/test_histogram.py
+++ b/tests/cupy_tests/statics_tests/test_histogram.py
@@ -38,7 +38,6 @@ def for_all_dtypes_combination_bincount(names):
 @testing.gpu
 class TestHistogram(unittest.TestCase):
 
-    @testing.with_requires('numpy>=1.15.0')
     @testing.for_all_dtypes(no_bool=True, no_complex=True)
     @testing.numpy_cupy_array_list_equal()
     def test_histogram(self, xp, dtype):
@@ -46,7 +45,6 @@ def test_histogram(self, xp, dtype):
         y, bin_edges = xp.histogram(x)
         return y, bin_edges
 
-    @testing.with_requires('numpy>=1.15.0')
     @testing.for_all_dtypes(no_bool=True, no_complex=True)
     @testing.numpy_cupy_array_list_equal()
     def test_histogram_same_value(self, xp, dtype):
@@ -54,7 +52,6 @@ def test_histogram_same_value(self, xp, dtype):
         y, bin_edges = xp.histogram(x, 3)
         return y, bin_edges
 
-    @testing.with_requires('numpy>=1.15.0')
     @testing.for_all_dtypes(no_bool=True, no_complex=True)
     @testing.numpy_cupy_array_list_equal()
     def test_histogram_empty(self, xp, dtype):
@@ -77,7 +74,6 @@ def test_histogram_array_bins(self, xp, dtype):
         y, bin_edges = xp.histogram(x, bins)
         return y, bin_edges
 
-    @testing.with_requires('numpy>=1.13.2')
     @testing.for_all_dtypes(no_bool=True, no_complex=True)
     @testing.numpy_cupy_raises(accept_error=ValueError)
     def test_histogram_bins_not_ordered(self, xp, dtype):
@@ -137,7 +133,6 @@ def test_bincount_too_small(self, xp, dtype):
         return xp.bincount(x)
 
     @for_all_dtypes_bincount()
-    @testing.with_requires('numpy>=1.13')
     @testing.numpy_cupy_allclose(accept_error=TypeError)
     def test_bincount_zero(self, xp, dtype):
         x = testing.shaped_arange((3,), xp, dtype)
@@ -166,7 +161,6 @@ def test_bincount_too_small_minlength(self, xp, dtype):
 )
 class TestDigitize(unittest.TestCase):
 
-    @testing.with_requires('numpy>=1.10.0')
     @testing.for_all_dtypes(no_bool=True, no_complex=True)
     @testing.numpy_cupy_array_list_equal()
     def test_digitize(self, xp, dtype):
@@ -185,7 +179,6 @@ def test_digitize(self, xp, dtype):
     {'right': False})
 class TestDigitizeNanInf(unittest.TestCase):
 
-    @testing.with_requires('numpy>=1.10.0')
     @testing.numpy_cupy_array_list_equal()
     def test_digitize_nan(self, xp):
         x = testing.shaped_arange((14,), xp, xp.float32)
@@ -194,7 +187,6 @@ def test_digitize_nan(self, xp):
         y = xp.digitize(x, bins, right=self.right)
         return y,
 
-    @testing.with_requires('numpy>=1.10.0')
     @testing.numpy_cupy_array_list_equal()
     def test_digitize_nan_bins(self, xp):
         x = testing.shaped_arange((14,), xp, xp.float32)
@@ -202,7 +194,6 @@ def test_digitize_nan_bins(self, xp):
         y = xp.digitize(x, bins, right=self.right)
         return y,
 
-    @testing.with_requires('numpy>=1.10.0')
     @testing.numpy_cupy_array_list_equal()
     def test_digitize_nan_bins_repeated(self, xp):
         x = testing.shaped_arange((14,), xp, xp.float32)
@@ -212,7 +203,6 @@ def test_digitize_nan_bins_repeated(self, xp):
         y = xp.digitize(x, bins, right=self.right)
         return y,
 
-    @testing.with_requires('numpy>=1.10.0')
     @testing.numpy_cupy_array_list_equal()
     def test_digitize_nan_bins_decreasing(self, xp):
         x = testing.shaped_arange((14,), xp, xp.float32)
@@ -222,7 +212,6 @@ def test_digitize_nan_bins_decreasing(self, xp):
         y = xp.digitize(x, bins, right=self.right)
         return y,
 
-    @testing.with_requires('numpy>=1.10.0')
     @testing.numpy_cupy_array_list_equal()
     def test_digitize_nan_bins_decreasing_repeated(self, xp):
         x = testing.shaped_arange((14,), xp, xp.float32)
@@ -232,7 +221,6 @@ def test_digitize_nan_bins_decreasing_repeated(self, xp):
         y = xp.digitize(x, bins, right=self.right)
         return y,
 
-    @testing.with_requires('numpy>=1.10.0')
     @testing.numpy_cupy_array_list_equal()
     def test_digitize_all_nan_bins(self, xp):
         x = testing.shaped_arange((14,), xp, xp.float32)
@@ -242,7 +230,6 @@ def test_digitize_all_nan_bins(self, xp):
         y = xp.digitize(x, bins, right=self.right)
         return y,
 
-    @testing.with_requires('numpy>=1.10.0')
     @testing.numpy_cupy_array_list_equal()
     def test_searchsorted_inf(self, xp):
         x = testing.shaped_arange((14,), xp, xp.float64)
@@ -251,7 +238,6 @@ def test_searchsorted_inf(self, xp):
         y = xp.digitize(x, bins, right=self.right)
         return y,
 
-    @testing.with_requires('numpy>=1.10.0')
     @testing.numpy_cupy_array_list_equal()
     def test_searchsorted_minf(self, xp):
         x = testing.shaped_arange((14,), xp, xp.float64)
@@ -264,14 +250,12 @@ def test_searchsorted_minf(self, xp):
 @testing.gpu
 class TestDigitizeInvalid(unittest.TestCase):
 
-    @testing.with_requires('numpy>=1.10.0')
     @testing.numpy_cupy_raises(accept_error=TypeError)
     def test_digitize_complex(self, xp):
         x = testing.shaped_arange((14,), xp, xp.complex)
         bins = xp.array([1.0, 3.0, 5.0, 8.0, 12.0], xp.complex)
         xp.digitize(x, bins)
 
-    @testing.with_requires('numpy>=1.10.0')
     @testing.numpy_cupy_raises(accept_error=ValueError)
     def test_digitize_nd_bins(self, xp):
         x = testing.shaped_arange((14,), xp, xp.float64)
diff --git a/tests/cupy_tests/statics_tests/test_order.py b/tests/cupy_tests/statics_tests/test_order.py
--- a/tests/cupy_tests/statics_tests/test_order.py
+++ b/tests/cupy_tests/statics_tests/test_order.py
@@ -45,7 +45,6 @@ def test_percentile_neg_axis(self, xp, dtype, interpolation):
 
     @for_all_interpolations()
     @testing.for_all_dtypes(no_float16=True, no_bool=True, no_complex=True)
-    @testing.with_requires('numpy>=1.10.0')
     @testing.numpy_cupy_allclose(rtol=1e-6)
     def test_percentile_tuple_axis(self, xp, dtype, interpolation):
         a = testing.shaped_random((1, 6, 3, 2), xp, dtype)
diff --git a/tests/cupy_tests/test_type_routines.py b/tests/cupy_tests/test_type_routines.py
--- a/tests/cupy_tests/test_type_routines.py
+++ b/tests/cupy_tests/test_type_routines.py
@@ -36,8 +36,6 @@ def test_can_cast(self, xp, from_dtype, to_dtype):
         return ret
 
 
-# NumPy 1.9 cannot handle float16 in ``numpy.common_type``.
-@testing.with_requires('numpy>=1.10')
 class TestCommonType(unittest.TestCase):
 
     @testing.numpy_cupy_equal()
diff --git a/tests/cupy_tests/testing_tests/test_helper.py b/tests/cupy_tests/testing_tests/test_helper.py
--- a/tests/cupy_tests/testing_tests/test_helper.py
+++ b/tests/cupy_tests/testing_tests/test_helper.py
@@ -170,7 +170,6 @@ def dummy_axis_error(self, xp):
         with self.assertRaisesRegex(AssertionError, pattern):
             dummy_axis_error(self)
 
-    @testing.with_requires('numpy>=1.13')
     def test_axis_error_value_different_type(self):
         @testing.helper.numpy_cupy_raises()
         def dummy_axis_error(self, xp):
@@ -184,7 +183,6 @@ def dummy_axis_error(self, xp):
         with self.assertRaisesRegex(AssertionError, pattern):
             dummy_axis_error(self)
 
-    @testing.with_requires('numpy>=1.13')
     def test_axis_error_index_different_type(self):
         @testing.helper.numpy_cupy_raises()
         def dummy_axis_error(self, xp):
@@ -198,28 +196,6 @@ def dummy_axis_error(self, xp):
         with self.assertRaisesRegex(AssertionError, pattern):
             dummy_axis_error(self)
 
-    @testing.with_requires('numpy<1.13')
-    def test_axis_error_value(self):
-        @testing.helper.numpy_cupy_raises()
-        def dummy_axis_error(self, xp):
-            if xp is cupy:
-                raise cupy.core._errors._AxisError(self.tbs.get(cupy))
-            elif xp is numpy:
-                raise ValueError(self.tbs.get(numpy))
-
-        dummy_axis_error(self)
-
-    @testing.with_requires('numpy<1.13')
-    def test_axis_error_index(self):
-        @testing.helper.numpy_cupy_raises()
-        def dummy_axis_error(self, xp):
-            if xp is cupy:
-                raise cupy.core._errors._AxisError(self.tbs.get(cupy))
-            elif xp is numpy:
-                raise IndexError(self.tbs.get(numpy))
-
-        dummy_axis_error(self)
-
 
 class NumPyCuPyDecoratorBase(object):
 
diff --git a/tests/cupyx_tests/scipy_tests/fft_tests/test_fft.py b/tests/cupyx_tests/scipy_tests/fft_tests/test_fft.py
--- a/tests/cupyx_tests/scipy_tests/fft_tests/test_fft.py
+++ b/tests/cupyx_tests/scipy_tests/fft_tests/test_fft.py
@@ -34,7 +34,6 @@ def _correct_np_dtype(xp, dtype, out):
     'norm': [None, 'ortho']
 }))
 @testing.gpu
-@testing.with_requires('numpy>=1.10.0')
 class TestFft(unittest.TestCase):
 
     @testing.for_all_dtypes()
@@ -214,7 +213,6 @@ def test_ifft_plan_manager(self, xp, dtype):
         'norm': [None, 'ortho']
     })))
 @testing.gpu
-@testing.with_requires('numpy>=1.10.0')
 class TestFft2(unittest.TestCase):
 
     @testing.for_all_dtypes()
@@ -395,7 +393,6 @@ def test_ifft2_plan_manager(self, xp, dtype):
         'norm': [None, 'ortho']
     })))
 @testing.gpu
-@testing.with_requires('numpy>=1.10.0')
 class TestFftn(unittest.TestCase):
 
     @testing.for_all_dtypes()
@@ -564,7 +561,6 @@ def test_ifftn_plan_manager(self, xp, dtype):
     'norm': [None, 'ortho']
 }))
 @testing.gpu
-@testing.with_requires('numpy>=1.10.0')
 class TestRfft(unittest.TestCase):
 
     @testing.for_all_dtypes(no_complex=True)
@@ -644,7 +640,6 @@ def test_irfft_plan(self, dtype):
     {'shape': (2, 3, 4, 5), 's': None, 'axes': None, 'norm': None},
 )
 @testing.gpu
-@testing.with_requires('numpy>=1.10.0')
 class TestRfft2(unittest.TestCase):
 
     @testing.for_all_dtypes(no_complex=True)
@@ -725,7 +720,6 @@ def test_irfft2_plan(self, dtype):
     {'shape': (2, 3, 4, 5), 's': None, 'axes': None, 'norm': None},
 )
 @testing.gpu
-@testing.with_requires('numpy>=1.10.0')
 class TestRfftn(unittest.TestCase):
 
     @testing.for_all_dtypes(no_complex=True)
@@ -794,7 +788,6 @@ def test_irfftn_plan(self, dtype):
     'norm': [None, 'ortho'],
 }))
 @testing.gpu
-@testing.with_requires('numpy>=1.10.0')
 class TestHfft(unittest.TestCase):
 
     @testing.for_all_dtypes()
diff --git a/tests/cupyx_tests/test_rsqrt.py b/tests/cupyx_tests/test_rsqrt.py
--- a/tests/cupyx_tests/test_rsqrt.py
+++ b/tests/cupyx_tests/test_rsqrt.py
@@ -11,7 +11,6 @@
 class TestRsqrt(unittest.TestCase):
 
     @testing.for_all_dtypes(no_complex=True)
-    @testing.with_requires('numpy>=1.11.2')
     def test_rsqrt(self, dtype):
         # Adding 1.0 to avoid division by zero.
         a = testing.shaped_arange((2, 3), numpy, dtype) + 1.0