#!/usr/bin/env python

import os
from setuptools import setup
import sys

import cupy_setup_build


if sys.version_info[:3] == (3, 5, 0):
    if not int(os.getenv('CUPY_PYTHON_350_FORCE', '0')):
        msg = """
CuPy does not work with Python 3.5.0.

We strongly recommend to use another version of Python.
If you want to use CuPy with Python 3.5.0 at your own risk,
set 1 to CUPY_PYTHON_350_FORCE environment variable."""
        print(msg)
        sys.exit(1)


requirements = {
    'setup': [
        'fastrlock>=0.3',
    ],
    'install': [
        'numpy>=1.9.0',
        'fastrlock>=0.3',
    ],
    'stylecheck': [
        'autopep8==1.3.5',
        'flake8==3.5.0',
        'pbr==4.0.4',
        'pycodestyle==2.3.1',
    ],
    'test': [
        'pytest<4.2.0',  # 4.2.0 is slow collecting tests and times out on CI.
        'attrs<19.2.0',  # pytest 4.1.1 does not run with attrs==19.2.0
        'mock',
    ],
    'doctest': [
        'matplotlib',
        'theano',
    ],
    'docs': [
        'sphinx',
        'sphinx_rtd_theme',
    ],
    'travis': [
        '-r stylecheck',
        '-r docs',
    ],
    'appveyor': [
        '-r test',
    ],
    'jenkins': [
        '-r test',
        'pytest-timeout',
        'pytest-cov',
        'coveralls',
        'codecov',
    ],
}


def reduce_requirements(key):
    # Resolve recursive requirements notation (-r)
    reqs = requirements[key]
    resolved_reqs = []
    for req in reqs:
        if req.startswith('-r'):
            depend_key = req[2:].lstrip()
            reduce_requirements(depend_key)
            resolved_reqs += requirements[depend_key]
        else:
            resolved_reqs.append(req)
    requirements[key] = resolved_reqs


for k in requirements.keys():
    reduce_requirements(k)


extras_require = {k: v for k, v in requirements.items() if k != 'install'}


setup_requires = requirements['setup']
install_requires = requirements['install']
tests_require = requirements['test']


package_data = {
    'cupy': [
        'core/include/cupy/complex/arithmetic.h',
        'core/include/cupy/complex/catrig.h',
        'core/include/cupy/complex/catrigf.h',
        'core/include/cupy/complex/ccosh.h',
        'core/include/cupy/complex/ccoshf.h',
        'core/include/cupy/complex/cexp.h',
        'core/include/cupy/complex/cexpf.h',
        'core/include/cupy/complex/clog.h',
        'core/include/cupy/complex/clogf.h',
        'core/include/cupy/complex/complex.h',
        'core/include/cupy/complex/complex_inl.h',
        'core/include/cupy/complex/cpow.h',
        'core/include/cupy/complex/cproj.h',
        'core/include/cupy/complex/csinh.h',
        'core/include/cupy/complex/csinhf.h',
        'core/include/cupy/complex/csqrt.h',
        'core/include/cupy/complex/csqrtf.h',
        'core/include/cupy/complex/ctanh.h',
        'core/include/cupy/complex/ctanhf.h',
        'core/include/cupy/complex/math_private.h',
        'core/include/cupy/carray.cuh',
        'core/include/cupy/complex.cuh',
        'core/include/cupy/atomics.cuh',
        'core/include/cupy/cuComplex_bridge.h',
        'core/include/cupy/_cuda/cuda-*/*.h',
        'core/include/cupy/_cuda/cuda-*/*.hpp',
        'cuda/cupy_thrust.cu',
    ],
}

package_data['cupy'] += cupy_setup_build.prepare_wheel_libs()

package_name = cupy_setup_build.get_package_name()
long_description = cupy_setup_build.get_long_description()
ext_modules = cupy_setup_build.get_ext_modules()
build_ext = cupy_setup_build.custom_build_ext
sdist = cupy_setup_build.sdist_with_cython

here = os.path.abspath(os.path.dirname(__file__))
# Get __version__ variable
exec(open(os.path.join(here, 'cupy', '_version.py')).read())

CLASSIFIERS = """\
Development Status :: 5 - Production/Stable
Intended Audience :: Science/Research
Intended Audience :: Developers
License :: OSI Approved :: MIT License
Programming Language :: Python
Programming Language :: Python :: 3
Programming Language :: Python :: 3.5
Programming Language :: Python :: 3.6
Programming Language :: Python :: 3.7
Programming Language :: Python :: 3 :: Only
Programming Language :: Cython
Topic :: Software Development
Topic :: Scientific/Engineering
Operating System :: Microsoft :: Windows
Operating System :: POSIX
Operating System :: MacOS
"""


setup(
    name=package_name,
    version=__version__,  # NOQA
    description='CuPy: NumPy-like API accelerated with CUDA',
    long_description=long_description,
    author='Seiya Tokui',
    author_email='tokui@preferred.jp',
    url='https://cupy.chainer.org/',
    license='MIT License',
    project_urls={
        "Bug Tracker": "https://github.com/cupy/cupy/issues",
        "Documentation": "https://docs-cupy.chainer.org/",
        "Source Code": "https://github.com/cupy/cupy",
    },
    classifiers=[_f for _f in CLASSIFIERS.split('\n') if _f],
    packages=[
        'cupy',
        'cupy.binary',
        'cupy.core',
        'cupy.creation',
        'cupy.cuda',
        'cupy.cuda.memory_hooks',
        'cupy.ext',
        'cupy.fft',
        'cupy.indexing',
        'cupy.io',
        'cupy.lib',
        'cupy.linalg',
        'cupy.logic',
        'cupy.manipulation',
        'cupy.math',
        'cupy.misc',
        'cupy.padding',
        'cupy.prof',
        'cupy.random',
        'cupy._sorting',
        'cupy.sparse',
        'cupy.sparse.linalg',
        'cupy.statistics',
        'cupy.testing',
        'cupyx',
        'cupyx.fallback_mode',
        'cupyx.scipy',
        'cupyx.scipy.fft',
        'cupyx.scipy.fftpack',
        'cupyx.scipy.ndimage',
        'cupyx.scipy.sparse',
        'cupyx.scipy.sparse.linalg',
        'cupyx.scipy.special',
        'cupyx.scipy.linalg',
        'cupyx.linalg',
        'cupyx.linalg.sparse'
    ],
    package_data=package_data,
    zip_safe=False,
    python_requires='>=3.5.0',
    setup_requires=setup_requires,
    install_requires=install_requires,
    tests_require=tests_require,
    extras_require=extras_require,
    ext_modules=ext_modules,
    cmdclass={'build_ext': build_ext,
              'sdist': sdist},
)

setup.py
#!/usr/bin/env python

import os
from setuptools import setup
import sys

import cupy_setup_build


if sys.version_info[:3] == (3, 5, 0):
    if not int(os.getenv('CUPY_PYTHON_350_FORCE', '0')):
        msg = """
CuPy does not work with Python 3.5.0.

We strongly recommend to use another version of Python.
If you want to use CuPy with Python 3.5.0 at your own risk,
set 1 to CUPY_PYTHON_350_FORCE environment variable."""
        print(msg)
        sys.exit(1)


requirements = {
    'setup': [
        'fastrlock>=0.3',
    ],
    'install': [
        'numpy>=1.15',
        'fastrlock>=0.3',
    ],
    'stylecheck': [
        'autopep8==1.3.5',
        'flake8==3.5.0',
        'pbr==4.0.4',
        'pycodestyle==2.3.1',
    ],
    'test': [
        'pytest<4.2.0',  # 4.2.0 is slow collecting tests and times out on CI.
        'attrs<19.2.0',  # pytest 4.1.1 does not run with attrs==19.2.0
        'mock',
    ],
    'doctest': [
        'matplotlib',
        'theano',
    ],
    'docs': [
        'sphinx',
        'sphinx_rtd_theme',
    ],
    'travis': [
        '-r stylecheck',
        '-r docs',
    ],
    'appveyor': [
        '-r test',
    ],
    'jenkins': [
        '-r test',
        'pytest-timeout',
        'pytest-cov',
        'coveralls',
        'codecov',
    ],
}


def reduce_requirements(key):
    # Resolve recursive requirements notation (-r)
    reqs = requirements[key]
    resolved_reqs = []
    for req in reqs:
        if req.startswith('-r'):
            depend_key = req[2:].lstrip()
            reduce_requirements(depend_key)
            resolved_reqs += requirements[depend_key]
        else:
            resolved_reqs.append(req)
    requirements[key] = resolved_reqs


for k in requirements.keys():
    reduce_requirements(k)


extras_require = {k: v for k, v in requirements.items() if k != 'install'}


setup_requires = requirements['setup']
install_requires = requirements['install']
tests_require = requirements['test']


package_data = {
    'cupy': [
        'core/include/cupy/complex/arithmetic.h',
        'core/include/cupy/complex/catrig.h',
        'core/include/cupy/complex/catrigf.h',
        'core/include/cupy/complex/ccosh.h',
        'core/include/cupy/complex/ccoshf.h',
        'core/include/cupy/complex/cexp.h',
        'core/include/cupy/complex/cexpf.h',
        'core/include/cupy/complex/clog.h',
        'core/include/cupy/complex/clogf.h',
        'core/include/cupy/complex/complex.h',
        'core/include/cupy/complex/complex_inl.h',
        'core/include/cupy/complex/cpow.h',
        'core/include/cupy/complex/cproj.h',
        'core/include/cupy/complex/csinh.h',
        'core/include/cupy/complex/csinhf.h',
        'core/include/cupy/complex/csqrt.h',
        'core/include/cupy/complex/csqrtf.h',
        'core/include/cupy/complex/ctanh.h',
        'core/include/cupy/complex/ctanhf.h',
        'core/include/cupy/complex/math_private.h',
        'core/include/cupy/carray.cuh',
        'core/include/cupy/complex.cuh',
        'core/include/cupy/atomics.cuh',
        'core/include/cupy/cuComplex_bridge.h',
        'core/include/cupy/_cuda/cuda-*/*.h',
        'core/include/cupy/_cuda/cuda-*/*.hpp',
        'cuda/cupy_thrust.cu',
    ],
}

package_data['cupy'] += cupy_setup_build.prepare_wheel_libs()

package_name = cupy_setup_build.get_package_name()
long_description = cupy_setup_build.get_long_description()
ext_modules = cupy_setup_build.get_ext_modules()
build_ext = cupy_setup_build.custom_build_ext
sdist = cupy_setup_build.sdist_with_cython

here = os.path.abspath(os.path.dirname(__file__))
# Get __version__ variable
exec(open(os.path.join(here, 'cupy', '_version.py')).read())

CLASSIFIERS = """\
Development Status :: 5 - Production/Stable
Intended Audience :: Science/Research
Intended Audience :: Developers
License :: OSI Approved :: MIT License
Programming Language :: Python
Programming Language :: Python :: 3
Programming Language :: Python :: 3.5
Programming Language :: Python :: 3.6
Programming Language :: Python :: 3.7
Programming Language :: Python :: 3 :: Only
Programming Language :: Cython
Topic :: Software Development
Topic :: Scientific/Engineering
Operating System :: Microsoft :: Windows
Operating System :: POSIX
Operating System :: MacOS
"""


setup(
    name=package_name,
    version=__version__,  # NOQA
    description='CuPy: NumPy-like API accelerated with CUDA',
    long_description=long_description,
    author='Seiya Tokui',
    author_email='tokui@preferred.jp',
    url='https://cupy.chainer.org/',
    license='MIT License',
    project_urls={
        "Bug Tracker": "https://github.com/cupy/cupy/issues",
        "Documentation": "https://docs-cupy.chainer.org/",
        "Source Code": "https://github.com/cupy/cupy",
    },
    classifiers=[_f for _f in CLASSIFIERS.split('\n') if _f],
    packages=[
        'cupy',
        'cupy.binary',
        'cupy.core',
        'cupy.creation',
        'cupy.cuda',
        'cupy.cuda.memory_hooks',
        'cupy.ext',
        'cupy.fft',
        'cupy.indexing',
        'cupy.io',
        'cupy.lib',
        'cupy.linalg',
        'cupy.logic',
        'cupy.manipulation',
        'cupy.math',
        'cupy.misc',
        'cupy.padding',
        'cupy.prof',
        'cupy.random',
        'cupy._sorting',
        'cupy.sparse',
        'cupy.sparse.linalg',
        'cupy.statistics',
        'cupy.testing',
        'cupyx',
        'cupyx.fallback_mode',
        'cupyx.scipy',
        'cupyx.scipy.fft',
        'cupyx.scipy.fftpack',
        'cupyx.scipy.ndimage',
        'cupyx.scipy.sparse',
        'cupyx.scipy.sparse.linalg',
        'cupyx.scipy.special',
        'cupyx.scipy.linalg',
        'cupyx.linalg',
        'cupyx.linalg.sparse'
    ],
    package_data=package_data,
    zip_safe=False,
    python_requires='>=3.5.0',
    setup_requires=setup_requires,
    install_requires=install_requires,
    tests_require=tests_require,
    extras_require=extras_require,
    ext_modules=ext_modules,
    cmdclass={'build_ext': build_ext,
              'sdist': sdist},
)

setup.py
diff --git a/cupy/testing/helper.py b/cupy/testing/helper.py
index 14c19cff1b6..7b41cfc9fd2 100644
--- 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/docs/source/install.rst b/docs/source/install.rst
index 5261a86aa47..72809baee26 100644
--- a/docs/source/install.rst
+++ b/docs/source/install.rst
@@ -31,7 +31,7 @@ You need to have the following components to use CuPy.
 * `Python <https://python.org/>`_
     * Supported Versions: 3.5.1+, 3.6.0+, 3.7.0+ and 3.8.0+.
 * `NumPy <http://www.numpy.org/>`_
-    * Supported Versions: 1.9, 1.10, 1.11, 1.12, 1.13, 1.14, 1.15, 1.16, 1.17 and 1.18.
+    * Supported Versions: 1.15, 1.16, 1.17 and 1.18.
     * NumPy will be installed automatically during the installation of CuPy.
 
 Before installing CuPy, we recommend you to upgrade ``setuptools`` and ``pip``::
diff --git a/setup.py b/setup.py
index aadc3122a31..3fe6c8503d0 100644
--- 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': [
diff --git a/tests/cupy_tests/binary_tests/test_packing.py b/tests/cupy_tests/binary_tests/test_packing.py
index cc513f85f9c..c503a84f957 100644
--- 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
index f60b03072fe..40eb155a718 100644
--- 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
index dbcfc1bfe91..79e5acaee75 100644
--- 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
index 53058ef5550..06fab2a5ad7 100644
--- 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
index 8a901ba7bc1..e96fcb4be19 100644
--- 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
index 2c32b18f7bb..e24062fd8cf 100644
--- 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
index 8a94c26e89d..ef0787caa9a 100644
--- 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
index 0e9462549b3..52b7858ce26 100644
--- 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
index 395c26b34eb..b1c48a1f47b 100644
--- 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
index e9b6f57b29d..705c0893d8a 100644
--- 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
index 56e138600d0..62cd9bd8db6 100644
--- 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
index 2345130a893..8c383f1ec4d 100644
--- 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
index 7b697c407fb..b32bb38d9c7 100644
--- 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
index b9a5622c820..f0081196128 100644
--- 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
index ce0c5d215d9..abf8951aa44 100644
--- 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
index e76888cfca8..4be5e0104ce 100644
--- 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
index ee3552ae50b..59cdaad1aee 100644
--- 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
index 44696e1928e..b36e70b394f 100644
--- 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
index 387cefa9fc3..df1c1963c45 100644
--- 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
index 86011de7fa5..3829eb31e6d 100644
--- 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
index cca2375f18c..553a16f7c02 100644
--- 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
index 2205635d0a4..da192e6ed36 100644
--- 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
index 4ef50988942..d571e944d82 100644
--- 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
index fbf34641f8e..8728d93c41b 100644
--- 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
index 738b913ee9d..77172373625 100644
--- 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
index 34df069e245..ca9f8c0e743 100644
--- 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
index 4eaa4cc6a41..6dc0bb25d85 100644
--- 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
index 9516587b141..e6c64d94c6c 100644
--- 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
index a1c6a0a424e..a3bbeaf0ea8 100644
--- 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
index a38ae27cc22..2a249265e9b 100644
--- 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
index fd29a53863f..a17073507c9 100644
--- 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
index 5238f5048c9..59f4821e12b 100644
--- 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
index bd1655c9a1a..873b5fd1249 100644
--- 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
index 6b20871e3e3..485a329de2e 100644
--- 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
index b84a113df7a..7402d7a9abb 100644
--- 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
index 483d86af533..feaf8d8c361 100644
--- 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
index 06b516b8dca..4617460c301 100644
--- 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
index 7d1ac4dec25..97f13b39c18 100644
--- 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
index 645bb4b1056..2877b36445f 100644
--- 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
index bd7713f4274..06f62d4d8b1 100644
--- 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
index e77419a5c65..5be2271d90b 100644
--- 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
index 3c649c7383e..b299d91ca76 100644
--- 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
index 6373a0533f7..d7ba2b1cecf 100644
--- 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
index 835bb47f934..0f7badb0334 100644
--- 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
index 1b4d30fe9ed..06f6ad5f7a5 100644
--- 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
index 7c5890bcb02..66a7670fe58 100644
--- 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
index 442c173cf82..325f963dc5d 100644
--- 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
index b8c6513d49e..c75007bc45c 100644
--- 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
index 4094aa967fe..98606066145 100644
--- 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
index f4e07dbf8a7..c978fd74ee8 100644
--- 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
index 3ff8d8960f3..b691056df47 100644
--- 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

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.
