home *** CD-ROM | disk | FTP | other *** search
/ Maximum CD 2011 July / maximum-cd-2011-07.iso / DiscContents / LibO_3.3.2_Win_x86_install_multi.exe / libreoffice1.cab / test_array.py < prev    next >
Encoding:
Python Source  |  2011-03-15  |  33.8 KB  |  1,049 lines
  1. #! /usr/bin/env python
  2. """Test the arraymodule.
  3.    Roger E. Masse
  4. """
  5.  
  6. import unittest
  7. from test import test_support
  8. from weakref import proxy
  9. import array, cStringIO
  10. from cPickle import loads, dumps
  11.  
  12. class ArraySubclass(array.array):
  13.     pass
  14.  
  15. class ArraySubclassWithKwargs(array.array):
  16.     def __init__(self, typecode, newarg=None):
  17.         array.array.__init__(typecode)
  18.  
  19. tests = [] # list to accumulate all tests
  20. typecodes = "cubBhHiIlLfd"
  21.  
  22. class BadConstructorTest(unittest.TestCase):
  23.  
  24.     def test_constructor(self):
  25.         self.assertRaises(TypeError, array.array)
  26.         self.assertRaises(TypeError, array.array, spam=42)
  27.         self.assertRaises(TypeError, array.array, 'xx')
  28.         self.assertRaises(ValueError, array.array, 'x')
  29.  
  30. tests.append(BadConstructorTest)
  31.  
  32. class BaseTest(unittest.TestCase):
  33.     # Required class attributes (provided by subclasses
  34.     # typecode: the typecode to test
  35.     # example: an initializer usable in the constructor for this type
  36.     # smallerexample: the same length as example, but smaller
  37.     # biggerexample: the same length as example, but bigger
  38.     # outside: An entry that is not in example
  39.     # minitemsize: the minimum guaranteed itemsize
  40.  
  41.     def assertEntryEqual(self, entry1, entry2):
  42.         self.assertEqual(entry1, entry2)
  43.  
  44.     def badtypecode(self):
  45.         # Return a typecode that is different from our own
  46.         return typecodes[(typecodes.index(self.typecode)+1) % len(typecodes)]
  47.  
  48.     def test_constructor(self):
  49.         a = array.array(self.typecode)
  50.         self.assertEqual(a.typecode, self.typecode)
  51.         self.assert_(a.itemsize>=self.minitemsize)
  52.         self.assertRaises(TypeError, array.array, self.typecode, None)
  53.  
  54.     def test_len(self):
  55.         a = array.array(self.typecode)
  56.         a.append(self.example[0])
  57.         self.assertEqual(len(a), 1)
  58.  
  59.         a = array.array(self.typecode, self.example)
  60.         self.assertEqual(len(a), len(self.example))
  61.  
  62.     def test_buffer_info(self):
  63.         a = array.array(self.typecode, self.example)
  64.         self.assertRaises(TypeError, a.buffer_info, 42)
  65.         bi = a.buffer_info()
  66.         self.assert_(isinstance(bi, tuple))
  67.         self.assertEqual(len(bi), 2)
  68.         self.assert_(isinstance(bi[0], (int, long)))
  69.         self.assert_(isinstance(bi[1], int))
  70.         self.assertEqual(bi[1], len(a))
  71.  
  72.     def test_byteswap(self):
  73.         a = array.array(self.typecode, self.example)
  74.         self.assertRaises(TypeError, a.byteswap, 42)
  75.         if a.itemsize in (1, 2, 4, 8):
  76.             b = array.array(self.typecode, self.example)
  77.             b.byteswap()
  78.             if a.itemsize==1:
  79.                 self.assertEqual(a, b)
  80.             else:
  81.                 self.assertNotEqual(a, b)
  82.             b.byteswap()
  83.             self.assertEqual(a, b)
  84.  
  85.     def test_copy(self):
  86.         import copy
  87.         a = array.array(self.typecode, self.example)
  88.         b = copy.copy(a)
  89.         self.assertNotEqual(id(a), id(b))
  90.         self.assertEqual(a, b)
  91.  
  92.     def test_deepcopy(self):
  93.         import copy
  94.         a = array.array(self.typecode, self.example)
  95.         b = copy.deepcopy(a)
  96.         self.assertNotEqual(id(a), id(b))
  97.         self.assertEqual(a, b)
  98.  
  99.     def test_pickle(self):
  100.         for protocol in (0, 1, 2):
  101.             a = array.array(self.typecode, self.example)
  102.             b = loads(dumps(a, protocol))
  103.             self.assertNotEqual(id(a), id(b))
  104.             self.assertEqual(a, b)
  105.  
  106.             a = ArraySubclass(self.typecode, self.example)
  107.             a.x = 10
  108.             b = loads(dumps(a, protocol))
  109.             self.assertNotEqual(id(a), id(b))
  110.             self.assertEqual(a, b)
  111.             self.assertEqual(a.x, b.x)
  112.             self.assertEqual(type(a), type(b))
  113.  
  114.     def test_pickle_for_empty_array(self):
  115.         for protocol in (0, 1, 2):
  116.             a = array.array(self.typecode)
  117.             b = loads(dumps(a, protocol))
  118.             self.assertNotEqual(id(a), id(b))
  119.             self.assertEqual(a, b)
  120.  
  121.             a = ArraySubclass(self.typecode)
  122.             a.x = 10
  123.             b = loads(dumps(a, protocol))
  124.             self.assertNotEqual(id(a), id(b))
  125.             self.assertEqual(a, b)
  126.             self.assertEqual(a.x, b.x)
  127.             self.assertEqual(type(a), type(b))
  128.  
  129.     def test_insert(self):
  130.         a = array.array(self.typecode, self.example)
  131.         a.insert(0, self.example[0])
  132.         self.assertEqual(len(a), 1+len(self.example))
  133.         self.assertEqual(a[0], a[1])
  134.         self.assertRaises(TypeError, a.insert)
  135.         self.assertRaises(TypeError, a.insert, None)
  136.         self.assertRaises(TypeError, a.insert, 0, None)
  137.  
  138.         a = array.array(self.typecode, self.example)
  139.         a.insert(-1, self.example[0])
  140.         self.assertEqual(
  141.             a,
  142.             array.array(
  143.                 self.typecode,
  144.                 self.example[:-1] + self.example[:1] + self.example[-1:]
  145.             )
  146.         )
  147.  
  148.         a = array.array(self.typecode, self.example)
  149.         a.insert(-1000, self.example[0])
  150.         self.assertEqual(
  151.             a,
  152.             array.array(self.typecode, self.example[:1] + self.example)
  153.         )
  154.  
  155.         a = array.array(self.typecode, self.example)
  156.         a.insert(1000, self.example[0])
  157.         self.assertEqual(
  158.             a,
  159.             array.array(self.typecode, self.example + self.example[:1])
  160.         )
  161.  
  162.     def test_tofromfile(self):
  163.         a = array.array(self.typecode, 2*self.example)
  164.         self.assertRaises(TypeError, a.tofile)
  165.         self.assertRaises(TypeError, a.tofile, cStringIO.StringIO())
  166.         test_support.unlink(test_support.TESTFN)
  167.         f = open(test_support.TESTFN, 'wb')
  168.         try:
  169.             a.tofile(f)
  170.             f.close()
  171.             b = array.array(self.typecode)
  172.             f = open(test_support.TESTFN, 'rb')
  173.             self.assertRaises(TypeError, b.fromfile)
  174.             self.assertRaises(
  175.                 TypeError,
  176.                 b.fromfile,
  177.                 cStringIO.StringIO(), len(self.example)
  178.             )
  179.             b.fromfile(f, len(self.example))
  180.             self.assertEqual(b, array.array(self.typecode, self.example))
  181.             self.assertNotEqual(a, b)
  182.             b.fromfile(f, len(self.example))
  183.             self.assertEqual(a, b)
  184.             self.assertRaises(EOFError, b.fromfile, f, 1)
  185.             f.close()
  186.         finally:
  187.             if not f.closed:
  188.                 f.close()
  189.             test_support.unlink(test_support.TESTFN)
  190.  
  191.     def test_tofromlist(self):
  192.         a = array.array(self.typecode, 2*self.example)
  193.         b = array.array(self.typecode)
  194.         self.assertRaises(TypeError, a.tolist, 42)
  195.         self.assertRaises(TypeError, b.fromlist)
  196.         self.assertRaises(TypeError, b.fromlist, 42)
  197.         self.assertRaises(TypeError, b.fromlist, [None])
  198.         b.fromlist(a.tolist())
  199.         self.assertEqual(a, b)
  200.  
  201.     def test_tofromstring(self):
  202.         a = array.array(self.typecode, 2*self.example)
  203.         b = array.array(self.typecode)
  204.         self.assertRaises(TypeError, a.tostring, 42)
  205.         self.assertRaises(TypeError, b.fromstring)
  206.         self.assertRaises(TypeError, b.fromstring, 42)
  207.         b.fromstring(a.tostring())
  208.         self.assertEqual(a, b)
  209.         if a.itemsize>1:
  210.             self.assertRaises(ValueError, b.fromstring, "x")
  211.  
  212.     def test_repr(self):
  213.         a = array.array(self.typecode, 2*self.example)
  214.         self.assertEqual(a, eval(repr(a), {"array": array.array}))
  215.  
  216.         a = array.array(self.typecode)
  217.         self.assertEqual(repr(a), "array('%s')" % self.typecode)
  218.  
  219.     def test_str(self):
  220.         a = array.array(self.typecode, 2*self.example)
  221.         str(a)
  222.  
  223.     def test_cmp(self):
  224.         a = array.array(self.typecode, self.example)
  225.         self.assert_((a == 42) is False)
  226.         self.assert_((a != 42) is True)
  227.  
  228.         self.assert_((a == a) is True)
  229.         self.assert_((a != a) is False)
  230.         self.assert_((a < a) is False)
  231.         self.assert_((a <= a) is True)
  232.         self.assert_((a > a) is False)
  233.         self.assert_((a >= a) is True)
  234.  
  235.         al = array.array(self.typecode, self.smallerexample)
  236.         ab = array.array(self.typecode, self.biggerexample)
  237.  
  238.         self.assert_((a == 2*a) is False)
  239.         self.assert_((a != 2*a) is True)
  240.         self.assert_((a < 2*a) is True)
  241.         self.assert_((a <= 2*a) is True)
  242.         self.assert_((a > 2*a) is False)
  243.         self.assert_((a >= 2*a) is False)
  244.  
  245.         self.assert_((a == al) is False)
  246.         self.assert_((a != al) is True)
  247.         self.assert_((a < al) is False)
  248.         self.assert_((a <= al) is False)
  249.         self.assert_((a > al) is True)
  250.         self.assert_((a >= al) is True)
  251.  
  252.         self.assert_((a == ab) is False)
  253.         self.assert_((a != ab) is True)
  254.         self.assert_((a < ab) is True)
  255.         self.assert_((a <= ab) is True)
  256.         self.assert_((a > ab) is False)
  257.         self.assert_((a >= ab) is False)
  258.  
  259.     def test_add(self):
  260.         a = array.array(self.typecode, self.example) \
  261.             + array.array(self.typecode, self.example[::-1])
  262.         self.assertEqual(
  263.             a,
  264.             array.array(self.typecode, self.example + self.example[::-1])
  265.         )
  266.  
  267.         b = array.array(self.badtypecode())
  268.         self.assertRaises(TypeError, a.__add__, b)
  269.  
  270.         self.assertRaises(TypeError, a.__add__, "bad")
  271.  
  272.     def test_iadd(self):
  273.         a = array.array(self.typecode, self.example[::-1])
  274.         b = a
  275.         a += array.array(self.typecode, 2*self.example)
  276.         self.assert_(a is b)
  277.         self.assertEqual(
  278.             a,
  279.             array.array(self.typecode, self.example[::-1]+2*self.example)
  280.         )
  281.  
  282.         b = array.array(self.badtypecode())
  283.         self.assertRaises(TypeError, a.__add__, b)
  284.  
  285.         self.assertRaises(TypeError, a.__iadd__, "bad")
  286.  
  287.     def test_mul(self):
  288.         a = 5*array.array(self.typecode, self.example)
  289.         self.assertEqual(
  290.             a,
  291.             array.array(self.typecode, 5*self.example)
  292.         )
  293.  
  294.         a = array.array(self.typecode, self.example)*5
  295.         self.assertEqual(
  296.             a,
  297.             array.array(self.typecode, self.example*5)
  298.         )
  299.  
  300.         a = 0*array.array(self.typecode, self.example)
  301.         self.assertEqual(
  302.             a,
  303.             array.array(self.typecode)
  304.         )
  305.  
  306.         a = (-1)*array.array(self.typecode, self.example)
  307.         self.assertEqual(
  308.             a,
  309.             array.array(self.typecode)
  310.         )
  311.  
  312.         self.assertRaises(TypeError, a.__mul__, "bad")
  313.  
  314.     def test_imul(self):
  315.         a = array.array(self.typecode, self.example)
  316.         b = a
  317.  
  318.         a *= 5
  319.         self.assert_(a is b)
  320.         self.assertEqual(
  321.             a,
  322.             array.array(self.typecode, 5*self.example)
  323.         )
  324.  
  325.         a *= 0
  326.         self.assert_(a is b)
  327.         self.assertEqual(a, array.array(self.typecode))
  328.  
  329.         a *= 1000
  330.         self.assert_(a is b)
  331.         self.assertEqual(a, array.array(self.typecode))
  332.  
  333.         a *= -1
  334.         self.assert_(a is b)
  335.         self.assertEqual(a, array.array(self.typecode))
  336.  
  337.         a = array.array(self.typecode, self.example)
  338.         a *= -1
  339.         self.assertEqual(a, array.array(self.typecode))
  340.  
  341.         self.assertRaises(TypeError, a.__imul__, "bad")
  342.  
  343.     def test_getitem(self):
  344.         a = array.array(self.typecode, self.example)
  345.         self.assertEntryEqual(a[0], self.example[0])
  346.         self.assertEntryEqual(a[0L], self.example[0])
  347.         self.assertEntryEqual(a[-1], self.example[-1])
  348.         self.assertEntryEqual(a[-1L], self.example[-1])
  349.         self.assertEntryEqual(a[len(self.example)-1], self.example[-1])
  350.         self.assertEntryEqual(a[-len(self.example)], self.example[0])
  351.         self.assertRaises(TypeError, a.__getitem__)
  352.         self.assertRaises(IndexError, a.__getitem__, len(self.example))
  353.         self.assertRaises(IndexError, a.__getitem__, -len(self.example)-1)
  354.  
  355.     def test_setitem(self):
  356.         a = array.array(self.typecode, self.example)
  357.         a[0] = a[-1]
  358.         self.assertEntryEqual(a[0], a[-1])
  359.  
  360.         a = array.array(self.typecode, self.example)
  361.         a[0L] = a[-1]
  362.         self.assertEntryEqual(a[0], a[-1])
  363.  
  364.         a = array.array(self.typecode, self.example)
  365.         a[-1] = a[0]
  366.         self.assertEntryEqual(a[0], a[-1])
  367.  
  368.         a = array.array(self.typecode, self.example)
  369.         a[-1L] = a[0]
  370.         self.assertEntryEqual(a[0], a[-1])
  371.  
  372.         a = array.array(self.typecode, self.example)
  373.         a[len(self.example)-1] = a[0]
  374.         self.assertEntryEqual(a[0], a[-1])
  375.  
  376.         a = array.array(self.typecode, self.example)
  377.         a[-len(self.example)] = a[-1]
  378.         self.assertEntryEqual(a[0], a[-1])
  379.  
  380.         self.assertRaises(TypeError, a.__setitem__)
  381.         self.assertRaises(TypeError, a.__setitem__, None)
  382.         self.assertRaises(TypeError, a.__setitem__, 0, None)
  383.         self.assertRaises(
  384.             IndexError,
  385.             a.__setitem__,
  386.             len(self.example), self.example[0]
  387.         )
  388.         self.assertRaises(
  389.             IndexError,
  390.             a.__setitem__,
  391.             -len(self.example)-1, self.example[0]
  392.         )
  393.  
  394.     def test_delitem(self):
  395.         a = array.array(self.typecode, self.example)
  396.         del a[0]
  397.         self.assertEqual(
  398.             a,
  399.             array.array(self.typecode, self.example[1:])
  400.         )
  401.  
  402.         a = array.array(self.typecode, self.example)
  403.         del a[-1]
  404.         self.assertEqual(
  405.             a,
  406.             array.array(self.typecode, self.example[:-1])
  407.         )
  408.  
  409.         a = array.array(self.typecode, self.example)
  410.         del a[len(self.example)-1]
  411.         self.assertEqual(
  412.             a,
  413.             array.array(self.typecode, self.example[:-1])
  414.         )
  415.  
  416.         a = array.array(self.typecode, self.example)
  417.         del a[-len(self.example)]
  418.         self.assertEqual(
  419.             a,
  420.             array.array(self.typecode, self.example[1:])
  421.         )
  422.  
  423.         self.assertRaises(TypeError, a.__delitem__)
  424.         self.assertRaises(TypeError, a.__delitem__, None)
  425.         self.assertRaises(IndexError, a.__delitem__, len(self.example))
  426.         self.assertRaises(IndexError, a.__delitem__, -len(self.example)-1)
  427.  
  428.     def test_getslice(self):
  429.         a = array.array(self.typecode, self.example)
  430.         self.assertEqual(a[:], a)
  431.  
  432.         self.assertEqual(
  433.             a[1:],
  434.             array.array(self.typecode, self.example[1:])
  435.         )
  436.  
  437.         self.assertEqual(
  438.             a[:1],
  439.             array.array(self.typecode, self.example[:1])
  440.         )
  441.  
  442.         self.assertEqual(
  443.             a[:-1],
  444.             array.array(self.typecode, self.example[:-1])
  445.         )
  446.  
  447.         self.assertEqual(
  448.             a[-1:],
  449.             array.array(self.typecode, self.example[-1:])
  450.         )
  451.  
  452.         self.assertEqual(
  453.             a[-1:-1],
  454.             array.array(self.typecode)
  455.         )
  456.  
  457.         self.assertEqual(
  458.             a[2:1],
  459.             array.array(self.typecode)
  460.         )
  461.  
  462.         self.assertEqual(
  463.             a[1000:],
  464.             array.array(self.typecode)
  465.         )
  466.         self.assertEqual(a[-1000:], a)
  467.         self.assertEqual(a[:1000], a)
  468.         self.assertEqual(
  469.             a[:-1000],
  470.             array.array(self.typecode)
  471.         )
  472.         self.assertEqual(a[-1000:1000], a)
  473.         self.assertEqual(
  474.             a[2000:1000],
  475.             array.array(self.typecode)
  476.         )
  477.  
  478.     def test_extended_getslice(self):
  479.         # Test extended slicing by comparing with list slicing
  480.         # (Assumes list conversion works correctly, too)
  481.         a = array.array(self.typecode, self.example)
  482.         indices = (0, None, 1, 3, 19, 100, -1, -2, -31, -100)
  483.         for start in indices:
  484.             for stop in indices:
  485.                 # Everything except the initial 0 (invalid step)
  486.                 for step in indices[1:]:
  487.                     self.assertEqual(list(a[start:stop:step]),
  488.                                      list(a)[start:stop:step])
  489.  
  490.     def test_setslice(self):
  491.         a = array.array(self.typecode, self.example)
  492.         a[:1] = a
  493.         self.assertEqual(
  494.             a,
  495.             array.array(self.typecode, self.example + self.example[1:])
  496.         )
  497.  
  498.         a = array.array(self.typecode, self.example)
  499.         a[:-1] = a
  500.         self.assertEqual(
  501.             a,
  502.             array.array(self.typecode, self.example + self.example[-1:])
  503.         )
  504.  
  505.         a = array.array(self.typecode, self.example)
  506.         a[-1:] = a
  507.         self.assertEqual(
  508.             a,
  509.             array.array(self.typecode, self.example[:-1] + self.example)
  510.         )
  511.  
  512.         a = array.array(self.typecode, self.example)
  513.         a[1:] = a
  514.         self.assertEqual(
  515.             a,
  516.             array.array(self.typecode, self.example[:1] + self.example)
  517.         )
  518.  
  519.         a = array.array(self.typecode, self.example)
  520.         a[1:-1] = a
  521.         self.assertEqual(
  522.             a,
  523.             array.array(
  524.                 self.typecode,
  525.                 self.example[:1] + self.example + self.example[-1:]
  526.             )
  527.         )
  528.  
  529.         a = array.array(self.typecode, self.example)
  530.         a[1000:] = a
  531.         self.assertEqual(
  532.             a,
  533.             array.array(self.typecode, 2*self.example)
  534.         )
  535.  
  536.         a = array.array(self.typecode, self.example)
  537.         a[-1000:] = a
  538.         self.assertEqual(
  539.             a,
  540.             array.array(self.typecode, self.example)
  541.         )
  542.  
  543.         a = array.array(self.typecode, self.example)
  544.         a[:1000] = a
  545.         self.assertEqual(
  546.             a,
  547.             array.array(self.typecode, self.example)
  548.         )
  549.  
  550.         a = array.array(self.typecode, self.example)
  551.         a[:-1000] = a
  552.         self.assertEqual(
  553.             a,
  554.             array.array(self.typecode, 2*self.example)
  555.         )
  556.  
  557.         a = array.array(self.typecode, self.example)
  558.         a[1:0] = a
  559.         self.assertEqual(
  560.             a,
  561.             array.array(self.typecode, self.example[:1] + self.example + self.example[1:])
  562.         )
  563.  
  564.         a = array.array(self.typecode, self.example)
  565.         a[2000:1000] = a
  566.         self.assertEqual(
  567.             a,
  568.             array.array(self.typecode, 2*self.example)
  569.         )
  570.  
  571.         a = array.array(self.typecode, self.example)
  572.         self.assertRaises(TypeError, a.__setslice__, 0, 0, None)
  573.         self.assertRaises(TypeError, a.__setitem__, slice(0, 0), None)
  574.         self.assertRaises(TypeError, a.__setitem__, slice(0, 1), None)
  575.  
  576.         b = array.array(self.badtypecode())
  577.         self.assertRaises(TypeError, a.__setslice__, 0, 0, b)
  578.         self.assertRaises(TypeError, a.__setitem__, slice(0, 0), b)
  579.         self.assertRaises(TypeError, a.__setitem__, slice(0, 1), b)
  580.  
  581.     def test_extended_set_del_slice(self):
  582.         indices = (0, None, 1, 3, 19, 100, -1, -2, -31, -100)
  583.         for start in indices:
  584.             for stop in indices:
  585.                 # Everything except the initial 0 (invalid step)
  586.                 for step in indices[1:]:
  587.                     a = array.array(self.typecode, self.example)
  588.                     L = list(a)
  589.                     # Make sure we have a slice of exactly the right length,
  590.                     # but with (hopefully) different data.
  591.                     data = L[start:stop:step]
  592.                     data.reverse()
  593.                     L[start:stop:step] = data
  594.                     a[start:stop:step] = array.array(self.typecode, data)
  595.                     self.assertEquals(a, array.array(self.typecode, L))
  596.  
  597.                     del L[start:stop:step]
  598.                     del a[start:stop:step]
  599.                     self.assertEquals(a, array.array(self.typecode, L))
  600.  
  601.     def test_index(self):
  602.         example = 2*self.example
  603.         a = array.array(self.typecode, example)
  604.         self.assertRaises(TypeError, a.index)
  605.         for x in example:
  606.             self.assertEqual(a.index(x), example.index(x))
  607.         self.assertRaises(ValueError, a.index, None)
  608.         self.assertRaises(ValueError, a.index, self.outside)
  609.  
  610.     def test_count(self):
  611.         example = 2*self.example
  612.         a = array.array(self.typecode, example)
  613.         self.assertRaises(TypeError, a.count)
  614.         for x in example:
  615.             self.assertEqual(a.count(x), example.count(x))
  616.         self.assertEqual(a.count(self.outside), 0)
  617.         self.assertEqual(a.count(None), 0)
  618.  
  619.     def test_remove(self):
  620.         for x in self.example:
  621.             example = 2*self.example
  622.             a = array.array(self.typecode, example)
  623.             pos = example.index(x)
  624.             example2 = example[:pos] + example[pos+1:]
  625.             a.remove(x)
  626.             self.assertEqual(a, array.array(self.typecode, example2))
  627.  
  628.         a = array.array(self.typecode, self.example)
  629.         self.assertRaises(ValueError, a.remove, self.outside)
  630.  
  631.         self.assertRaises(ValueError, a.remove, None)
  632.  
  633.     def test_pop(self):
  634.         a = array.array(self.typecode)
  635.         self.assertRaises(IndexError, a.pop)
  636.  
  637.         a = array.array(self.typecode, 2*self.example)
  638.         self.assertRaises(TypeError, a.pop, 42, 42)
  639.         self.assertRaises(TypeError, a.pop, None)
  640.         self.assertRaises(IndexError, a.pop, len(a))
  641.         self.assertRaises(IndexError, a.pop, -len(a)-1)
  642.  
  643.         self.assertEntryEqual(a.pop(0), self.example[0])
  644.         self.assertEqual(
  645.             a,
  646.             array.array(self.typecode, self.example[1:]+self.example)
  647.         )
  648.         self.assertEntryEqual(a.pop(1), self.example[2])
  649.         self.assertEqual(
  650.             a,
  651.             array.array(self.typecode, self.example[1:2]+self.example[3:]+self.example)
  652.         )
  653.         self.assertEntryEqual(a.pop(0), self.example[1])
  654.         self.assertEntryEqual(a.pop(), self.example[-1])
  655.         self.assertEqual(
  656.             a,
  657.             array.array(self.typecode, self.example[3:]+self.example[:-1])
  658.         )
  659.  
  660.     def test_reverse(self):
  661.         a = array.array(self.typecode, self.example)
  662.         self.assertRaises(TypeError, a.reverse, 42)
  663.         a.reverse()
  664.         self.assertEqual(
  665.             a,
  666.             array.array(self.typecode, self.example[::-1])
  667.         )
  668.  
  669.     def test_extend(self):
  670.         a = array.array(self.typecode, self.example)
  671.         self.assertRaises(TypeError, a.extend)
  672.         a.extend(array.array(self.typecode, self.example[::-1]))
  673.         self.assertEqual(
  674.             a,
  675.             array.array(self.typecode, self.example+self.example[::-1])
  676.         )
  677.  
  678.         b = array.array(self.badtypecode())
  679.         self.assertRaises(TypeError, a.extend, b)
  680.  
  681.         a = array.array(self.typecode, self.example)
  682.         a.extend(self.example[::-1])
  683.         self.assertEqual(
  684.             a,
  685.             array.array(self.typecode, self.example+self.example[::-1])
  686.         )
  687.  
  688.     def test_constructor_with_iterable_argument(self):
  689.         a = array.array(self.typecode, iter(self.example))
  690.         b = array.array(self.typecode, self.example)
  691.         self.assertEqual(a, b)
  692.  
  693.         # non-iterable argument
  694.         self.assertRaises(TypeError, array.array, self.typecode, 10)
  695.  
  696.         # pass through errors raised in __iter__
  697.         class A:
  698.             def __iter__(self):
  699.                 raise UnicodeError
  700.         self.assertRaises(UnicodeError, array.array, self.typecode, A())
  701.  
  702.         # pass through errors raised in next()
  703.         def B():
  704.             raise UnicodeError
  705.             yield None
  706.         self.assertRaises(UnicodeError, array.array, self.typecode, B())
  707.  
  708.     def test_coveritertraverse(self):
  709.         try:
  710.             import gc
  711.         except ImportError:
  712.             return
  713.         a = array.array(self.typecode)
  714.         l = [iter(a)]
  715.         l.append(l)
  716.         gc.collect()
  717.  
  718.     def test_buffer(self):
  719.         a = array.array(self.typecode, self.example)
  720.         b = buffer(a)
  721.         self.assertEqual(b[0], a.tostring()[0])
  722.  
  723.     def test_weakref(self):
  724.         s = array.array(self.typecode, self.example)
  725.         p = proxy(s)
  726.         self.assertEqual(p.tostring(), s.tostring())
  727.         s = None
  728.         self.assertRaises(ReferenceError, len, p)
  729.  
  730.     def test_bug_782369(self):
  731.         import sys
  732.         if hasattr(sys, "getrefcount"):
  733.             for i in range(10):
  734.                 b = array.array('B', range(64))
  735.             rc = sys.getrefcount(10)
  736.             for i in range(10):
  737.                 b = array.array('B', range(64))
  738.             self.assertEqual(rc, sys.getrefcount(10))
  739.  
  740.     def test_subclass_with_kwargs(self):
  741.         # SF bug #1486663 -- this used to erroneously raise a TypeError
  742.         ArraySubclassWithKwargs('b', newarg=1)
  743.  
  744.  
  745. class StringTest(BaseTest):
  746.  
  747.     def test_setitem(self):
  748.         super(StringTest, self).test_setitem()
  749.         a = array.array(self.typecode, self.example)
  750.         self.assertRaises(TypeError, a.__setitem__, 0, self.example[:2])
  751.  
  752. class CharacterTest(StringTest):
  753.     typecode = 'c'
  754.     example = '\x01azAZ\x00\xfe'
  755.     smallerexample = '\x01azAY\x00\xfe'
  756.     biggerexample = '\x01azAZ\x00\xff'
  757.     outside = '\x33'
  758.     minitemsize = 1
  759.  
  760.     def test_subbclassing(self):
  761.         class EditableString(array.array):
  762.             def __new__(cls, s, *args, **kwargs):
  763.                 return array.array.__new__(cls, 'c', s)
  764.  
  765.             def __init__(self, s, color='blue'):
  766.                 self.color = color
  767.  
  768.             def strip(self):
  769.                 self[:] = array.array('c', self.tostring().strip())
  770.  
  771.             def __repr__(self):
  772.                 return 'EditableString(%r)' % self.tostring()
  773.  
  774.         s = EditableString("\ttest\r\n")
  775.         s.strip()
  776.         self.assertEqual(s.tostring(), "test")
  777.  
  778.         self.assertEqual(s.color, "blue")
  779.         s.color = "red"
  780.         self.assertEqual(s.color, "red")
  781.         self.assertEqual(s.__dict__.keys(), ["color"])
  782.  
  783.     def test_nounicode(self):
  784.         a = array.array(self.typecode, self.example)
  785.         self.assertRaises(ValueError, a.fromunicode, unicode(''))
  786.         self.assertRaises(ValueError, a.tounicode)
  787.  
  788. tests.append(CharacterTest)
  789.  
  790. if test_support.have_unicode:
  791.     class UnicodeTest(StringTest):
  792.         typecode = 'u'
  793.         example = unicode(r'\x01\u263a\x00\ufeff', 'unicode-escape')
  794.         smallerexample = unicode(r'\x01\u263a\x00\ufefe', 'unicode-escape')
  795.         biggerexample = unicode(r'\x01\u263a\x01\ufeff', 'unicode-escape')
  796.         outside = unicode('\x33')
  797.         minitemsize = 2
  798.  
  799.         def test_unicode(self):
  800.             self.assertRaises(TypeError, array.array, 'b', unicode('foo', 'ascii'))
  801.  
  802.             a = array.array('u', unicode(r'\xa0\xc2\u1234', 'unicode-escape'))
  803.             a.fromunicode(unicode(' ', 'ascii'))
  804.             a.fromunicode(unicode('', 'ascii'))
  805.             a.fromunicode(unicode('', 'ascii'))
  806.             a.fromunicode(unicode(r'\x11abc\xff\u1234', 'unicode-escape'))
  807.             s = a.tounicode()
  808.             self.assertEqual(
  809.                 s,
  810.                 unicode(r'\xa0\xc2\u1234 \x11abc\xff\u1234', 'unicode-escape')
  811.             )
  812.  
  813.             s = unicode(r'\x00="\'a\\b\x80\xff\u0000\u0001\u1234', 'unicode-escape')
  814.             a = array.array('u', s)
  815.             self.assertEqual(
  816.                 repr(a),
  817.                 r"""array('u', u'\x00="\'a\\b\x80\xff\x00\x01\u1234')"""
  818.             )
  819.  
  820.             self.assertRaises(TypeError, a.fromunicode)
  821.  
  822.     tests.append(UnicodeTest)
  823.  
  824. class NumberTest(BaseTest):
  825.  
  826.     def test_extslice(self):
  827.         a = array.array(self.typecode, range(5))
  828.         self.assertEqual(a[::], a)
  829.         self.assertEqual(a[::2], array.array(self.typecode, [0,2,4]))
  830.         self.assertEqual(a[1::2], array.array(self.typecode, [1,3]))
  831.         self.assertEqual(a[::-1], array.array(self.typecode, [4,3,2,1,0]))
  832.         self.assertEqual(a[::-2], array.array(self.typecode, [4,2,0]))
  833.         self.assertEqual(a[3::-2], array.array(self.typecode, [3,1]))
  834.         self.assertEqual(a[-100:100:], a)
  835.         self.assertEqual(a[100:-100:-1], a[::-1])
  836.         self.assertEqual(a[-100L:100L:2L], array.array(self.typecode, [0,2,4]))
  837.         self.assertEqual(a[1000:2000:2], array.array(self.typecode, []))
  838.         self.assertEqual(a[-1000:-2000:-2], array.array(self.typecode, []))
  839.  
  840.     def test_delslice(self):
  841.         a = array.array(self.typecode, range(5))
  842.         del a[::2]
  843.         self.assertEqual(a, array.array(self.typecode, [1,3]))
  844.         a = array.array(self.typecode, range(5))
  845.         del a[1::2]
  846.         self.assertEqual(a, array.array(self.typecode, [0,2,4]))
  847.         a = array.array(self.typecode, range(5))
  848.         del a[1::-2]
  849.         self.assertEqual(a, array.array(self.typecode, [0,2,3,4]))
  850.         a = array.array(self.typecode, range(10))
  851.         del a[::1000]
  852.         self.assertEqual(a, array.array(self.typecode, [1,2,3,4,5,6,7,8,9]))
  853.  
  854.     def test_assignment(self):
  855.         a = array.array(self.typecode, range(10))
  856.         a[::2] = array.array(self.typecode, [42]*5)
  857.         self.assertEqual(a, array.array(self.typecode, [42, 1, 42, 3, 42, 5, 42, 7, 42, 9]))
  858.         a = array.array(self.typecode, range(10))
  859.         a[::-4] = array.array(self.typecode, [10]*3)
  860.         self.assertEqual(a, array.array(self.typecode, [0, 10, 2, 3, 4, 10, 6, 7, 8 ,10]))
  861.         a = array.array(self.typecode, range(4))
  862.         a[::-1] = a
  863.         self.assertEqual(a, array.array(self.typecode, [3, 2, 1, 0]))
  864.         a = array.array(self.typecode, range(10))
  865.         b = a[:]
  866.         c = a[:]
  867.         ins = array.array(self.typecode, range(2))
  868.         a[2:3] = ins
  869.         b[slice(2,3)] = ins
  870.         c[2:3:] = ins
  871.  
  872.     def test_iterationcontains(self):
  873.         a = array.array(self.typecode, range(10))
  874.         self.assertEqual(list(a), range(10))
  875.         b = array.array(self.typecode, [20])
  876.         self.assertEqual(a[-1] in a, True)
  877.         self.assertEqual(b[0] not in a, True)
  878.  
  879.     def check_overflow(self, lower, upper):
  880.         # method to be used by subclasses
  881.  
  882.         # should not overflow assigning lower limit
  883.         a = array.array(self.typecode, [lower])
  884.         a[0] = lower
  885.         # should overflow assigning less than lower limit
  886.         self.assertRaises(OverflowError, array.array, self.typecode, [lower-1])
  887.         self.assertRaises(OverflowError, a.__setitem__, 0, lower-1)
  888.         # should not overflow assigning upper limit
  889.         a = array.array(self.typecode, [upper])
  890.         a[0] = upper
  891.         # should overflow assigning more than upper limit
  892.         self.assertRaises(OverflowError, array.array, self.typecode, [upper+1])
  893.         self.assertRaises(OverflowError, a.__setitem__, 0, upper+1)
  894.  
  895.     def test_subclassing(self):
  896.         typecode = self.typecode
  897.         class ExaggeratingArray(array.array):
  898.             __slots__ = ['offset']
  899.  
  900.             def __new__(cls, typecode, data, offset):
  901.                 return array.array.__new__(cls, typecode, data)
  902.  
  903.             def __init__(self, typecode, data, offset):
  904.                 self.offset = offset
  905.  
  906.             def __getitem__(self, i):
  907.                 return array.array.__getitem__(self, i) + self.offset
  908.  
  909.         a = ExaggeratingArray(self.typecode, [3, 6, 7, 11], 4)
  910.         self.assertEntryEqual(a[0], 7)
  911.  
  912.         self.assertRaises(AttributeError, setattr, a, "color", "blue")
  913.  
  914. class SignedNumberTest(NumberTest):
  915.     example = [-1, 0, 1, 42, 0x7f]
  916.     smallerexample = [-1, 0, 1, 42, 0x7e]
  917.     biggerexample = [-1, 0, 1, 43, 0x7f]
  918.     outside = 23
  919.  
  920.     def test_overflow(self):
  921.         a = array.array(self.typecode)
  922.         lower = -1 * long(pow(2, a.itemsize * 8 - 1))
  923.         upper = long(pow(2, a.itemsize * 8 - 1)) - 1L
  924.         self.check_overflow(lower, upper)
  925.  
  926. class UnsignedNumberTest(NumberTest):
  927.     example = [0, 1, 17, 23, 42, 0xff]
  928.     smallerexample = [0, 1, 17, 23, 42, 0xfe]
  929.     biggerexample = [0, 1, 17, 23, 43, 0xff]
  930.     outside = 0xaa
  931.  
  932.     def test_overflow(self):
  933.         a = array.array(self.typecode)
  934.         lower = 0
  935.         upper = long(pow(2, a.itemsize * 8)) - 1L
  936.         self.check_overflow(lower, upper)
  937.  
  938.  
  939. class ByteTest(SignedNumberTest):
  940.     typecode = 'b'
  941.     minitemsize = 1
  942. tests.append(ByteTest)
  943.  
  944. class UnsignedByteTest(UnsignedNumberTest):
  945.     typecode = 'B'
  946.     minitemsize = 1
  947. tests.append(UnsignedByteTest)
  948.  
  949. class ShortTest(SignedNumberTest):
  950.     typecode = 'h'
  951.     minitemsize = 2
  952. tests.append(ShortTest)
  953.  
  954. class UnsignedShortTest(UnsignedNumberTest):
  955.     typecode = 'H'
  956.     minitemsize = 2
  957. tests.append(UnsignedShortTest)
  958.  
  959. class IntTest(SignedNumberTest):
  960.     typecode = 'i'
  961.     minitemsize = 2
  962. tests.append(IntTest)
  963.  
  964. class UnsignedIntTest(UnsignedNumberTest):
  965.     typecode = 'I'
  966.     minitemsize = 2
  967. tests.append(UnsignedIntTest)
  968.  
  969. class LongTest(SignedNumberTest):
  970.     typecode = 'l'
  971.     minitemsize = 4
  972. tests.append(LongTest)
  973.  
  974. class UnsignedLongTest(UnsignedNumberTest):
  975.     typecode = 'L'
  976.     minitemsize = 4
  977. tests.append(UnsignedLongTest)
  978.  
  979. class FPTest(NumberTest):
  980.     example = [-42.0, 0, 42, 1e5, -1e10]
  981.     smallerexample = [-42.0, 0, 42, 1e5, -2e10]
  982.     biggerexample = [-42.0, 0, 42, 1e5, 1e10]
  983.     outside = 23
  984.  
  985.     def assertEntryEqual(self, entry1, entry2):
  986.         self.assertAlmostEqual(entry1, entry2)
  987.  
  988.     def test_byteswap(self):
  989.         a = array.array(self.typecode, self.example)
  990.         self.assertRaises(TypeError, a.byteswap, 42)
  991.         if a.itemsize in (1, 2, 4, 8):
  992.             b = array.array(self.typecode, self.example)
  993.             b.byteswap()
  994.             if a.itemsize==1:
  995.                 self.assertEqual(a, b)
  996.             else:
  997.                 # On alphas treating the byte swapped bit patters as
  998.                 # floats/doubles results in floating point exceptions
  999.                 # => compare the 8bit string values instead
  1000.                 self.assertNotEqual(a.tostring(), b.tostring())
  1001.             b.byteswap()
  1002.             self.assertEqual(a, b)
  1003.  
  1004. class FloatTest(FPTest):
  1005.     typecode = 'f'
  1006.     minitemsize = 4
  1007. tests.append(FloatTest)
  1008.  
  1009. class DoubleTest(FPTest):
  1010.     typecode = 'd'
  1011.     minitemsize = 8
  1012.  
  1013.     def test_alloc_overflow(self):
  1014.         from sys import maxsize
  1015.         a = array.array('d', [-1]*65536)
  1016.         try:
  1017.             a *= maxsize//65536 + 1
  1018.         except MemoryError:
  1019.             pass
  1020.         else:
  1021.             self.fail("Array of size > maxsize created - MemoryError expected")
  1022.         b = array.array('d', [ 2.71828183, 3.14159265, -1])
  1023.         try:
  1024.             b * (maxsize//3 + 1)
  1025.         except MemoryError:
  1026.             pass
  1027.         else:
  1028.             self.fail("Array of size > maxsize created - MemoryError expected")
  1029.  
  1030. tests.append(DoubleTest)
  1031.  
  1032. def test_main(verbose=None):
  1033.     import sys
  1034.  
  1035.     test_support.run_unittest(*tests)
  1036.  
  1037.     # verify reference counting
  1038.     if verbose and hasattr(sys, "gettotalrefcount"):
  1039.         import gc
  1040.         counts = [None] * 5
  1041.         for i in xrange(len(counts)):
  1042.             test_support.run_unittest(*tests)
  1043.             gc.collect()
  1044.             counts[i] = sys.gettotalrefcount()
  1045.         print counts
  1046.  
  1047. if __name__ == "__main__":
  1048.     test_main(verbose=True)
  1049.