from test
import test_support
from weakref
import proxy
import array
, cStringIO
, math
tests
= [] # list to accumulate all tests
typecodes
= "cubBhHiIlLfd"
class BadConstructorTest(unittest
.TestCase
):
def test_constructor(self
):
self
.assertRaises(TypeError, array
.array
)
self
.assertRaises(TypeError, array
.array
, spam
=42)
self
.assertRaises(TypeError, array
.array
, 'xx')
self
.assertRaises(ValueError, array
.array
, 'x')
tests
.append(BadConstructorTest
)
class BaseTest(unittest
.TestCase
):
# Required class attributes (provided by subclasses
# typecode: the typecode to test
# example: an initializer usable in the constructor for this type
# smallerexample: the same length as example, but smaller
# biggerexample: the same length as example, but bigger
# outside: An entry that is not in example
# minitemsize: the minimum guaranteed itemsize
def assertEntryEqual(self
, entry1
, entry2
):
self
.assertEqual(entry1
, entry2
)
# Return a typecode that is different from our own
return typecodes
[(typecodes
.index(self
.typecode
)+1) % len(typecodes
)]
def test_constructor(self
):
a
= array
.array(self
.typecode
)
self
.assertEqual(a
.typecode
, self
.typecode
)
self
.assert_(a
.itemsize
>=self
.minitemsize
)
self
.assertRaises(TypeError, array
.array
, self
.typecode
, None)
a
= array
.array(self
.typecode
)
a
.append(self
.example
[0])
self
.assertEqual(len(a
), 1)
a
= array
.array(self
.typecode
, self
.example
)
self
.assertEqual(len(a
), len(self
.example
))
def test_buffer_info(self
):
a
= array
.array(self
.typecode
, self
.example
)
self
.assertRaises(TypeError, a
.buffer_info
, 42)
self
.assert_(isinstance(bi
, tuple))
self
.assertEqual(len(bi
), 2)
self
.assert_(isinstance(bi
[0], int))
self
.assert_(isinstance(bi
[1], int))
self
.assertEqual(bi
[1], len(a
))
a
= array
.array(self
.typecode
, self
.example
)
self
.assertRaises(TypeError, a
.byteswap
, 42)
if a
.itemsize
in (1, 2, 4, 8):
b
= array
.array(self
.typecode
, self
.example
)
self
.assertNotEqual(a
, b
)
a
= array
.array(self
.typecode
, self
.example
)
self
.assertNotEqual(id(a
), id(b
))
a
= array
.array(self
.typecode
, self
.example
)
a
.insert(0, self
.example
[0])
self
.assertEqual(len(a
), 1+len(self
.example
))
self
.assertEqual(a
[0], a
[1])
self
.assertRaises(TypeError, a
.insert
)
self
.assertRaises(TypeError, a
.insert
, None)
self
.assertRaises(TypeError, a
.insert
, 0, None)
a
= array
.array(self
.typecode
, self
.example
)
a
.insert(-1, self
.example
[0])
self
.example
[:-1] + self
.example
[:1] + self
.example
[-1:]
a
= array
.array(self
.typecode
, self
.example
)
a
.insert(-1000, self
.example
[0])
array
.array(self
.typecode
, self
.example
[:1] + self
.example
)
a
= array
.array(self
.typecode
, self
.example
)
a
.insert(1000, self
.example
[0])
array
.array(self
.typecode
, self
.example
+ self
.example
[:1])
def test_tofromfile(self
):
a
= array
.array(self
.typecode
, 2*self
.example
)
self
.assertRaises(TypeError, a
.tofile
)
self
.assertRaises(TypeError, a
.tofile
, cStringIO
.StringIO())
f
= open(test_support
.TESTFN
, 'wb')
b
= array
.array(self
.typecode
)
f
= open(test_support
.TESTFN
, 'rb')
self
.assertRaises(TypeError, b
.fromfile
)
cStringIO
.StringIO(), len(self
.example
)
b
.fromfile(f
, len(self
.example
))
self
.assertEqual(b
, array
.array(self
.typecode
, self
.example
))
self
.assertNotEqual(a
, b
)
b
.fromfile(f
, len(self
.example
))
self
.assertRaises(EOFError, b
.fromfile
, f
, 1)
test_support
.unlink(test_support
.TESTFN
)
def test_tofromlist(self
):
a
= array
.array(self
.typecode
, 2*self
.example
)
b
= array
.array(self
.typecode
)
self
.assertRaises(TypeError, a
.tolist
, 42)
self
.assertRaises(TypeError, b
.fromlist
)
self
.assertRaises(TypeError, b
.fromlist
, 42)
self
.assertRaises(TypeError, b
.fromlist
, [None])
def test_tofromstring(self
):
a
= array
.array(self
.typecode
, 2*self
.example
)
b
= array
.array(self
.typecode
)
self
.assertRaises(TypeError, a
.tostring
, 42)
self
.assertRaises(TypeError, b
.fromstring
)
self
.assertRaises(TypeError, b
.fromstring
, 42)
b
.fromstring(a
.tostring())
self
.assertRaises(ValueError, b
.fromstring
, "x")
a
= array
.array(self
.typecode
, 2*self
.example
)
self
.assertEqual(a
, eval(repr(a
), {"array": array
.array
}))
a
= array
.array(self
.typecode
)
self
.assertEqual(repr(a
), "array('%s')" % self
.typecode
)
a
= array
.array(self
.typecode
, 2*self
.example
)
a
= array
.array(self
.typecode
, self
.example
)
self
.assert_((a
== 42) is False)
self
.assert_((a
!= 42) is True)
self
.assert_((a
== a
) is True)
self
.assert_((a
!= a
) is False)
self
.assert_((a
< a
) is False)
self
.assert_((a
<= a
) is True)
self
.assert_((a
> a
) is False)
self
.assert_((a
>= a
) is True)
as = array
.array(self
.typecode
, self
.smallerexample
)
ab
= array
.array(self
.typecode
, self
.biggerexample
)
self
.assert_((a
== 2*a
) is False)
self
.assert_((a
!= 2*a
) is True)
self
.assert_((a
< 2*a
) is True)
self
.assert_((a
<= 2*a
) is True)
self
.assert_((a
> 2*a
) is False)
self
.assert_((a
>= 2*a
) is False)
self
.assert_((a
== as) is False)
self
.assert_((a
!= as) is True)
self
.assert_((a
< as) is False)
self
.assert_((a
<= as) is False)
self
.assert_((a
> as) is True)
self
.assert_((a
>= as) is True)
self
.assert_((a
== ab
) is False)
self
.assert_((a
!= ab
) is True)
self
.assert_((a
< ab
) is True)
self
.assert_((a
<= ab
) is True)
self
.assert_((a
> ab
) is False)
self
.assert_((a
>= ab
) is False)
a
= array
.array(self
.typecode
, self
.example
) \
+ array
.array(self
.typecode
, self
.example
[::-1])
array
.array(self
.typecode
, self
.example
+ self
.example
[::-1])
b
= array
.array(self
.badtypecode())
self
.assertRaises(TypeError, a
.__add
__, b
)
self
.assertRaises(TypeError, a
.__add
__, "bad")
a
= array
.array(self
.typecode
, self
.example
[::-1])
a
+= array
.array(self
.typecode
, 2*self
.example
)
array
.array(self
.typecode
, self
.example
[::-1]+2*self
.example
)
b
= array
.array(self
.badtypecode())
self
.assertRaises(TypeError, a
.__add
__, b
)
self
.assertRaises(TypeError, a
.__iadd
__, "bad")
a
= 5*array
.array(self
.typecode
, self
.example
)
array
.array(self
.typecode
, 5*self
.example
)
a
= array
.array(self
.typecode
, self
.example
)*5
array
.array(self
.typecode
, self
.example
*5)
a
= 0*array
.array(self
.typecode
, self
.example
)
array
.array(self
.typecode
)
a
= (-1)*array
.array(self
.typecode
, self
.example
)
array
.array(self
.typecode
)
self
.assertRaises(TypeError, a
.__mul
__, "bad")
a
= array
.array(self
.typecode
, self
.example
)
array
.array(self
.typecode
, 5*self
.example
)
self
.assertEqual(a
, array
.array(self
.typecode
))
self
.assertEqual(a
, array
.array(self
.typecode
))
self
.assertEqual(a
, array
.array(self
.typecode
))
a
= array
.array(self
.typecode
, self
.example
)
self
.assertEqual(a
, array
.array(self
.typecode
))
self
.assertRaises(TypeError, a
.__imul
__, "bad")
a
= array
.array(self
.typecode
, self
.example
)
self
.assertEntryEqual(a
[0], self
.example
[0])
self
.assertEntryEqual(a
[0L], self
.example
[0])
self
.assertEntryEqual(a
[-1], self
.example
[-1])
self
.assertEntryEqual(a
[-1L], self
.example
[-1])
self
.assertEntryEqual(a
[len(self
.example
)-1], self
.example
[-1])
self
.assertEntryEqual(a
[-len(self
.example
)], self
.example
[0])
self
.assertRaises(TypeError, a
.__getitem
__)
self
.assertRaises(IndexError, a
.__getitem
__, len(self
.example
))
self
.assertRaises(IndexError, a
.__getitem
__, -len(self
.example
)-1)
a
= array
.array(self
.typecode
, self
.example
)
self
.assertEntryEqual(a
[0], a
[-1])
a
= array
.array(self
.typecode
, self
.example
)
self
.assertEntryEqual(a
[0], a
[-1])
a
= array
.array(self
.typecode
, self
.example
)
self
.assertEntryEqual(a
[0], a
[-1])
a
= array
.array(self
.typecode
, self
.example
)
self
.assertEntryEqual(a
[0], a
[-1])
a
= array
.array(self
.typecode
, self
.example
)
a
[len(self
.example
)-1] = a
[0]
self
.assertEntryEqual(a
[0], a
[-1])
a
= array
.array(self
.typecode
, self
.example
)
a
[-len(self
.example
)] = a
[-1]
self
.assertEntryEqual(a
[0], a
[-1])
self
.assertRaises(TypeError, a
.__setitem
__)
self
.assertRaises(TypeError, a
.__setitem
__, None)
self
.assertRaises(TypeError, a
.__setitem
__, 0, None)
len(self
.example
), self
.example
[0]
-len(self
.example
)-1, self
.example
[0]
a
= array
.array(self
.typecode
, self
.example
)
array
.array(self
.typecode
, self
.example
[1:])
a
= array
.array(self
.typecode
, self
.example
)
array
.array(self
.typecode
, self
.example
[:-1])
a
= array
.array(self
.typecode
, self
.example
)
del a
[len(self
.example
)-1]
array
.array(self
.typecode
, self
.example
[:-1])
a
= array
.array(self
.typecode
, self
.example
)
del a
[-len(self
.example
)]
array
.array(self
.typecode
, self
.example
[1:])
self
.assertRaises(TypeError, a
.__delitem
__)
self
.assertRaises(TypeError, a
.__delitem
__, None)
self
.assertRaises(IndexError, a
.__delitem
__, len(self
.example
))
self
.assertRaises(IndexError, a
.__delitem
__, -len(self
.example
)-1)
a
= array
.array(self
.typecode
, self
.example
)
self
.assertEqual(a
[:], a
)
array
.array(self
.typecode
, self
.example
[1:])
array
.array(self
.typecode
, self
.example
[:1])
array
.array(self
.typecode
, self
.example
[:-1])
array
.array(self
.typecode
, self
.example
[-1:])
array
.array(self
.typecode
)
array
.array(self
.typecode
)
self
.assertEqual(a
[-1000:], a
)
self
.assertEqual(a
[:1000], a
)
array
.array(self
.typecode
)
self
.assertEqual(a
[-1000:1000], a
)
array
.array(self
.typecode
)
a
= array
.array(self
.typecode
, self
.example
)
array
.array(self
.typecode
, self
.example
+ self
.example
[1:])
a
= array
.array(self
.typecode
, self
.example
)
array
.array(self
.typecode
, self
.example
+ self
.example
[-1:])
a
= array
.array(self
.typecode
, self
.example
)
array
.array(self
.typecode
, self
.example
[:-1] + self
.example
)
a
= array
.array(self
.typecode
, self
.example
)
array
.array(self
.typecode
, self
.example
[:1] + self
.example
)
a
= array
.array(self
.typecode
, self
.example
)
self
.example
[:1] + self
.example
+ self
.example
[-1:]
a
= array
.array(self
.typecode
, self
.example
)
array
.array(self
.typecode
, 2*self
.example
)
a
= array
.array(self
.typecode
, self
.example
)
array
.array(self
.typecode
, self
.example
)
a
= array
.array(self
.typecode
, self
.example
)
array
.array(self
.typecode
, self
.example
)
a
= array
.array(self
.typecode
, self
.example
)
array
.array(self
.typecode
, 2*self
.example
)
a
= array
.array(self
.typecode
, self
.example
)
array
.array(self
.typecode
, self
.example
[:1] + self
.example
+ self
.example
[1:])
a
= array
.array(self
.typecode
, self
.example
)
array
.array(self
.typecode
, 2*self
.example
)
a
= array
.array(self
.typecode
, self
.example
)
self
.assertRaises(TypeError, a
.__setslice
__, 0, 0, None)
self
.assertRaises(TypeError, a
.__setitem
__, slice(0, 1), None)
b
= array
.array(self
.badtypecode())
self
.assertRaises(TypeError, a
.__setslice
__, 0, 0, b
)
self
.assertRaises(TypeError, a
.__setitem
__, slice(0, 1), b
)
a
= array
.array(self
.typecode
, example
)
self
.assertRaises(TypeError, a
.index
)
self
.assertEqual(a
.index(x
), example
.index(x
))
self
.assertRaises(ValueError, a
.index
, None)
self
.assertRaises(ValueError, a
.index
, self
.outside
)
a
= array
.array(self
.typecode
, example
)
self
.assertRaises(TypeError, a
.count
)
self
.assertEqual(a
.count(x
), example
.count(x
))
self
.assertEqual(a
.count(self
.outside
), 0)
self
.assertEqual(a
.count(None), 0)
a
= array
.array(self
.typecode
, example
)
example2
= example
[:pos
] + example
[pos
+1:]
self
.assertEqual(a
, array
.array(self
.typecode
, example2
))
a
= array
.array(self
.typecode
, self
.example
)
self
.assertRaises(ValueError, a
.remove
, self
.outside
)
self
.assertRaises(ValueError, a
.remove
, None)
a
= array
.array(self
.typecode
)
self
.assertRaises(IndexError, a
.pop
)
a
= array
.array(self
.typecode
, 2*self
.example
)
self
.assertRaises(TypeError, a
.pop
, 42, 42)
self
.assertRaises(TypeError, a
.pop
, None)
self
.assertRaises(IndexError, a
.pop
, len(a
))
self
.assertRaises(IndexError, a
.pop
, -len(a
)-1)
self
.assertEntryEqual(a
.pop(0), self
.example
[0])
array
.array(self
.typecode
, self
.example
[1:]+self
.example
)
self
.assertEntryEqual(a
.pop(1), self
.example
[2])
array
.array(self
.typecode
, self
.example
[1:2]+self
.example
[3:]+self
.example
)
self
.assertEntryEqual(a
.pop(0), self
.example
[1])
self
.assertEntryEqual(a
.pop(), self
.example
[-1])
array
.array(self
.typecode
, self
.example
[3:]+self
.example
[:-1])
a
= array
.array(self
.typecode
, self
.example
)
self
.assertRaises(TypeError, a
.reverse
, 42)
array
.array(self
.typecode
, self
.example
[::-1])
a
= array
.array(self
.typecode
, self
.example
)
self
.assertRaises(TypeError, a
.extend
)
a
.extend(array
.array(self
.typecode
, self
.example
[::-1]))
array
.array(self
.typecode
, self
.example
+self
.example
[::-1])
b
= array
.array(self
.badtypecode())
self
.assertRaises(TypeError, a
.extend
, b
)
a
= array
.array(self
.typecode
, self
.example
)
a
.extend(self
.example
[::-1])
array
.array(self
.typecode
, self
.example
+self
.example
[::-1])
def test_constructor_with_iterable_argument(self
):
a
= array
.array(self
.typecode
, iter(self
.example
))
b
= array
.array(self
.typecode
, self
.example
)
self
.assertRaises(TypeError, array
.array
, self
.typecode
, 10)
# pass through errors raised in __iter__
self
.assertRaises(UnicodeError, array
.array
, self
.typecode
, A())
# pass through errors raised in next()
self
.assertRaises(UnicodeError, array
.array
, self
.typecode
, B())
def test_coveritertraverse(self
):
a
= array
.array(self
.typecode
)
a
= array
.array(self
.typecode
, self
.example
)
self
.assertEqual(b
[0], a
.tostring()[0])
s
= array
.array(self
.typecode
, self
.example
)
self
.assertEqual(p
.tostring(), s
.tostring())
self
.assertRaises(ReferenceError, len, p
)
def test_bug_782369(self
):
if hasattr(sys
, "getrefcount"):
b
= array
.array('B', range(64))
b
= array
.array('B', range(64))
self
.assertEqual(rc
, sys
.getrefcount(10))
class StringTest(BaseTest
):
super(StringTest
, self
).test_setitem()
a
= array
.array(self
.typecode
, self
.example
)
self
.assertRaises(TypeError, a
.__setitem
__, 0, self
.example
[:2])
class CharacterTest(StringTest
):
example
= '\x01azAZ\x00\xfe'
smallerexample
= '\x01azAY\x00\xfe'
biggerexample
= '\x01azAZ\x00\xff'
def test_subbclassing(self
):
class EditableString(array
.array
):
def __new__(cls
, s
, *args
, **kwargs
):
return array
.array
.__new
__(cls
, 'c', s
)
def __init__(self
, s
, color
='blue'):
array
.array
.__init
__(self
, 'c', s
)
self
[:] = array
.array('c', self
.tostring().strip())
return 'EditableString(%r)' % self
.tostring()
s
= EditableString("\ttest\r\n")
self
.assertEqual(s
.tostring(), "test")
self
.assertEqual(s
.color
, "blue")
self
.assertEqual(s
.color
, "red")
self
.assertEqual(s
.__dict
__.keys(), ["color"])
def test_nounicode(self
):
a
= array
.array(self
.typecode
, self
.example
)
self
.assertRaises(ValueError, a
.fromunicode
, unicode(''))
self
.assertRaises(ValueError, a
.tounicode
)
tests
.append(CharacterTest
)
if test_support
.have_unicode
:
class UnicodeTest(StringTest
):
example
= unicode(r
'\x01\u263a\x00\ufeff', 'unicode-escape')
smallerexample
= unicode(r
'\x01\u263a\x00\ufefe', 'unicode-escape')
biggerexample
= unicode(r
'\x01\u263a\x01\ufeff', 'unicode-escape')
outside
= unicode('\x33')
self
.assertRaises(TypeError, array
.array
, 'b', unicode('foo', 'ascii'))
a
= array
.array('u', unicode(r
'\xa0\xc2\u1234', 'unicode-escape'))
a
.fromunicode(unicode(' ', 'ascii'))
a
.fromunicode(unicode('', 'ascii'))
a
.fromunicode(unicode('', 'ascii'))
a
.fromunicode(unicode(r
'\x11abc\xff\u1234', 'unicode-escape'))
unicode(r
'\xa0\xc2\u1234 \x11abc\xff\u1234', 'unicode-escape')
s
= unicode(r
'\x00="\'a
\\b
\x80\xff\u0000\u0001\u1234
', 'unicode-escape
')
r"""array('u
', u'\x00="\'a\\b\x80\xff\x00\x01\u1234')"""
self.assertRaises(TypeError, a.fromunicode)
tests.append(UnicodeTest)
class NumberTest(BaseTest):
a = array.array(self.typecode, range(5))
self.assertEqual(a[::], a)
self.assertEqual(a[::2], array.array(self.typecode, [0,2,4]))
self.assertEqual(a[1::2], array.array(self.typecode, [1,3]))
self.assertEqual(a[::-1], array.array(self.typecode, [4,3,2,1,0]))
self.assertEqual(a[::-2], array.array(self.typecode, [4,2,0]))
self.assertEqual(a[3::-2], array.array(self.typecode, [3,1]))
self.assertEqual(a[-100:100:], a)
self.assertEqual(a[100:-100:-1], a[::-1])
self.assertEqual(a[-100L:100L:2L], array.array(self.typecode, [0,2,4]))
self.assertEqual(a[1000:2000:2], array.array(self.typecode, []))
self.assertEqual(a[-1000:-2000:-2], array.array(self.typecode, []))
a = array.array(self.typecode, range(5))
self.assertEqual(a, array.array(self.typecode, [1,3]))
a = array.array(self.typecode, range(5))
self.assertEqual(a, array.array(self.typecode, [0,2,4]))
a = array.array(self.typecode, range(5))
self.assertEqual(a, array.array(self.typecode, [0,2,3,4]))
a = array.array(self.typecode, range(10))
self.assertEqual(a, array.array(self.typecode, [1,2,3,4,5,6,7,8,9]))
def test_assignment(self):
a = array.array(self.typecode, range(10))
a[::2] = array.array(self.typecode, [42]*5)
self.assertEqual(a, array.array(self.typecode, [42, 1, 42, 3, 42, 5, 42, 7, 42, 9]))
a = array.array(self.typecode, range(10))
a[::-4] = array.array(self.typecode, [10]*3)
self.assertEqual(a, array.array(self.typecode, [0, 10, 2, 3, 4, 10, 6, 7, 8 ,10]))
a = array.array(self.typecode, range(4))
self.assertEqual(a, array.array(self.typecode, [3, 2, 1, 0]))
a = array.array(self.typecode, range(10))
ins = array.array(self.typecode, range(2))
def test_iterationcontains(self):
a = array.array(self.typecode, range(10))
self.assertEqual(list(a), range(10))
b = array.array(self.typecode, [20])
self.assertEqual(a[-1] in a, True)
self.assertEqual(b[0] not in a, True)
def check_overflow(self, lower, upper):
# method to be used by subclasses
# should not overflow assigning lower limit
a = array.array(self.typecode, [lower])
# should overflow assigning less than lower limit
self.assertRaises(OverflowError, array.array, self.typecode, [lower-1])
self.assertRaises(OverflowError, a.__setitem__, 0, lower-1)
# should not overflow assigning upper limit
a = array.array(self.typecode, [upper])
# should overflow assigning more than upper limit
self.assertRaises(OverflowError, array.array, self.typecode, [upper+1])
self.assertRaises(OverflowError, a.__setitem__, 0, upper+1)
def test_subclassing(self):
class ExaggeratingArray(array.array):
def __new__(cls, typecode, data, offset):
return array.array.__new__(cls, typecode, data)
def __init__(self, typecode, data, offset):
def __getitem__(self, i):
return array.array.__getitem__(self, i) + self.offset
a = ExaggeratingArray(self.typecode, [3, 6, 7, 11], 4)
self.assertEntryEqual(a[0], 7)
self.assertRaises(AttributeError, setattr, a, "color
", "blue
")
class SignedNumberTest(NumberTest):
example = [-1, 0, 1, 42, 0x7f]
smallerexample = [-1, 0, 1, 42, 0x7e]
biggerexample = [-1, 0, 1, 43, 0x7f]
a = array.array(self.typecode)
lower = -1 * long(pow(2, a.itemsize * 8 - 1))
upper = long(pow(2, a.itemsize * 8 - 1)) - 1L
self.check_overflow(lower, upper)
class UnsignedNumberTest(NumberTest):
example = [0, 1, 17, 23, 42, 0xff]
smallerexample = [0, 1, 17, 23, 42, 0xfe]
biggerexample = [0, 1, 17, 23, 43, 0xff]
a = array.array(self.typecode)
upper = long(pow(2, a.itemsize * 8)) - 1L
self.check_overflow(lower, upper)
class ByteTest(SignedNumberTest):
class UnsignedByteTest(UnsignedNumberTest):
tests.append(UnsignedByteTest)
class ShortTest(SignedNumberTest):
class UnsignedShortTest(UnsignedNumberTest):
tests.append(UnsignedShortTest)
class IntTest(SignedNumberTest):
class UnsignedIntTest(UnsignedNumberTest):
tests.append(UnsignedIntTest)
class LongTest(SignedNumberTest):
class UnsignedLongTest(UnsignedNumberTest):
tests.append(UnsignedLongTest)
class FPTest(NumberTest):
example = [-42.0, 0, 42, 1e5, -1e10]
smallerexample = [-42.0, 0, 42, 1e5, -2e10]
biggerexample = [-42.0, 0, 42, 1e5, 1e10]
def assertEntryEqual(self, entry1, entry2):
self.assertAlmostEqual(entry1, entry2)
a = array.array(self.typecode, self.example)
self.assertRaises(TypeError, a.byteswap, 42)
if a.itemsize in (1, 2, 4, 8):
b = array.array(self.typecode, self.example)
# On alphas treating the byte swapped bit patters as
# floats/doubles results in floating point exceptions
# => compare the 8bit string values instead
self.assertNotEqual(a.tostring(), b.tostring())
class DoubleTest(FPTest):
def test_main(verbose=None):
test_support.run_unittest(*tests)
# verify reference counting
if verbose and hasattr(sys, "gettotalrefcount
"):
for i in xrange(len(counts)):
test_support.run_unittest(*tests)
counts[i] = sys.gettotalrefcount()
if __name__ == "__main__
":