import numpy as np
from numpy.testing import *

class TestPrint(TestCase):

    def test_float_types(self) :
        """ Check formatting.

            This is only for the str function, and only for simple types.
            The precision of np.float and np.longdouble aren't the same as the
            python float precision.

        """
        for t in [np.float, np.double, np.longdouble] :
            for x in [0, 1,-1, 1e10, 1e20] :
                assert_equal(str(t(x)), str(float(x)))

    def test_complex_types(self) :
        """Check formatting.

            This is only for the str function, and only for simple types.
            The precision of np.float and np.longdouble aren't the same as the
            python float precision.

        """
        for t in [np.cfloat, np.cdouble, np.clongdouble] :
            for x in [0, 1,-1, 1e10, 1e20] :
                assert_equal(str(t(x)), str(complex(x)))
                assert_equal(str(t(x*1j)), str(complex(x*1j)))
                assert_equal(str(t(x + x*1j)), str(complex(x + x*1j)))


if __name__ == "__main__":
    run_module_suite()

import numpy as np
from numpy.testing import *

def check_float_type(tp):
    for x in [0, 1,-1, 1e10, 1e20] :
        assert_equal(str(tp(x)), str(float(x)))

def test_float_types():
    """ Check formatting.

        This is only for the str function, and only for simple types.
        The precision of np.float and np.longdouble aren't the same as the
        python float precision.

    """
    for t in [np.float, np.double, np.longdouble] :
        yield check_float_type, t

def check_complex_type(tp):
    for x in [0, 1,-1, 1e10, 1e20] :
        assert_equal(str(tp(x)), str(complex(x)))
        assert_equal(str(tp(x*1j)), str(complex(x*1j)))
        assert_equal(str(tp(x + x*1j)), str(complex(x + x*1j)))

def test_complex_types():
    """Check formatting.

        This is only for the str function, and only for simple types.
        The precision of np.float and np.longdouble aren't the same as the
        python float precision.

    """
    for t in [np.cfloat, np.cdouble, np.clongdouble] :
        yield check_complex_type, t

if __name__ == "__main__":
    run_module_suite()

Use parametric tests for format tests so that it is clearer which type is failing.
Use parametric tests for format tests so that it is clearer which type is failing.

  import numpy as np
  from numpy.testing import *
  
- class TestPrint(TestCase):
+ def check_float_type(tp):
+     for x in [0, 1,-1, 1e10, 1e20] :
+         assert_equal(str(tp(x)), str(float(x)))
  
-     def test_float_types(self) :
+ def test_float_types():
-         """ Check formatting.
+     """ Check formatting.
  
-             This is only for the str function, and only for simple types.
+         This is only for the str function, and only for simple types.
-             The precision of np.float and np.longdouble aren't the same as the
+         The precision of np.float and np.longdouble aren't the same as the
-             python float precision.
+         python float precision.
  
-         """
+     """
-         for t in [np.float, np.double, np.longdouble] :
+     for t in [np.float, np.double, np.longdouble] :
+         yield check_float_type, t
-             for x in [0, 1,-1, 1e10, 1e20] :
-                 assert_equal(str(t(x)), str(float(x)))
  
-     def test_complex_types(self) :
-         """Check formatting.
+ def check_complex_type(tp):
+     for x in [0, 1,-1, 1e10, 1e20] :
+         assert_equal(str(tp(x)), str(complex(x)))
+         assert_equal(str(tp(x*1j)), str(complex(x*1j)))
+         assert_equal(str(tp(x + x*1j)), str(complex(x + x*1j)))
  
+ def test_complex_types():
+     """Check formatting.
-             This is only for the str function, and only for simple types.
-             The precision of np.float and np.longdouble aren't the same as the
-             python float precision.
  
+         This is only for the str function, and only for simple types.
+         The precision of np.float and np.longdouble aren't the same as the
+         python float precision.
-         """
-         for t in [np.cfloat, np.cdouble, np.clongdouble] :
-             for x in [0, 1,-1, 1e10, 1e20] :
-                 assert_equal(str(t(x)), str(complex(x)))
-                 assert_equal(str(t(x*1j)), str(complex(x*1j)))
-                 assert_equal(str(t(x + x*1j)), str(complex(x + x*1j)))
  
+     """
+     for t in [np.cfloat, np.cdouble, np.clongdouble] :
+         yield check_complex_type, t
  
  if __name__ == "__main__":
      run_module_suite()
  
Use parametric tests for format tests so that it is clearer which type is failing.
## Code Before:
import numpy as np
from numpy.testing import *

class TestPrint(TestCase):

    def test_float_types(self) :
        """ Check formatting.

            This is only for the str function, and only for simple types.
            The precision of np.float and np.longdouble aren't the same as the
            python float precision.

        """
        for t in [np.float, np.double, np.longdouble] :
            for x in [0, 1,-1, 1e10, 1e20] :
                assert_equal(str(t(x)), str(float(x)))

    def test_complex_types(self) :
        """Check formatting.

            This is only for the str function, and only for simple types.
            The precision of np.float and np.longdouble aren't the same as the
            python float precision.

        """
        for t in [np.cfloat, np.cdouble, np.clongdouble] :
            for x in [0, 1,-1, 1e10, 1e20] :
                assert_equal(str(t(x)), str(complex(x)))
                assert_equal(str(t(x*1j)), str(complex(x*1j)))
                assert_equal(str(t(x + x*1j)), str(complex(x + x*1j)))


if __name__ == "__main__":
    run_module_suite()

## Instruction:
Use parametric tests for format tests so that it is clearer which type is failing.
## Code After:
import numpy as np
from numpy.testing import *

def check_float_type(tp):
    for x in [0, 1,-1, 1e10, 1e20] :
        assert_equal(str(tp(x)), str(float(x)))

def test_float_types():
    """ Check formatting.

        This is only for the str function, and only for simple types.
        The precision of np.float and np.longdouble aren't the same as the
        python float precision.

    """
    for t in [np.float, np.double, np.longdouble] :
        yield check_float_type, t

def check_complex_type(tp):
    for x in [0, 1,-1, 1e10, 1e20] :
        assert_equal(str(tp(x)), str(complex(x)))
        assert_equal(str(tp(x*1j)), str(complex(x*1j)))
        assert_equal(str(tp(x + x*1j)), str(complex(x + x*1j)))

def test_complex_types():
    """Check formatting.

        This is only for the str function, and only for simple types.
        The precision of np.float and np.longdouble aren't the same as the
        python float precision.

    """
    for t in [np.cfloat, np.cdouble, np.clongdouble] :
        yield check_complex_type, t

if __name__ == "__main__":
    run_module_suite()
