home *** CD-ROM | disk | FTP | other *** search
/ Maximum CD 2011 June / maximum-cd-2011-06.iso / DiscContents / LibO_3.3.1_Win_x86_install_multi.exe / libreoffice1.cab / test_operator.py < prev    next >
Encoding:
Python Source  |  2011-02-15  |  21.0 KB  |  530 lines
  1. import operator
  2. import unittest
  3.  
  4. from test import test_support
  5.  
  6. class Seq1:
  7.     def __init__(self, lst):
  8.         self.lst = lst
  9.     def __len__(self):
  10.         return len(self.lst)
  11.     def __getitem__(self, i):
  12.         return self.lst[i]
  13.     def __add__(self, other):
  14.         return self.lst + other.lst
  15.     def __mul__(self, other):
  16.         return self.lst * other
  17.     def __rmul__(self, other):
  18.         return other * self.lst
  19.  
  20. class Seq2(object):
  21.     def __init__(self, lst):
  22.         self.lst = lst
  23.     def __len__(self):
  24.         return len(self.lst)
  25.     def __getitem__(self, i):
  26.         return self.lst[i]
  27.     def __add__(self, other):
  28.         return self.lst + other.lst
  29.     def __mul__(self, other):
  30.         return self.lst * other
  31.     def __rmul__(self, other):
  32.         return other * self.lst
  33.  
  34.  
  35. class OperatorTestCase(unittest.TestCase):
  36.     def test_lt(self):
  37.         self.failUnlessRaises(TypeError, operator.lt)
  38.         self.failUnlessRaises(TypeError, operator.lt, 1j, 2j)
  39.         self.failIf(operator.lt(1, 0))
  40.         self.failIf(operator.lt(1, 0.0))
  41.         self.failIf(operator.lt(1, 1))
  42.         self.failIf(operator.lt(1, 1.0))
  43.         self.failUnless(operator.lt(1, 2))
  44.         self.failUnless(operator.lt(1, 2.0))
  45.  
  46.     def test_le(self):
  47.         self.failUnlessRaises(TypeError, operator.le)
  48.         self.failUnlessRaises(TypeError, operator.le, 1j, 2j)
  49.         self.failIf(operator.le(1, 0))
  50.         self.failIf(operator.le(1, 0.0))
  51.         self.failUnless(operator.le(1, 1))
  52.         self.failUnless(operator.le(1, 1.0))
  53.         self.failUnless(operator.le(1, 2))
  54.         self.failUnless(operator.le(1, 2.0))
  55.  
  56.     def test_eq(self):
  57.         class C(object):
  58.             def __eq__(self, other):
  59.                 raise SyntaxError
  60.             __hash__ = None # Silence Py3k warning
  61.         self.failUnlessRaises(TypeError, operator.eq)
  62.         self.failUnlessRaises(SyntaxError, operator.eq, C(), C())
  63.         self.failIf(operator.eq(1, 0))
  64.         self.failIf(operator.eq(1, 0.0))
  65.         self.failUnless(operator.eq(1, 1))
  66.         self.failUnless(operator.eq(1, 1.0))
  67.         self.failIf(operator.eq(1, 2))
  68.         self.failIf(operator.eq(1, 2.0))
  69.  
  70.     def test_ne(self):
  71.         class C(object):
  72.             def __ne__(self, other):
  73.                 raise SyntaxError
  74.         self.failUnlessRaises(TypeError, operator.ne)
  75.         self.failUnlessRaises(SyntaxError, operator.ne, C(), C())
  76.         self.failUnless(operator.ne(1, 0))
  77.         self.failUnless(operator.ne(1, 0.0))
  78.         self.failIf(operator.ne(1, 1))
  79.         self.failIf(operator.ne(1, 1.0))
  80.         self.failUnless(operator.ne(1, 2))
  81.         self.failUnless(operator.ne(1, 2.0))
  82.  
  83.     def test_ge(self):
  84.         self.failUnlessRaises(TypeError, operator.ge)
  85.         self.failUnlessRaises(TypeError, operator.ge, 1j, 2j)
  86.         self.failUnless(operator.ge(1, 0))
  87.         self.failUnless(operator.ge(1, 0.0))
  88.         self.failUnless(operator.ge(1, 1))
  89.         self.failUnless(operator.ge(1, 1.0))
  90.         self.failIf(operator.ge(1, 2))
  91.         self.failIf(operator.ge(1, 2.0))
  92.  
  93.     def test_gt(self):
  94.         self.failUnlessRaises(TypeError, operator.gt)
  95.         self.failUnlessRaises(TypeError, operator.gt, 1j, 2j)
  96.         self.failUnless(operator.gt(1, 0))
  97.         self.failUnless(operator.gt(1, 0.0))
  98.         self.failIf(operator.gt(1, 1))
  99.         self.failIf(operator.gt(1, 1.0))
  100.         self.failIf(operator.gt(1, 2))
  101.         self.failIf(operator.gt(1, 2.0))
  102.  
  103.     def test_abs(self):
  104.         self.failUnlessRaises(TypeError, operator.abs)
  105.         self.failUnlessRaises(TypeError, operator.abs, None)
  106.         self.failUnless(operator.abs(-1) == 1)
  107.         self.failUnless(operator.abs(1) == 1)
  108.  
  109.     def test_add(self):
  110.         self.failUnlessRaises(TypeError, operator.add)
  111.         self.failUnlessRaises(TypeError, operator.add, None, None)
  112.         self.failUnless(operator.add(3, 4) == 7)
  113.  
  114.     def test_bitwise_and(self):
  115.         self.failUnlessRaises(TypeError, operator.and_)
  116.         self.failUnlessRaises(TypeError, operator.and_, None, None)
  117.         self.failUnless(operator.and_(0xf, 0xa) == 0xa)
  118.  
  119.     def test_concat(self):
  120.         self.failUnlessRaises(TypeError, operator.concat)
  121.         self.failUnlessRaises(TypeError, operator.concat, None, None)
  122.         self.failUnless(operator.concat('py', 'thon') == 'python')
  123.         self.failUnless(operator.concat([1, 2], [3, 4]) == [1, 2, 3, 4])
  124.         self.failUnless(operator.concat(Seq1([5, 6]), Seq1([7])) == [5, 6, 7])
  125.         self.failUnless(operator.concat(Seq2([5, 6]), Seq2([7])) == [5, 6, 7])
  126.         self.failUnlessRaises(TypeError, operator.concat, 13, 29)
  127.  
  128.     def test_countOf(self):
  129.         self.failUnlessRaises(TypeError, operator.countOf)
  130.         self.failUnlessRaises(TypeError, operator.countOf, None, None)
  131.         self.failUnless(operator.countOf([1, 2, 1, 3, 1, 4], 3) == 1)
  132.         self.failUnless(operator.countOf([1, 2, 1, 3, 1, 4], 5) == 0)
  133.  
  134.     def test_delitem(self):
  135.         a = [4, 3, 2, 1]
  136.         self.failUnlessRaises(TypeError, operator.delitem, a)
  137.         self.failUnlessRaises(TypeError, operator.delitem, a, None)
  138.         self.failUnless(operator.delitem(a, 1) is None)
  139.         self.assert_(a == [4, 2, 1])
  140.  
  141.     def test_delslice(self):
  142.         a = range(10)
  143.         self.failUnlessRaises(TypeError, operator.delslice, a)
  144.         self.failUnlessRaises(TypeError, operator.delslice, a, None, None)
  145.         self.failUnless(operator.delslice(a, 2, 8) is None)
  146.         self.assert_(a == [0, 1, 8, 9])
  147.         operator.delslice(a, 0, test_support.MAX_Py_ssize_t)
  148.         self.assert_(a == [])
  149.  
  150.     def test_div(self):
  151.         self.failUnlessRaises(TypeError, operator.div, 5)
  152.         self.failUnlessRaises(TypeError, operator.div, None, None)
  153.         self.failUnless(operator.floordiv(5, 2) == 2)
  154.  
  155.     def test_floordiv(self):
  156.         self.failUnlessRaises(TypeError, operator.floordiv, 5)
  157.         self.failUnlessRaises(TypeError, operator.floordiv, None, None)
  158.         self.failUnless(operator.floordiv(5, 2) == 2)
  159.  
  160.     def test_truediv(self):
  161.         self.failUnlessRaises(TypeError, operator.truediv, 5)
  162.         self.failUnlessRaises(TypeError, operator.truediv, None, None)
  163.         self.failUnless(operator.truediv(5, 2) == 2.5)
  164.  
  165.     def test_getitem(self):
  166.         a = range(10)
  167.         self.failUnlessRaises(TypeError, operator.getitem)
  168.         self.failUnlessRaises(TypeError, operator.getitem, a, None)
  169.         self.failUnless(operator.getitem(a, 2) == 2)
  170.  
  171.     def test_getslice(self):
  172.         a = range(10)
  173.         self.failUnlessRaises(TypeError, operator.getslice)
  174.         self.failUnlessRaises(TypeError, operator.getslice, a, None, None)
  175.         self.failUnless(operator.getslice(a, 4, 6) == [4, 5])
  176.         b = operator.getslice(a, 0, test_support.MAX_Py_ssize_t)
  177.         self.assert_(b == a)
  178.  
  179.     def test_indexOf(self):
  180.         self.failUnlessRaises(TypeError, operator.indexOf)
  181.         self.failUnlessRaises(TypeError, operator.indexOf, None, None)
  182.         self.failUnless(operator.indexOf([4, 3, 2, 1], 3) == 1)
  183.         self.assertRaises(ValueError, operator.indexOf, [4, 3, 2, 1], 0)
  184.  
  185.     def test_invert(self):
  186.         self.failUnlessRaises(TypeError, operator.invert)
  187.         self.failUnlessRaises(TypeError, operator.invert, None)
  188.         self.failUnless(operator.inv(4) == -5)
  189.  
  190.     def test_isCallable(self):
  191.         self.failUnlessRaises(TypeError, operator.isCallable)
  192.         class C:
  193.             pass
  194.         def check(self, o, v):
  195.             self.assert_(operator.isCallable(o) == callable(o) == v)
  196.         check(self, 4, 0)
  197.         check(self, operator.isCallable, 1)
  198.         check(self, C, 1)
  199.         check(self, C(), 0)
  200.  
  201.     def test_isMappingType(self):
  202.         self.failUnlessRaises(TypeError, operator.isMappingType)
  203.         self.failIf(operator.isMappingType(1))
  204.         self.failIf(operator.isMappingType(operator.isMappingType))
  205.         self.failUnless(operator.isMappingType(operator.__dict__))
  206.         self.failUnless(operator.isMappingType({}))
  207.  
  208.     def test_isNumberType(self):
  209.         self.failUnlessRaises(TypeError, operator.isNumberType)
  210.         self.failUnless(operator.isNumberType(8))
  211.         self.failUnless(operator.isNumberType(8j))
  212.         self.failUnless(operator.isNumberType(8L))
  213.         self.failUnless(operator.isNumberType(8.3))
  214.         self.failIf(operator.isNumberType(dir()))
  215.  
  216.     def test_isSequenceType(self):
  217.         self.failUnlessRaises(TypeError, operator.isSequenceType)
  218.         self.failUnless(operator.isSequenceType(dir()))
  219.         self.failUnless(operator.isSequenceType(()))
  220.         self.failUnless(operator.isSequenceType(xrange(10)))
  221.         self.failUnless(operator.isSequenceType('yeahbuddy'))
  222.         self.failIf(operator.isSequenceType(3))
  223.         class Dict(dict): pass
  224.         self.failIf(operator.isSequenceType(Dict()))
  225.  
  226.     def test_lshift(self):
  227.         self.failUnlessRaises(TypeError, operator.lshift)
  228.         self.failUnlessRaises(TypeError, operator.lshift, None, 42)
  229.         self.failUnless(operator.lshift(5, 1) == 10)
  230.         self.failUnless(operator.lshift(5, 0) == 5)
  231.         self.assertRaises(ValueError, operator.lshift, 2, -1)
  232.  
  233.     def test_mod(self):
  234.         self.failUnlessRaises(TypeError, operator.mod)
  235.         self.failUnlessRaises(TypeError, operator.mod, None, 42)
  236.         self.failUnless(operator.mod(5, 2) == 1)
  237.  
  238.     def test_mul(self):
  239.         self.failUnlessRaises(TypeError, operator.mul)
  240.         self.failUnlessRaises(TypeError, operator.mul, None, None)
  241.         self.failUnless(operator.mul(5, 2) == 10)
  242.  
  243.     def test_neg(self):
  244.         self.failUnlessRaises(TypeError, operator.neg)
  245.         self.failUnlessRaises(TypeError, operator.neg, None)
  246.         self.failUnless(operator.neg(5) == -5)
  247.         self.failUnless(operator.neg(-5) == 5)
  248.         self.failUnless(operator.neg(0) == 0)
  249.         self.failUnless(operator.neg(-0) == 0)
  250.  
  251.     def test_bitwise_or(self):
  252.         self.failUnlessRaises(TypeError, operator.or_)
  253.         self.failUnlessRaises(TypeError, operator.or_, None, None)
  254.         self.failUnless(operator.or_(0xa, 0x5) == 0xf)
  255.  
  256.     def test_pos(self):
  257.         self.failUnlessRaises(TypeError, operator.pos)
  258.         self.failUnlessRaises(TypeError, operator.pos, None)
  259.         self.failUnless(operator.pos(5) == 5)
  260.         self.failUnless(operator.pos(-5) == -5)
  261.         self.failUnless(operator.pos(0) == 0)
  262.         self.failUnless(operator.pos(-0) == 0)
  263.  
  264.     def test_pow(self):
  265.         self.failUnlessRaises(TypeError, operator.pow)
  266.         self.failUnlessRaises(TypeError, operator.pow, None, None)
  267.         self.failUnless(operator.pow(3,5) == 3**5)
  268.         self.failUnless(operator.__pow__(3,5) == 3**5)
  269.         self.assertRaises(TypeError, operator.pow, 1)
  270.         self.assertRaises(TypeError, operator.pow, 1, 2, 3)
  271.  
  272.     def test_repeat(self):
  273.         a = range(3)
  274.         self.failUnlessRaises(TypeError, operator.repeat)
  275.         self.failUnlessRaises(TypeError, operator.repeat, a, None)
  276.         self.failUnless(operator.repeat(a, 2) == a+a)
  277.         self.failUnless(operator.repeat(a, 1) == a)
  278.         self.failUnless(operator.repeat(a, 0) == [])
  279.         a = (1, 2, 3)
  280.         self.failUnless(operator.repeat(a, 2) == a+a)
  281.         self.failUnless(operator.repeat(a, 1) == a)
  282.         self.failUnless(operator.repeat(a, 0) == ())
  283.         a = '123'
  284.         self.failUnless(operator.repeat(a, 2) == a+a)
  285.         self.failUnless(operator.repeat(a, 1) == a)
  286.         self.failUnless(operator.repeat(a, 0) == '')
  287.         a = Seq1([4, 5, 6])
  288.         self.failUnless(operator.repeat(a, 2) == [4, 5, 6, 4, 5, 6])
  289.         self.failUnless(operator.repeat(a, 1) == [4, 5, 6])
  290.         self.failUnless(operator.repeat(a, 0) == [])
  291.         a = Seq2([4, 5, 6])
  292.         self.failUnless(operator.repeat(a, 2) == [4, 5, 6, 4, 5, 6])
  293.         self.failUnless(operator.repeat(a, 1) == [4, 5, 6])
  294.         self.failUnless(operator.repeat(a, 0) == [])
  295.         self.failUnlessRaises(TypeError, operator.repeat, 6, 7)
  296.  
  297.     def test_rshift(self):
  298.         self.failUnlessRaises(TypeError, operator.rshift)
  299.         self.failUnlessRaises(TypeError, operator.rshift, None, 42)
  300.         self.failUnless(operator.rshift(5, 1) == 2)
  301.         self.failUnless(operator.rshift(5, 0) == 5)
  302.         self.assertRaises(ValueError, operator.rshift, 2, -1)
  303.  
  304.     def test_contains(self):
  305.         self.failUnlessRaises(TypeError, operator.contains)
  306.         self.failUnlessRaises(TypeError, operator.contains, None, None)
  307.         self.failUnless(operator.contains(range(4), 2))
  308.         self.failIf(operator.contains(range(4), 5))
  309.         self.failUnless(operator.sequenceIncludes(range(4), 2))
  310.         self.failIf(operator.sequenceIncludes(range(4), 5))
  311.  
  312.     def test_setitem(self):
  313.         a = range(3)
  314.         self.failUnlessRaises(TypeError, operator.setitem, a)
  315.         self.failUnlessRaises(TypeError, operator.setitem, a, None, None)
  316.         self.failUnless(operator.setitem(a, 0, 2) is None)
  317.         self.assert_(a == [2, 1, 2])
  318.         self.assertRaises(IndexError, operator.setitem, a, 4, 2)
  319.  
  320.     def test_setslice(self):
  321.         a = range(4)
  322.         self.failUnlessRaises(TypeError, operator.setslice, a)
  323.         self.failUnlessRaises(TypeError, operator.setslice, a, None, None, None)
  324.         self.failUnless(operator.setslice(a, 1, 3, [2, 1]) is None)
  325.         self.assert_(a == [0, 2, 1, 3])
  326.         operator.setslice(a, 0, test_support.MAX_Py_ssize_t, [])
  327.         self.assert_(a == [])
  328.  
  329.     def test_sub(self):
  330.         self.failUnlessRaises(TypeError, operator.sub)
  331.         self.failUnlessRaises(TypeError, operator.sub, None, None)
  332.         self.failUnless(operator.sub(5, 2) == 3)
  333.  
  334.     def test_truth(self):
  335.         class C(object):
  336.             def __nonzero__(self):
  337.                 raise SyntaxError
  338.         self.failUnlessRaises(TypeError, operator.truth)
  339.         self.failUnlessRaises(SyntaxError, operator.truth, C())
  340.         self.failUnless(operator.truth(5))
  341.         self.failUnless(operator.truth([0]))
  342.         self.failIf(operator.truth(0))
  343.         self.failIf(operator.truth([]))
  344.  
  345.     def test_bitwise_xor(self):
  346.         self.failUnlessRaises(TypeError, operator.xor)
  347.         self.failUnlessRaises(TypeError, operator.xor, None, None)
  348.         self.failUnless(operator.xor(0xb, 0xc) == 0x7)
  349.  
  350.     def test_is(self):
  351.         a = b = 'xyzpdq'
  352.         c = a[:3] + b[3:]
  353.         self.failUnlessRaises(TypeError, operator.is_)
  354.         self.failUnless(operator.is_(a, b))
  355.         self.failIf(operator.is_(a,c))
  356.  
  357.     def test_is_not(self):
  358.         a = b = 'xyzpdq'
  359.         c = a[:3] + b[3:]
  360.         self.failUnlessRaises(TypeError, operator.is_not)
  361.         self.failIf(operator.is_not(a, b))
  362.         self.failUnless(operator.is_not(a,c))
  363.  
  364.     def test_attrgetter(self):
  365.         class A:
  366.             pass
  367.         a = A()
  368.         a.name = 'arthur'
  369.         f = operator.attrgetter('name')
  370.         self.assertEqual(f(a), 'arthur')
  371.         f = operator.attrgetter('rank')
  372.         self.assertRaises(AttributeError, f, a)
  373.         f = operator.attrgetter(2)
  374.         self.assertRaises(TypeError, f, a)
  375.         self.assertRaises(TypeError, operator.attrgetter)
  376.  
  377.         # multiple gets
  378.         record = A()
  379.         record.x = 'X'
  380.         record.y = 'Y'
  381.         record.z = 'Z'
  382.         self.assertEqual(operator.attrgetter('x','z','y')(record), ('X', 'Z', 'Y'))
  383.         self.assertRaises(TypeError, operator.attrgetter('x', (), 'y'), record)
  384.  
  385.         class C(object):
  386.             def __getattr__(self, name):
  387.                 raise SyntaxError
  388.         self.failUnlessRaises(SyntaxError, operator.attrgetter('foo'), C())
  389.  
  390.         # recursive gets
  391.         a = A()
  392.         a.name = 'arthur'
  393.         a.child = A()
  394.         a.child.name = 'thomas'
  395.         f = operator.attrgetter('child.name')
  396.         self.assertEqual(f(a), 'thomas')
  397.         self.assertRaises(AttributeError, f, a.child)
  398.         f = operator.attrgetter('name', 'child.name')
  399.         self.assertEqual(f(a), ('arthur', 'thomas'))
  400.         f = operator.attrgetter('name', 'child.name', 'child.child.name')
  401.         self.assertRaises(AttributeError, f, a)
  402.  
  403.         a.child.child = A()
  404.         a.child.child.name = 'johnson'
  405.         f = operator.attrgetter('child.child.name')
  406.         self.assertEqual(f(a), 'johnson')
  407.         f = operator.attrgetter('name', 'child.name', 'child.child.name')
  408.         self.assertEqual(f(a), ('arthur', 'thomas', 'johnson'))
  409.  
  410.     def test_itemgetter(self):
  411.         a = 'ABCDE'
  412.         f = operator.itemgetter(2)
  413.         self.assertEqual(f(a), 'C')
  414.         f = operator.itemgetter(10)
  415.         self.assertRaises(IndexError, f, a)
  416.  
  417.         class C(object):
  418.             def __getitem__(self, name):
  419.                 raise SyntaxError
  420.         self.failUnlessRaises(SyntaxError, operator.itemgetter(42), C())
  421.  
  422.         f = operator.itemgetter('name')
  423.         self.assertRaises(TypeError, f, a)
  424.         self.assertRaises(TypeError, operator.itemgetter)
  425.  
  426.         d = dict(key='val')
  427.         f = operator.itemgetter('key')
  428.         self.assertEqual(f(d), 'val')
  429.         f = operator.itemgetter('nonkey')
  430.         self.assertRaises(KeyError, f, d)
  431.  
  432.         # example used in the docs
  433.         inventory = [('apple', 3), ('banana', 2), ('pear', 5), ('orange', 1)]
  434.         getcount = operator.itemgetter(1)
  435.         self.assertEqual(map(getcount, inventory), [3, 2, 5, 1])
  436.         self.assertEqual(sorted(inventory, key=getcount),
  437.             [('orange', 1), ('banana', 2), ('apple', 3), ('pear', 5)])
  438.  
  439.         # multiple gets
  440.         data = map(str, range(20))
  441.         self.assertEqual(operator.itemgetter(2,10,5)(data), ('2', '10', '5'))
  442.         self.assertRaises(TypeError, operator.itemgetter(2, 'x', 5), data)
  443.  
  444.     def test_methodcaller(self):
  445.         self.assertRaises(TypeError, operator.methodcaller)
  446.         class A:
  447.             def foo(self, *args, **kwds):
  448.                 return args[0] + args[1]
  449.             def bar(self, f=42):
  450.                 return f
  451.         a = A()
  452.         f = operator.methodcaller('foo')
  453.         self.assertRaises(IndexError, f, a)
  454.         f = operator.methodcaller('foo', 1, 2)
  455.         self.assertEquals(f(a), 3)
  456.         f = operator.methodcaller('bar')
  457.         self.assertEquals(f(a), 42)
  458.         self.assertRaises(TypeError, f, a, a)
  459.         f = operator.methodcaller('bar', f=5)
  460.         self.assertEquals(f(a), 5)
  461.  
  462.     def test_inplace(self):
  463.         class C(object):
  464.             def __iadd__     (self, other): return "iadd"
  465.             def __iand__     (self, other): return "iand"
  466.             def __idiv__     (self, other): return "idiv"
  467.             def __ifloordiv__(self, other): return "ifloordiv"
  468.             def __ilshift__  (self, other): return "ilshift"
  469.             def __imod__     (self, other): return "imod"
  470.             def __imul__     (self, other): return "imul"
  471.             def __ior__      (self, other): return "ior"
  472.             def __ipow__     (self, other): return "ipow"
  473.             def __irshift__  (self, other): return "irshift"
  474.             def __isub__     (self, other): return "isub"
  475.             def __itruediv__ (self, other): return "itruediv"
  476.             def __ixor__     (self, other): return "ixor"
  477.             def __getitem__(self, other): return 5  # so that C is a sequence
  478.         c = C()
  479.         self.assertEqual(operator.iadd     (c, 5), "iadd")
  480.         self.assertEqual(operator.iand     (c, 5), "iand")
  481.         self.assertEqual(operator.idiv     (c, 5), "idiv")
  482.         self.assertEqual(operator.ifloordiv(c, 5), "ifloordiv")
  483.         self.assertEqual(operator.ilshift  (c, 5), "ilshift")
  484.         self.assertEqual(operator.imod     (c, 5), "imod")
  485.         self.assertEqual(operator.imul     (c, 5), "imul")
  486.         self.assertEqual(operator.ior      (c, 5), "ior")
  487.         self.assertEqual(operator.ipow     (c, 5), "ipow")
  488.         self.assertEqual(operator.irshift  (c, 5), "irshift")
  489.         self.assertEqual(operator.isub     (c, 5), "isub")
  490.         self.assertEqual(operator.itruediv (c, 5), "itruediv")
  491.         self.assertEqual(operator.ixor     (c, 5), "ixor")
  492.         self.assertEqual(operator.iconcat  (c, c), "iadd")
  493.         self.assertEqual(operator.irepeat  (c, 5), "imul")
  494.         self.assertEqual(operator.__iadd__     (c, 5), "iadd")
  495.         self.assertEqual(operator.__iand__     (c, 5), "iand")
  496.         self.assertEqual(operator.__idiv__     (c, 5), "idiv")
  497.         self.assertEqual(operator.__ifloordiv__(c, 5), "ifloordiv")
  498.         self.assertEqual(operator.__ilshift__  (c, 5), "ilshift")
  499.         self.assertEqual(operator.__imod__     (c, 5), "imod")
  500.         self.assertEqual(operator.__imul__     (c, 5), "imul")
  501.         self.assertEqual(operator.__ior__      (c, 5), "ior")
  502.         self.assertEqual(operator.__ipow__     (c, 5), "ipow")
  503.         self.assertEqual(operator.__irshift__  (c, 5), "irshift")
  504.         self.assertEqual(operator.__isub__     (c, 5), "isub")
  505.         self.assertEqual(operator.__itruediv__ (c, 5), "itruediv")
  506.         self.assertEqual(operator.__ixor__     (c, 5), "ixor")
  507.         self.assertEqual(operator.__iconcat__  (c, c), "iadd")
  508.         self.assertEqual(operator.__irepeat__  (c, 5), "imul")
  509.  
  510. def test_main(verbose=None):
  511.     import sys
  512.     test_classes = (
  513.         OperatorTestCase,
  514.     )
  515.  
  516.     test_support.run_unittest(*test_classes)
  517.  
  518.     # verify reference counting
  519.     if verbose and hasattr(sys, "gettotalrefcount"):
  520.         import gc
  521.         counts = [None] * 5
  522.         for i in xrange(len(counts)):
  523.             test_support.run_unittest(*test_classes)
  524.             gc.collect()
  525.             counts[i] = sys.gettotalrefcount()
  526.         print counts
  527.  
  528. if __name__ == "__main__":
  529.     test_main(verbose=True)
  530.