Skip to content

Commit

Permalink
TST: replace TestCase.assert_ (deprecated in Python 3.2) with assertT…
Browse files Browse the repository at this point in the history 
…rue.
  • Loading branch information
@rgommers
rgommers committed Mar 2, 2011
1 parent ee0831a commit 4800446
Show file tree
Hide file tree
Showing 4 changed files with 64 additions and 64 deletions.
6 changes: 3 additions & 3 deletions numpy/core/tests/test_numeric.py
View file
Expand Up @@ -421,7 +421,7 @@ def can_cast(self):
assert_(np.can_cast(np.int32, np.int64))
assert_(np.can_cast(np.float64, np.complex))
assert_(not np.can_cast(np.complex, np.float))

assert_(np.can_cast('i8', 'f8'))
assert_(not np.can_cast('i8', 'f4'))
assert_(np.can_cast('i4', 'S4'))
Expand Down Expand Up @@ -1027,7 +1027,7 @@ def test_clip_func_takes_out(self):
a2 = clip(a, m, M, out=a)
self.clip(a, m, M, ac)
assert_array_strict_equal(a2, ac)
self.assert_(a2 is a)
self.assertTrue(a2 is a)


class test_allclose_inf(TestCase):
Expand Down Expand Up @@ -1150,7 +1150,7 @@ def check_like_function(self, like_function, value):
# default (K) order, dtype
dz = like_function(d, dtype=dtype)
assert_equal(dz.shape, d.shape)
assert_equal(array(dz.strides)*d.dtype.itemsize,
assert_equal(array(dz.strides)*d.dtype.itemsize,
array(d.strides)*dz.dtype.itemsize)
if dtype is None:
assert_equal(dz.dtype, d.dtype)
Expand Down
64 changes: 32 additions & 32 deletions numpy/core/tests/test_numerictypes.py
View file
Expand Up @@ -104,30 +104,30 @@ class create_zeros(object):
def test_zeros0D(self):
"""Check creation of 0-dimensional objects"""
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 == np.void)
self.assertTrue(normalize_descr(self._descr) == h.dtype.descr)
self.assertTrue(h.dtype.fields['x'][0].name[:4] == 'void')
self.assertTrue(h.dtype.fields['x'][0].char == 'V')
self.assertTrue(h.dtype.fields['x'][0].type == np.void)
# A small check that data is ok
assert_equal(h['z'], np.zeros((), dtype='u1'))

def test_zerosSD(self):
"""Check creation of single-dimensional objects"""
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 == np.void)
self.assertTrue(normalize_descr(self._descr) == h.dtype.descr)
self.assertTrue(h.dtype['y'].name[:4] == 'void')
self.assertTrue(h.dtype['y'].char == 'V')
self.assertTrue(h.dtype['y'].type == np.void)
# A small check that data is ok
assert_equal(h['z'], np.zeros((2,), dtype='u1'))

def test_zerosMD(self):
"""Check creation of multi-dimensional objects"""
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 == np.uint8)
self.assertTrue(normalize_descr(self._descr) == h.dtype.descr)
self.assertTrue(h.dtype['z'].name == 'uint8')
self.assertTrue(h.dtype['z'].char == 'B')
self.assertTrue(h.dtype['z'].type == np.uint8)
# A small check that data is ok
assert_equal(h['z'], np.zeros((2,3), dtype='u1'))

Expand All @@ -147,29 +147,29 @@ class create_values(object):
def test_tuple(self):
"""Check creation from tuples"""
h = np.array(self._buffer, dtype=self._descr)
self.assert_(normalize_descr(self._descr) == h.dtype.descr)
self.assertTrue(normalize_descr(self._descr) == h.dtype.descr)
if self.multiple_rows:
self.assert_(h.shape == (2,))
self.assertTrue(h.shape == (2,))
else:
self.assert_(h.shape == ())
self.assertTrue(h.shape == ())

def test_list_of_tuple(self):
"""Check creation from list of tuples"""
h = np.array([self._buffer], dtype=self._descr)
self.assert_(normalize_descr(self._descr) == h.dtype.descr)
self.assertTrue(normalize_descr(self._descr) == h.dtype.descr)
if self.multiple_rows:
self.assert_(h.shape == (1,2))
self.assertTrue(h.shape == (1,2))
else:
self.assert_(h.shape == (1,))
self.assertTrue(h.shape == (1,))

def test_list_of_list_of_tuple(self):
"""Check creation from list of list of tuples"""
h = np.array([[self._buffer]], dtype=self._descr)
self.assert_(normalize_descr(self._descr) == h.dtype.descr)
self.assertTrue(normalize_descr(self._descr) == h.dtype.descr)
if self.multiple_rows:
self.assert_(h.shape == (1,1,2))
self.assertTrue(h.shape == (1,1,2))
else:
self.assert_(h.shape == (1,1))
self.assertTrue(h.shape == (1,1))


class test_create_values_plain_single(create_values, TestCase):
Expand Down Expand Up @@ -207,12 +207,12 @@ class read_values_plain(object):
def test_access_fields(self):
h = np.array(self._buffer, dtype=self._descr)
if not self.multiple_rows:
self.assert_(h.shape == ())
self.assertTrue(h.shape == ())
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)
self.assertTrue(len(h) == 2)
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][1],
Expand Down Expand Up @@ -241,12 +241,12 @@ def test_access_top_fields(self):
"""Check reading the top fields of a nested array"""
h = np.array(self._buffer, dtype=self._descr)
if not self.multiple_rows:
self.assert_(h.shape == ())
self.assertTrue(h.shape == ())
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)
self.assertTrue(len(h) == 2)
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],
Expand Down Expand Up @@ -306,19 +306,19 @@ def test_nested2_acessors(self):
def test_nested1_descriptor(self):
"""Check access nested descriptors of a nested array (1st level)"""
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.assertTrue(h.dtype['Info']['value'].name == 'complex128')
self.assertTrue(h.dtype['Info']['y2'].name == 'float64')
if sys.version_info[0] >= 3:
self.assert_(h.dtype['info']['Name'].name == 'str256')
self.assertTrue(h.dtype['info']['Name'].name == 'str256')
else:
self.assert_(h.dtype['info']['Name'].name == 'unicode256')
self.assert_(h.dtype['info']['Value'].name == 'complex128')
self.assertTrue(h.dtype['info']['Name'].name == 'unicode256')
self.assertTrue(h.dtype['info']['Value'].name == 'complex128')

def test_nested2_descriptor(self):
"""Check access nested descriptors of a nested array (2nd level)"""
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')
self.assertTrue(h.dtype['Info']['Info2']['value'].name == 'void256')
self.assertTrue(h.dtype['Info']['Info2']['z3'].name == 'void64')


class test_read_values_nested_single(read_values_nested, TestCase):
Expand Down
8 changes: 4 additions & 4 deletions numpy/core/tests/test_regression.py
View file
Expand Up @@ -115,11 +115,11 @@ def test_scalar_compare(self,level=rlevel):
"""Ticket #72"""
a = np.array(['test', 'auto'])
assert_array_equal(a == 'auto', np.array([False,True]))
self.assert_(a[1] == 'auto')
self.assert_(a[0] != 'auto')
self.assertTrue(a[1] == 'auto')
self.assertTrue(a[0] != 'auto')
b = np.linspace(0, 10, 11)
self.assert_(b != 'auto')
self.assert_(b[0] != 'auto')
self.assertTrue(b != 'auto')
self.assertTrue(b[0] != 'auto')

def test_unicode_swapping(self,level=rlevel):
"""Ticket #79"""
Expand Down
50 changes: 25 additions & 25 deletions numpy/core/tests/test_unicode.py
View file
Expand Up @@ -42,18 +42,18 @@ class create_zeros(object):
def content_check(self, ua, ua_scalar, nbytes):

# Check the length of the unicode base type
self.assert_(int(ua.dtype.str[2:]) == self.ulen)
self.assertTrue(int(ua.dtype.str[2:]) == self.ulen)
# Check the length of the data buffer
self.assert_(buffer_length(ua) == nbytes)
self.assertTrue(buffer_length(ua) == nbytes)
# Small check that data in array element is ok
self.assert_(ua_scalar == u'')
self.assertTrue(ua_scalar == u'')
# Encode to ascii and double check
self.assert_(ua_scalar.encode('ascii') == asbytes(''))
self.assertTrue(ua_scalar.encode('ascii') == asbytes(''))
# Check buffer lengths for scalars
if ucs4:
self.assert_(buffer_length(ua_scalar) == 0)
self.assertTrue(buffer_length(ua_scalar) == 0)
else:
self.assert_(buffer_length(ua_scalar) == 0)
self.assertTrue(buffer_length(ua_scalar) == 0)

def test_zeros0D(self):
"""Check creation of 0-dimensional objects"""
Expand Down Expand Up @@ -94,26 +94,26 @@ class create_values(object):
def content_check(self, ua, ua_scalar, nbytes):

# Check the length of the unicode base type
self.assert_(int(ua.dtype.str[2:]) == self.ulen)
self.assertTrue(int(ua.dtype.str[2:]) == self.ulen)
# Check the length of the data buffer
self.assert_(buffer_length(ua) == nbytes)
self.assertTrue(buffer_length(ua) == nbytes)
# Small check that data in array element is ok
self.assert_(ua_scalar == self.ucs_value*self.ulen)
self.assertTrue(ua_scalar == self.ucs_value*self.ulen)
# Encode to UTF-8 and double check
self.assert_(ua_scalar.encode('utf-8') == \
self.assertTrue(ua_scalar.encode('utf-8') == \
(self.ucs_value*self.ulen).encode('utf-8'))
# Check buffer lengths for scalars
if ucs4:
self.assert_(buffer_length(ua_scalar) == 4*self.ulen)
self.assertTrue(buffer_length(ua_scalar) == 4*self.ulen)
else:
if self.ucs_value == ucs4_value:
# In UCS2, the \U0010FFFF will be represented using a
# surrogate *pair*
self.assert_(buffer_length(ua_scalar) == 2*2*self.ulen)
self.assertTrue(buffer_length(ua_scalar) == 2*2*self.ulen)
else:
# In UCS2, the \uFFFF will be represented using a
# regular 2-byte word
self.assert_(buffer_length(ua_scalar) == 2*self.ulen)
self.assertTrue(buffer_length(ua_scalar) == 2*self.ulen)

def test_values0D(self):
"""Check creation of 0-dimensional objects with values"""
Expand Down Expand Up @@ -179,26 +179,26 @@ class assign_values(object):
def content_check(self, ua, ua_scalar, nbytes):

# Check the length of the unicode base type
self.assert_(int(ua.dtype.str[2:]) == self.ulen)
self.assertTrue(int(ua.dtype.str[2:]) == self.ulen)
# Check the length of the data buffer
self.assert_(buffer_length(ua) == nbytes)
self.assertTrue(buffer_length(ua) == nbytes)
# Small check that data in array element is ok
self.assert_(ua_scalar == self.ucs_value*self.ulen)
self.assertTrue(ua_scalar == self.ucs_value*self.ulen)
# Encode to UTF-8 and double check
self.assert_(ua_scalar.encode('utf-8') == \
self.assertTrue(ua_scalar.encode('utf-8') == \
(self.ucs_value*self.ulen).encode('utf-8'))
# Check buffer lengths for scalars
if ucs4:
self.assert_(buffer_length(ua_scalar) == 4*self.ulen)
self.assertTrue(buffer_length(ua_scalar) == 4*self.ulen)
else:
if self.ucs_value == ucs4_value:
# In UCS2, the \U0010FFFF will be represented using a
# surrogate *pair*
self.assert_(buffer_length(ua_scalar) == 2*2*self.ulen)
self.assertTrue(buffer_length(ua_scalar) == 2*2*self.ulen)
else:
# In UCS2, the \uFFFF will be represented using a
# regular 2-byte word
self.assert_(buffer_length(ua_scalar) == 2*self.ulen)
self.assertTrue(buffer_length(ua_scalar) == 2*self.ulen)

def test_values0D(self):
"""Check assignment of 0-dimensional objects with values"""
Expand Down Expand Up @@ -274,7 +274,7 @@ def test_values0D(self):
# This changes the interpretation of the data region (but not the
# actual data), therefore the returned scalars are not
# the same (they are byte-swapped versions of each other).
self.assert_(ua[()] != ua2[()])
self.assertTrue(ua[()] != ua2[()])
ua3 = ua2.newbyteorder()
# Arrays must be equal after the round-trip
assert_equal(ua, ua3)
Expand All @@ -283,8 +283,8 @@ def test_valuesSD(self):
"""Check byteorder of single-dimensional objects"""
ua = array([self.ucs_value*self.ulen]*2, dtype='U%s' % self.ulen)
ua2 = ua.newbyteorder()
self.assert_(ua[0] != ua2[0])
self.assert_(ua[-1] != ua2[-1])
self.assertTrue(ua[0] != ua2[0])
self.assertTrue(ua[-1] != ua2[-1])
ua3 = ua2.newbyteorder()
# Arrays must be equal after the round-trip
assert_equal(ua, ua3)
Expand All @@ -294,8 +294,8 @@ def test_valuesMD(self):
ua = array([[[self.ucs_value*self.ulen]*2]*3]*4,
dtype='U%s' % self.ulen)
ua2 = ua.newbyteorder()
self.assert_(ua[0,0,0] != ua2[0,0,0])
self.assert_(ua[-1,-1,-1] != ua2[-1,-1,-1])
self.assertTrue(ua[0,0,0] != ua2[0,0,0])
self.assertTrue(ua[-1,-1,-1] != ua2[-1,-1,-1])
ua3 = ua2.newbyteorder()
# Arrays must be equal after the round-trip
assert_equal(ua, ua3)
Expand Down

0 comments on commit 4800446

Please sign in to comment.