[Numpy-svn] r5335 - trunk/numpy/core/tests

numpy-svn@scip... numpy-svn@scip...
Wed Jul 2 21:49:07 CDT 2008


Author: alan.mcintyre
Date: 2008-07-02 21:49:02 -0500 (Wed, 02 Jul 2008)
New Revision: 5335

Modified:
   trunk/numpy/core/tests/test_defmatrix.py
   trunk/numpy/core/tests/test_numeric.py
   trunk/numpy/core/tests/test_numerictypes.py
   trunk/numpy/core/tests/test_records.py
   trunk/numpy/core/tests/test_regression.py
   trunk/numpy/core/tests/test_scalarmath.py
   trunk/numpy/core/tests/test_umath.py
   trunk/numpy/core/tests/test_unicode.py
Log:
Remove uses of set_package_path, set_local_path, restore_path.
Clean up and (somewhat) standardize test module imports.
In test_scalararray.py and test_defmatrix.py, update tests that are commented out so that 
they will be picked up in case they are ever uncommented.


Modified: trunk/numpy/core/tests/test_defmatrix.py
===================================================================
--- trunk/numpy/core/tests/test_defmatrix.py	2008-07-03 02:34:59 UTC (rev 5334)
+++ trunk/numpy/core/tests/test_defmatrix.py	2008-07-03 02:49:02 UTC (rev 5335)
@@ -1,9 +1,7 @@
 import sys
 from numpy.testing import *
-set_package_path()
 from numpy.core import *
 import numpy as np
-restore_path()
 
 class TestCtor(TestCase):
     def test_basic(self):
@@ -216,11 +214,11 @@
         assert isinstance(x, matrix)
         assert_equal(x, matrix([[4,  3], [1,  2]]))
 
-##     def check_vector_element(self):
-##         x = matrix([[1,2,3],[4,5,6]])
-##         assert_equal(x[0][0],1)
-##         assert_equal(x[0].shape,(1,3))
-##         assert_equal(x[:,0].shape,(2,1))
+#     def test_vector_element(self):
+#         x = matrix([[1,2,3],[4,5,6]])
+#         assert_equal(x[0][0],1)
+#         assert_equal(x[0].shape,(1,3))
+#         assert_equal(x[:,0].shape,(2,1))
 
     def test_matrix_element(self):
         x = matrix([[1,2,3],[4,5,6]])

Modified: trunk/numpy/core/tests/test_numeric.py
===================================================================
--- trunk/numpy/core/tests/test_numeric.py	2008-07-03 02:34:59 UTC (rev 5334)
+++ trunk/numpy/core/tests/test_numeric.py	2008-07-03 02:49:02 UTC (rev 5335)
@@ -291,17 +291,16 @@
         return (randn(n, m)).astype(float32)
 
     def _neg_byteorder(self, a):
-        import sys
-        a   = asarray(a)
+        a = asarray(a)
         if sys.byteorder == 'little':
-            a   = a.astype(a.dtype.newbyteorder('>'))
+            a = a.astype(a.dtype.newbyteorder('>'))
         else:
-            a   = a.astype(a.dtype.newbyteorder('<'))
+            a = a.astype(a.dtype.newbyteorder('<'))
         return a
 
     def _generate_non_native_data(self, n, m):
-        data    = randn(n, m)
-        data    = self._neg_byteorder(data)
+        data = randn(n, m)
+        data = self._neg_byteorder(data)
         assert not data.dtype.isnative
         return data
 

Modified: trunk/numpy/core/tests/test_numerictypes.py
===================================================================
--- trunk/numpy/core/tests/test_numerictypes.py	2008-07-03 02:34:59 UTC (rev 5334)
+++ trunk/numpy/core/tests/test_numerictypes.py	2008-07-03 02:49:02 UTC (rev 5335)
@@ -1,7 +1,6 @@
 import sys
 from numpy.testing import *
-import numpy
-from numpy import zeros, ones, array
+import numpy as np
 
 # This is the structure of the table used for plain objects:
 #
@@ -103,33 +102,33 @@
 
     def test_zeros0D(self):
         """Check creation of 0-dimensional objects"""
-        h = zeros((), dtype=self._descr)
+        h = np.zeros((), dtype=self._descr)
         self.assert_(normalize_descr(self._descr) == h.dtype.descr)
         self.assert_(h.dtype.fields['x'][0].name[:4] == 'void')
         self.assert_(h.dtype.fields['x'][0].char == 'V')
-        self.assert_(h.dtype.fields['x'][0].type == numpy.void)
+        self.assert_(h.dtype.fields['x'][0].type == np.void)
         # A small check that data is ok
-        assert_equal(h['z'], zeros((), dtype='u1'))
+        assert_equal(h['z'], np.zeros((), dtype='u1'))
 
     def test_zerosSD(self):
         """Check creation of single-dimensional objects"""
-        h = zeros((2,), dtype=self._descr)
+        h = np.zeros((2,), dtype=self._descr)
         self.assert_(normalize_descr(self._descr) == h.dtype.descr)
         self.assert_(h.dtype['y'].name[:4] == 'void')
         self.assert_(h.dtype['y'].char == 'V')
-        self.assert_(h.dtype['y'].type == numpy.void)
+        self.assert_(h.dtype['y'].type == np.void)
         # A small check that data is ok
-        assert_equal(h['z'], zeros((2,), dtype='u1'))
+        assert_equal(h['z'], np.zeros((2,), dtype='u1'))
 
     def test_zerosMD(self):
         """Check creation of multi-dimensional objects"""
-        h = zeros((2,3), dtype=self._descr)
+        h = np.zeros((2,3), dtype=self._descr)
         self.assert_(normalize_descr(self._descr) == h.dtype.descr)
         self.assert_(h.dtype['z'].name == 'uint8')
         self.assert_(h.dtype['z'].char == 'B')
-        self.assert_(h.dtype['z'].type == numpy.uint8)
+        self.assert_(h.dtype['z'].type == np.uint8)
         # A small check that data is ok
-        assert_equal(h['z'], zeros((2,3), dtype='u1'))
+        assert_equal(h['z'], np.zeros((2,3), dtype='u1'))
 
 
 class test_create_zeros_plain(create_zeros, TestCase):
@@ -146,7 +145,7 @@
 
     def test_tuple(self):
         """Check creation from tuples"""
-        h = array(self._buffer, dtype=self._descr)
+        h = np.array(self._buffer, dtype=self._descr)
         self.assert_(normalize_descr(self._descr) == h.dtype.descr)
         if self.multiple_rows:
             self.assert_(h.shape == (2,))
@@ -155,7 +154,7 @@
 
     def test_list_of_tuple(self):
         """Check creation from list of tuples"""
-        h = array([self._buffer], dtype=self._descr)
+        h = np.array([self._buffer], dtype=self._descr)
         self.assert_(normalize_descr(self._descr) == h.dtype.descr)
         if self.multiple_rows:
             self.assert_(h.shape == (1,2))
@@ -164,7 +163,7 @@
 
     def test_list_of_list_of_tuple(self):
         """Check creation from list of list of tuples"""
-        h = array([[self._buffer]], dtype=self._descr)
+        h = np.array([[self._buffer]], dtype=self._descr)
         self.assert_(normalize_descr(self._descr) == h.dtype.descr)
         if self.multiple_rows:
             self.assert_(h.shape == (1,1,2))
@@ -205,19 +204,19 @@
     """Check the reading of values in heterogeneous arrays (plain)"""
 
     def test_access_fields(self):
-        h = array(self._buffer, dtype=self._descr)
+        h = np.array(self._buffer, dtype=self._descr)
         if not self.multiple_rows:
             self.assert_(h.shape == ())
-            assert_equal(h['x'], array(self._buffer[0], dtype='i4'))
-            assert_equal(h['y'], array(self._buffer[1], dtype='f8'))
-            assert_equal(h['z'], array(self._buffer[2], dtype='u1'))
+            assert_equal(h['x'], np.array(self._buffer[0], dtype='i4'))
+            assert_equal(h['y'], np.array(self._buffer[1], dtype='f8'))
+            assert_equal(h['z'], np.array(self._buffer[2], dtype='u1'))
         else:
             self.assert_(len(h) == 2)
-            assert_equal(h['x'], array([self._buffer[0][0],
+            assert_equal(h['x'], np.array([self._buffer[0][0],
                                              self._buffer[1][0]], dtype='i4'))
-            assert_equal(h['y'], array([self._buffer[0][1],
+            assert_equal(h['y'], np.array([self._buffer[0][1],
                                              self._buffer[1][1]], dtype='f8'))
-            assert_equal(h['z'], array([self._buffer[0][2],
+            assert_equal(h['z'], np.array([self._buffer[0][2],
                                              self._buffer[1][2]], dtype='u1'))
 
 
@@ -239,73 +238,73 @@
 
     def test_access_top_fields(self):
         """Check reading the top fields of a nested array"""
-        h = array(self._buffer, dtype=self._descr)
+        h = np.array(self._buffer, dtype=self._descr)
         if not self.multiple_rows:
             self.assert_(h.shape == ())
-            assert_equal(h['x'], array(self._buffer[0], dtype='i4'))
-            assert_equal(h['y'], array(self._buffer[4], dtype='f8'))
-            assert_equal(h['z'], array(self._buffer[5], dtype='u1'))
+            assert_equal(h['x'], np.array(self._buffer[0], dtype='i4'))
+            assert_equal(h['y'], np.array(self._buffer[4], dtype='f8'))
+            assert_equal(h['z'], np.array(self._buffer[5], dtype='u1'))
         else:
             self.assert_(len(h) == 2)
-            assert_equal(h['x'], array([self._buffer[0][0],
-                                             self._buffer[1][0]], dtype='i4'))
-            assert_equal(h['y'], array([self._buffer[0][4],
-                                             self._buffer[1][4]], dtype='f8'))
-            assert_equal(h['z'], array([self._buffer[0][5],
-                                             self._buffer[1][5]], dtype='u1'))
+            assert_equal(h['x'], np.array([self._buffer[0][0],
+                                           self._buffer[1][0]], dtype='i4'))
+            assert_equal(h['y'], np.array([self._buffer[0][4],
+                                           self._buffer[1][4]], dtype='f8'))
+            assert_equal(h['z'], np.array([self._buffer[0][5],
+                                           self._buffer[1][5]], dtype='u1'))
+            
 
-
     def test_nested1_acessors(self):
         """Check reading the nested fields of a nested array (1st level)"""
-        h = array(self._buffer, dtype=self._descr)
+        h = np.array(self._buffer, dtype=self._descr)
         if not self.multiple_rows:
             assert_equal(h['Info']['value'],
-                         array(self._buffer[1][0], dtype='c16'))
+                         np.array(self._buffer[1][0], dtype='c16'))
             assert_equal(h['Info']['y2'],
-                         array(self._buffer[1][1], dtype='f8'))
+                         np.array(self._buffer[1][1], dtype='f8'))
             assert_equal(h['info']['Name'],
-                         array(self._buffer[3][0], dtype='U2'))
+                         np.array(self._buffer[3][0], dtype='U2'))
             assert_equal(h['info']['Value'],
-                         array(self._buffer[3][1], dtype='c16'))
+                         np.array(self._buffer[3][1], dtype='c16'))
         else:
             assert_equal(h['Info']['value'],
-                         array([self._buffer[0][1][0],
+                         np.array([self._buffer[0][1][0],
                                 self._buffer[1][1][0]],
                                 dtype='c16'))
             assert_equal(h['Info']['y2'],
-                         array([self._buffer[0][1][1],
+                         np.array([self._buffer[0][1][1],
                                 self._buffer[1][1][1]],
                                 dtype='f8'))
             assert_equal(h['info']['Name'],
-                         array([self._buffer[0][3][0],
+                         np.array([self._buffer[0][3][0],
                                 self._buffer[1][3][0]],
                                dtype='U2'))
             assert_equal(h['info']['Value'],
-                         array([self._buffer[0][3][1],
+                         np.array([self._buffer[0][3][1],
                                 self._buffer[1][3][1]],
                                dtype='c16'))
 
     def test_nested2_acessors(self):
         """Check reading the nested fields of a nested array (2nd level)"""
-        h = array(self._buffer, dtype=self._descr)
+        h = np.array(self._buffer, dtype=self._descr)
         if not self.multiple_rows:
             assert_equal(h['Info']['Info2']['value'],
-                         array(self._buffer[1][2][1], dtype='c16'))
+                         np.array(self._buffer[1][2][1], dtype='c16'))
             assert_equal(h['Info']['Info2']['z3'],
-                         array(self._buffer[1][2][3], dtype='u4'))
+                         np.array(self._buffer[1][2][3], dtype='u4'))
         else:
             assert_equal(h['Info']['Info2']['value'],
-                         array([self._buffer[0][1][2][1],
+                         np.array([self._buffer[0][1][2][1],
                                 self._buffer[1][1][2][1]],
                                dtype='c16'))
             assert_equal(h['Info']['Info2']['z3'],
-                         array([self._buffer[0][1][2][3],
+                         np.array([self._buffer[0][1][2][3],
                                 self._buffer[1][1][2][3]],
                                dtype='u4'))
 
     def test_nested1_descriptor(self):
         """Check access nested descriptors of a nested array (1st level)"""
-        h = array(self._buffer, dtype=self._descr)
+        h = np.array(self._buffer, dtype=self._descr)
         self.assert_(h.dtype['Info']['value'].name == 'complex128')
         self.assert_(h.dtype['Info']['y2'].name == 'float64')
         self.assert_(h.dtype['info']['Name'].name == 'unicode256')
@@ -313,7 +312,7 @@
 
     def test_nested2_descriptor(self):
         """Check access nested descriptors of a nested array (2nd level)"""
-        h = array(self._buffer, dtype=self._descr)
+        h = np.array(self._buffer, dtype=self._descr)
         self.assert_(h.dtype['Info']['Info2']['value'].name == 'void256')
         self.assert_(h.dtype['Info']['Info2']['z3'].name == 'void64')
 
@@ -332,26 +331,26 @@
 
 class TestEmptyField(TestCase):
     def test_assign(self):
-        a = numpy.arange(10, dtype=numpy.float32)
+        a = np.arange(10, dtype=np.float32)
         a.dtype = [("int",   "<0i4"),("float", "<2f4")]
         assert(a['int'].shape == (5,0))
         assert(a['float'].shape == (5,2))
 
 class TestCommonType(TestCase):
     def test_scalar_loses1(self):
-        res = numpy.find_common_type(['f4','f4','i4'],['f8'])
+        res = np.find_common_type(['f4','f4','i4'],['f8'])
         assert(res == 'f4')
     def test_scalar_loses2(self):
-        res = numpy.find_common_type(['f4','f4'],['i8'])
+        res = np.find_common_type(['f4','f4'],['i8'])
         assert(res == 'f4')
     def test_scalar_wins(self):
-        res = numpy.find_common_type(['f4','f4','i4'],['c8'])
+        res = np.find_common_type(['f4','f4','i4'],['c8'])
         assert(res == 'c8')
     def test_scalar_wins2(self):
-        res = numpy.find_common_type(['u4','i4','i4'],['f4'])
+        res = np.find_common_type(['u4','i4','i4'],['f4'])
         assert(res == 'f8')
     def test_scalar_wins3(self): # doesn't go up to 'f16' on purpose
-        res = numpy.find_common_type(['u8','i8','i8'],['f8'])
+        res = np.find_common_type(['u8','i8','i8'],['f8'])
         assert(res == 'f8')
 
 

Modified: trunk/numpy/core/tests/test_records.py
===================================================================
--- trunk/numpy/core/tests/test_records.py	2008-07-03 02:34:59 UTC (rev 5334)
+++ trunk/numpy/core/tests/test_records.py	2008-07-03 02:49:02 UTC (rev 5335)
@@ -1,8 +1,6 @@
+from os import path
 import numpy as np
 from numpy.testing import *
-from os import path
-set_package_path()
-restore_path()
 
 class TestFromrecords(TestCase):
     def test_fromrecords(self):

Modified: trunk/numpy/core/tests/test_regression.py
===================================================================
--- trunk/numpy/core/tests/test_regression.py	2008-07-03 02:34:59 UTC (rev 5334)
+++ trunk/numpy/core/tests/test_regression.py	2008-07-03 02:49:02 UTC (rev 5335)
@@ -3,9 +3,7 @@
 import sys
 from os import path
 from numpy.testing import *
-set_local_path()
 import numpy as np
-restore_path()
 
 rlevel = 1
 

Modified: trunk/numpy/core/tests/test_scalarmath.py
===================================================================
--- trunk/numpy/core/tests/test_scalarmath.py	2008-07-03 02:34:59 UTC (rev 5334)
+++ trunk/numpy/core/tests/test_scalarmath.py	2008-07-03 02:49:02 UTC (rev 5335)
@@ -1,6 +1,5 @@
 from numpy.testing import *
 import numpy.core.umath as ncu
-from numpy import array
 import numpy as np
 
 types = [np.bool_, np.byte, np.ubyte, np.short, np.ushort, np.intc, np.uintc,
@@ -20,10 +19,10 @@
         # list of types
         for k, atype in enumerate(types):
             vala = atype(3)
-            val1 = array([3],dtype=atype)
+            val1 = np.array([3],dtype=atype)
             for l, btype in enumerate(types):
                 valb = btype(1)
-                val2 = array([1],dtype=btype)
+                val2 = np.array([1],dtype=btype)
                 val = vala+valb
                 valo = val1 + val2
                 assert val.dtype.num == valo.dtype.num and \
@@ -32,7 +31,7 @@
 
     def test_type_create(self, level=1):
         for k, atype in enumerate(types):
-            a = array([1,2,3],atype)
+            a = np.array([1,2,3],atype)
             b = atype([1,2,3])
             assert_equal(a,b)
 
@@ -67,8 +66,8 @@
         assert_equal(map(int,a), li[:3])
 
 
-#class TestRepr(NumpyTestCase):
-#    def check_repr(self):
+#class TestRepr(TestCase):
+#    def test_repr(self):
 #        for t in types:
 #            val = t(1197346475.0137341)
 #            val_repr = repr(val)
@@ -89,7 +88,7 @@
             # could add some more types to the list below
             for which in ['small denorm','small norm']: 
                 # Values from http://en.wikipedia.org/wiki/IEEE_754
-                constr = array([0x00]*storage_bytes,dtype=np.uint8)
+                constr = np.array([0x00]*storage_bytes,dtype=np.uint8)
                 if which == 'small denorm':
                     byte = last_fraction_bit_idx // 8
                     bytebit = 7-(last_fraction_bit_idx % 8)

Modified: trunk/numpy/core/tests/test_umath.py
===================================================================
--- trunk/numpy/core/tests/test_umath.py	2008-07-03 02:34:59 UTC (rev 5334)
+++ trunk/numpy/core/tests/test_umath.py	2008-07-03 02:49:02 UTC (rev 5335)
@@ -1,22 +1,18 @@
 from numpy.testing import *
-set_package_path()
-from numpy.core.umath import minimum, maximum, exp
 import numpy.core.umath as ncu
-from numpy import zeros, ndarray, array, choose, pi
 import numpy as np
-restore_path()
 
 class TestDivision(TestCase):
     def test_division_int(self):
         # int division should return the floor of the result, a la Python
-        x = array([5, 10, 90, 100, -5, -10, -90, -100, -120])
+        x = np.array([5, 10, 90, 100, -5, -10, -90, -100, -120])
         assert_equal(x / 100, [0, 0, 0, 1, -1, -1, -1, -1, -2])
         assert_equal(x // 100, [0, 0, 0, 1, -1, -1, -1, -1, -2])
         assert_equal(x % 100, [5, 10, 90, 0, 95, 90, 10, 0, 80])
 
 class TestPower(TestCase):
     def test_power_float(self):
-        x = array([1., 2., 3.])
+        x = np.array([1., 2., 3.])
         assert_equal(x**0, [1., 1., 1.])
         assert_equal(x**1, x)
         assert_equal(x**2, [1., 4., 9.])
@@ -27,7 +23,7 @@
         assert_almost_equal(x**(0.5), [1., ncu.sqrt(2), ncu.sqrt(3)])
 
     def test_power_complex(self):
-        x = array([1+2j, 2+3j, 3+4j])
+        x = np.array([1+2j, 2+3j, 3+4j])
         assert_equal(x**0, [1., 1., 1.])
         assert_equal(x**1, x)
         assert_equal(x**2, [-3+4j, -5+12j, -7+24j])
@@ -52,12 +48,12 @@
 
 class TestMaximum(TestCase):
     def test_reduce_complex(self):
-        assert_equal(maximum.reduce([1,2j]),1)
-        assert_equal(maximum.reduce([1+3j,2j]),1+3j)
+        assert_equal(ncu.maximum.reduce([1,2j]),1)
+        assert_equal(ncu.maximum.reduce([1+3j,2j]),1+3j)
 
 class TestMinimum(TestCase):
     def test_reduce_complex(self):
-        assert_equal(minimum.reduce([1,2j]),2j)
+        assert_equal(ncu.minimum.reduce([1,2j]),2j)
 
 class TestFloatingPoint(TestCase):
     def test_floating_point(self):
@@ -65,29 +61,29 @@
 
 class TestDegrees(TestCase):
     def test_degrees(self):
-        assert_almost_equal(ncu.degrees(pi), 180.0)
-        assert_almost_equal(ncu.degrees(-0.5*pi), -90.0)
+        assert_almost_equal(ncu.degrees(np.pi), 180.0)
+        assert_almost_equal(ncu.degrees(-0.5*np.pi), -90.0)
 
 class TestRadians(TestCase):
     def test_radians(self):
-        assert_almost_equal(ncu.radians(180.0), pi)
-        assert_almost_equal(ncu.radians(-90.0), -0.5*pi)
+        assert_almost_equal(ncu.radians(180.0), np.pi)
+        assert_almost_equal(ncu.radians(-90.0), -0.5*np.pi)
 
 class TestSpecialMethods(TestCase):
     def test_wrap(self):
         class with_wrap(object):
             def __array__(self):
-                return zeros(1)
+                return np.zeros(1)
             def __array_wrap__(self, arr, context):
                 r = with_wrap()
                 r.arr = arr
                 r.context = context
                 return r
         a = with_wrap()
-        x = minimum(a, a)
-        assert_equal(x.arr, zeros(1))
+        x = ncu.minimum(a, a)
+        assert_equal(x.arr, np.zeros(1))
         func, args, i = x.context
-        self.failUnless(func is minimum)
+        self.failUnless(func is ncu.minimum)
         self.failUnlessEqual(len(args), 2)
         assert_equal(args[0], a)
         assert_equal(args[1], a)
@@ -96,19 +92,19 @@
     def test_old_wrap(self):
         class with_wrap(object):
             def __array__(self):
-                return zeros(1)
+                return np.zeros(1)
             def __array_wrap__(self, arr):
                 r = with_wrap()
                 r.arr = arr
                 return r
         a = with_wrap()
-        x = minimum(a, a)
-        assert_equal(x.arr, zeros(1))
+        x = ncu.minimum(a, a)
+        assert_equal(x.arr, np.zeros(1))
 
     def test_priority(self):
         class A(object):
             def __array__(self):
-                return zeros(1)
+                return np.zeros(1)
             def __array_wrap__(self, arr, context):
                 r = type(self)()
                 r.arr = arr
@@ -118,12 +114,12 @@
             __array_priority__ = 20.
         class C(A):
             __array_priority__ = 40.
-        x = zeros(1)
+        x = np.zeros(1)
         a = A()
         b = B()
         c = C()
-        f = minimum
-        self.failUnless(type(f(x,x)) is ndarray)
+        f = ncu.minimum
+        self.failUnless(type(f(x,x)) is np.ndarray)
         self.failUnless(type(f(x,a)) is A)
         self.failUnless(type(f(x,b)) is B)
         self.failUnless(type(f(x,c)) is C)
@@ -139,18 +135,18 @@
         self.failUnless(type(f(c,b)) is C)
         self.failUnless(type(f(c,c)) is C)
 
-        self.failUnless(type(exp(a) is A))
-        self.failUnless(type(exp(b) is B))
-        self.failUnless(type(exp(c) is C))
+        self.failUnless(type(ncu.exp(a) is A))
+        self.failUnless(type(ncu.exp(b) is B))
+        self.failUnless(type(ncu.exp(c) is C))
 
     def test_failing_wrap(self):
         class A(object):
             def __array__(self):
-                return zeros(1)
+                return np.zeros(1)
             def __array_wrap__(self, arr, context):
                 raise RuntimeError
         a = A()
-        self.failUnlessRaises(RuntimeError, maximum, a, a)
+        self.failUnlessRaises(RuntimeError, ncu.maximum, a, a)
 
     def test_array_with_context(self):
         class A(object):
@@ -159,28 +155,28 @@
                 self.func = func
                 self.args = args
                 self.i = i
-                return zeros(1)
+                return np.zeros(1)
         class B(object):
             def __array__(self, dtype=None):
-                return zeros(1, dtype)
+                return np.zeros(1, dtype)
         class C(object):
             def __array__(self):
-                return zeros(1)
+                return np.zeros(1)
         a = A()
-        maximum(zeros(1), a)
-        self.failUnless(a.func is maximum)
+        ncu.maximum(np.zeros(1), a)
+        self.failUnless(a.func is ncu.maximum)
         assert_equal(a.args[0], 0)
         self.failUnless(a.args[1] is a)
         self.failUnless(a.i == 1)
-        assert_equal(maximum(a, B()), 0)
-        assert_equal(maximum(a, C()), 0)
+        assert_equal(ncu.maximum(a, B()), 0)
+        assert_equal(ncu.maximum(a, C()), 0)
 
 
 class TestChoose(TestCase):
     def test_mixed(self):
-        c = array([True,True])
-        a = array([True,True])
-        assert_equal(choose(c, (a, 1)), array([1,1]))
+        c = np.array([True,True])
+        a = np.array([True,True])
+        assert_equal(np.choose(c, (a, 1)), np.array([1,1]))
 
 
 class TestComplexFunctions(TestCase):

Modified: trunk/numpy/core/tests/test_unicode.py
===================================================================
--- trunk/numpy/core/tests/test_unicode.py	2008-07-03 02:34:59 UTC (rev 5334)
+++ trunk/numpy/core/tests/test_unicode.py	2008-07-03 02:49:02 UTC (rev 5335)
@@ -1,4 +1,3 @@
-import sys
 from numpy.testing import *
 from numpy.core import *
 



More information about the Numpy-svn mailing list