rubyfox-server 2.3.0.pre2

data/lib/rubyfox/server/data/lib/Lib/test/test_operations.py

@@ -0,0 +1,475 @@
+# Python test set -- part 3, built-in operations.
+
+from test_support import *
+
+print_test('Operations (test_operations.py)', 1)
+
+print_test('Numeric', 2)
+print_test('+', 3)
+assert 0 + 0 == 0
+assert 0 + 3 == 3
+assert 0 + 42 == 42
+assert 3 + 0 == 3
+assert 3 + 3 == 6
+assert 3 + 42 == 45
+assert 42 + 0 == 42
+assert 42 + 3 == 45
+assert 42 + 42 == 84
+assert 0.0 + 0.0 == 0.0
+assert 0.0 + 3.0 == 3.0
+assert 0.0 + 42.0 == 42.0
+assert 3.0 + 0.0 == 3.0
+assert 3.0 + 3.0 == 6.0
+assert 3.0 + 42.0 == 45.0
+assert 42.0 + 0.0 == 42.0
+assert 42.0 + 3.0 == 45.0
+assert 42.0 + 42.0 == 84.0
+assert 0L + 0L == 0L
+assert 0L + 3L == 3L
+assert 0L + 42L == 42L
+assert 3L + 0L == 3L
+assert 3L + 3L == 6L
+assert 3L + 42L == 45L
+assert 42L + 0L == 42L
+assert 42L + 3L == 45L
+assert 42L + 42L == 84L
+print_test('-', 3)
+assert 0 - 0 == 0
+assert 0 - 3 == -3
+assert 0 - 42 == -42
+assert 3 - 0 == 3
+assert 3 - 3 == 0
+assert 3 - 42 == -39
+assert 42 - 0 == 42
+assert 42 - 3 == 39
+assert 42 - 42 == 0
+assert 0.0 - 0.0 == 0.0
+assert 0.0 - 3.0 == -3.0
+assert 0.0 - 42.0 == -42.0
+assert 3.0 - 0.0 == 3.0
+assert 3.0 - 3.0 == 0.0
+assert 3.0 - 42.0 == -39.0
+assert 42.0 - 0.0 == 42.0
+assert 42.0 - 3.0 == 39.0
+assert 42.0 - 42.0 == 0.0
+assert 0L - 0L == 0L
+assert 0L - 3L == -3L
+assert 0L - 42L == -42L
+assert 3L - 0L == 3L
+assert 3L - 3L == 0L
+assert 3L - 42L == -39L
+assert 42L - 0L == 42L
+assert 42L - 3L == 39L
+assert 42L - 42L == 0L
+print_test('*', 3)
+assert 0 * 0 == 0
+assert 0 * 3 == 0
+assert 0 * 42 == 0
+assert 3 * 0 == 0
+assert 3 * 3 == 9
+assert 3 * 42 == 126
+assert 42 * 0 == 0
+assert 42 * 3 == 126
+assert 42 * 42 == 1764
+assert 0.0 * 0.0 == 0.0
+assert 0.0 * 3.0 == 0.0
+assert 0.0 * 42.0 == 0.0
+assert 3.0 * 0.0 == 0.0
+assert 3.0 * 3.0 == 9.0
+assert 3.0 * 42.0 == 126.0
+assert 42.0 * 0.0 == 0.0
+assert 42.0 * 3.0 == 126.0
+assert 42.0 * 42.0 == 1764.0
+assert 0L * 0L == 0L
+assert 0L * 3L == 0L
+assert 0L * 42L == 0L
+assert 3L * 0L == 0L
+assert 3L * 3L == 9L
+assert 3L * 42L == 126L
+assert 42L * 0L == 0L
+assert 42L * 3L == 126L
+assert 42L * 42L == 1764L
+print_test('/', 3)
+assert 0 / 3 == 0
+assert 0 / 42 == 0
+assert 3 / 3 == 1
+assert 3 / 42 == 0
+assert 42 / 3 == 14
+assert 42 / 42 == 1
+assert 0.0 / 3.0 == 0.0
+assert 0.0 / 42.0 == 0.0
+assert 3.0 / 3.0 == 1.0
+assert abs(3.0 / 42.0 - 0.0714285714286) < 0.000001
+assert 42.0 / 3.0 == 14.0
+assert 42.0 / 42.0 == 1.0
+assert 0L / 3L == 0L
+assert 0L / 42L == 0L
+assert 3L / 3L == 1L
+assert 3L / 42L == 0L
+assert 42L / 3L == 14L
+assert 42L / 42L == 1L
+print_test('**', 3)
+assert 0 ** 0 == 1
+assert 0 ** 3 == 0
+assert 0 ** 42 == 0
+assert 3 ** 0 == 1
+assert 3 ** 3 == 27
+assert 42 ** 0 == 1
+assert 42 ** 3 == 74088
+assert 0.0 ** 0.0 == 1.0
+assert 0.0 ** 3.0 == 0.0
+assert 0.0 ** 42.0 == 0.0
+assert 3.0 ** 0.0 == 1.0
+assert 3.0 ** 3.0 == 27.0
+assert abs(3.0 ** 42.0 - 1.0941898913151237e+020) < 1e10
+assert 42.0 ** 0.0 == 1.0
+assert 42.0 ** 3.0 == 74088.0
+assert abs(42.0 ** 42.0 - 1.5013093754529659e+068) < 1e58
+assert 0L ** 0L == 1L
+assert 0L ** 3L == 0L
+assert 0L ** 42L == 0L
+assert 3L ** 0L == 1L
+assert 3L ** 3L == 27L
+assert 3L ** 42L == 109418989131512359209L
+assert 42L ** 0L == 1L
+assert 42L ** 3L == 74088L
+assert 42L ** 42L == 150130937545296572356771972164254457814047970568738777235893533016064L
+print_test('%', 3)
+assert 0 % 3 == 0
+assert 0 % 42 == 0
+assert 3 % 3 == 0
+assert 3 % 42 == 3
+assert 42 % 3 == 0
+assert 42 % 42 == 0
+assert 0.0 % 3.0 == 0.0
+assert 0.0 % 42.0 == 0.0
+assert 3.0 % 3.0 == 0.0
+assert 3.0 % 42.0 == 3.0
+assert 42.0 % 3.0 == 0.0
+assert 42.0 % 42.0 == 0.0
+assert 0L % 3L == 0L
+assert 0L % 42L == 0L
+assert 3L % 3L == 0L
+assert 3L % 42L == 3L
+assert 42L % 3L == 0L
+assert 42L % 42L == 0L
+
+print_test('Binary', 2)
+print_test('|', 3)
+assert 0 | 0 == 0
+assert 0 | 3 == 3
+assert 0 | 42 == 42
+assert 3 | 0 == 3
+assert 3 | 3 == 3
+assert 3 | 42 == 43
+assert 42 | 0 == 42
+assert 42 | 3 == 43
+assert 42 | 42 == 42
+assert 0L | 0L == 0L
+assert 0L | 3L == 3L
+assert 0L | 42L == 42L
+assert 3L | 0L == 3L
+assert 3L | 3L == 3L
+assert 3L | 42L == 43L
+assert 42L | 0L == 42L
+assert 42L | 3L == 43L
+assert 42L | 42L == 42L
+print_test('^', 3)
+assert 0 ^ 0 == 0
+assert 0 ^ 3 == 3
+assert 0 ^ 42 == 42
+assert 3 ^ 0 == 3
+assert 3 ^ 3 == 0
+assert 3 ^ 42 == 41
+assert 42 ^ 0 == 42
+assert 42 ^ 3 == 41
+assert 42 ^ 42 == 0
+assert 0L ^ 0L == 0L
+assert 0L ^ 3L == 3L
+assert 0L ^ 42L == 42L
+assert 3L ^ 0L == 3L
+assert 3L ^ 3L == 0L
+assert 3L ^ 42L == 41L
+assert 42L ^ 0L == 42L
+assert 42L ^ 3L == 41L
+assert 42L ^ 42L == 0L
+print_test('&', 3)
+assert 0 & 0 == 0
+assert 0 & 3 == 0
+assert 0 & 42 == 0
+assert 3 & 0 == 0
+assert 3 & 3 == 3
+assert 3 & 42 == 2
+assert 42 & 0 == 0
+assert 42 & 3 == 2
+assert 42 & 42 == 42
+assert 0L & 0L == 0L
+assert 0L & 3L == 0L
+assert 0L & 42L == 0L
+assert 3L & 0L == 0L
+assert 3L & 3L == 3L
+assert 3L & 42L == 2L
+assert 42L & 0L == 0L
+assert 42L & 3L == 2L
+assert 42L & 42L == 42L
+print_test('<<', 3)
+assert 0 << 0 == 0
+assert 0 << 3 == 0
+assert 0 << 42 == 0
+assert 3 << 0 == 3
+assert 3 << 3 == 24
+assert 3 << 42 == 0
+assert 42 << 0 == 42
+assert 42 << 3 == 336
+assert 42 << 42 == 0
+assert 0L << 0L == 0L
+assert 0L << 3L == 0L
+assert 0L << 42L == 0L
+assert 3L << 0L == 3L
+assert 3L << 3L == 24L
+assert 3L << 42L == 13194139533312L
+assert 42L << 0L == 42L
+assert 42L << 3L == 336L
+assert 42L << 42L == 184717953466368L
+print_test('>>', 3)
+assert 0 >> 0 == 0
+assert 0 >> 3 == 0
+assert 0 >> 42 == 0
+assert 3 >> 0 == 3
+assert 3 >> 3 == 0
+assert 3 >> 42 == 0
+assert 42 >> 0 == 42
+assert 42 >> 3 == 5
+assert 42 >> 42 == 0
+assert 0L >> 0L == 0L
+assert 0L >> 3L == 0L
+assert 0L >> 42L == 0L
+assert 3L >> 0L == 3L
+assert 3L >> 3L == 0L
+assert 3L >> 42L == 0L
+assert 42L >> 0L == 42L
+assert 42L >> 3L == 5L
+assert 42L >> 42L == 0L
+
+print_test('Comparison', 2)
+print_test('<', 3)
+assert (0 < 0) == 0
+assert (0 < 3) == 1
+assert (0 < 42) == 1
+assert (3 < 0) == 0
+assert (3 < 3) == 0
+assert (3 < 42) == 1
+assert (42 < 0) == 0
+assert (42 < 3) == 0
+assert (42 < 42) == 0
+assert (0.0 < 0.0) == 0
+assert (0.0 < 3.0) == 1
+assert (0.0 < 42.0) == 1
+assert (3.0 < 0.0) == 0
+assert (3.0 < 3.0) == 0
+assert (3.0 < 42.0) == 1
+assert (42.0 < 0.0) == 0
+assert (42.0 < 3.0) == 0
+assert (42.0 < 42.0) == 0
+assert (0L < 0L) == 0
+assert (0L < 3L) == 1
+assert (0L < 42L) == 1
+assert (3L < 0L) == 0
+assert (3L < 3L) == 0
+assert (3L < 42L) == 1
+assert (42L < 0L) == 0
+assert (42L < 3L) == 0
+assert (42L < 42L) == 0
+print_test('>', 3)
+assert (0 > 0) == 0
+assert (0 > 3) == 0
+assert (0 > 42) == 0
+assert (3 > 0) == 1
+assert (3 > 3) == 0
+assert (3 > 42) == 0
+assert (42 > 0) == 1
+assert (42 > 3) == 1
+assert (42 > 42) == 0
+assert (0.0 > 0.0) == 0
+assert (0.0 > 3.0) == 0
+assert (0.0 > 42.0) == 0
+assert (3.0 > 0.0) == 1
+assert (3.0 > 3.0) == 0
+assert (3.0 > 42.0) == 0
+assert (42.0 > 0.0) == 1
+assert (42.0 > 3.0) == 1
+assert (42.0 > 42.0) == 0
+assert (0L > 0L) == 0
+assert (0L > 3L) == 0
+assert (0L > 42L) == 0
+assert (3L > 0L) == 1
+assert (3L > 3L) == 0
+assert (3L > 42L) == 0
+assert (42L > 0L) == 1
+assert (42L > 3L) == 1
+assert (42L > 42L) == 0
+print_test('==', 3)
+assert (0 == 0) == 1
+assert (0 == 3) == 0
+assert (0 == 42) == 0
+assert (3 == 0) == 0
+assert (3 == 3) == 1
+assert (3 == 42) == 0
+assert (42 == 0) == 0
+assert (42 == 3) == 0
+assert (42 == 42) == 1
+assert (0.0 == 0.0) == 1
+assert (0.0 == 3.0) == 0
+assert (0.0 == 42.0) == 0
+assert (3.0 == 0.0) == 0
+assert (3.0 == 3.0) == 1
+assert (3.0 == 42.0) == 0
+assert (42.0 == 0.0) == 0
+assert (42.0 == 3.0) == 0
+assert (42.0 == 42.0) == 1
+assert (0L == 0L) == 1
+assert (0L == 3L) == 0
+assert (0L == 42L) == 0
+assert (3L == 0L) == 0
+assert (3L == 3L) == 1
+assert (3L == 42L) == 0
+assert (42L == 0L) == 0
+assert (42L == 3L) == 0
+assert (42L == 42L) == 1
+print_test('<=', 3)
+assert (0 <= 0) == 1
+assert (0 <= 3) == 1
+assert (0 <= 42) == 1
+assert (3 <= 0) == 0
+assert (3 <= 3) == 1
+assert (3 <= 42) == 1
+assert (42 <= 0) == 0
+assert (42 <= 3) == 0
+assert (42 <= 42) == 1
+assert (0.0 <= 0.0) == 1
+assert (0.0 <= 3.0) == 1
+assert (0.0 <= 42.0) == 1
+assert (3.0 <= 0.0) == 0
+assert (3.0 <= 3.0) == 1
+assert (3.0 <= 42.0) == 1
+assert (42.0 <= 0.0) == 0
+assert (42.0 <= 3.0) == 0
+assert (42.0 <= 42.0) == 1
+assert (0L <= 0L) == 1
+assert (0L <= 3L) == 1
+assert (0L <= 42L) == 1
+assert (3L <= 0L) == 0
+assert (3L <= 3L) == 1
+assert (3L <= 42L) == 1
+assert (42L <= 0L) == 0
+assert (42L <= 3L) == 0
+assert (42L <= 42L) == 1
+print_test('>=', 3)
+assert (0 >= 0) == 1
+assert (0 >= 3) == 0
+assert (0 >= 42) == 0
+assert (3 >= 0) == 1
+assert (3 >= 3) == 1
+assert (3 >= 42) == 0
+assert (42 >= 0) == 1
+assert (42 >= 3) == 1
+assert (42 >= 42) == 1
+assert (0.0 >= 0.0) == 1
+assert (0.0 >= 3.0) == 0
+assert (0.0 >= 42.0) == 0
+assert (3.0 >= 0.0) == 1
+assert (3.0 >= 3.0) == 1
+assert (3.0 >= 42.0) == 0
+assert (42.0 >= 0.0) == 1
+assert (42.0 >= 3.0) == 1
+assert (42.0 >= 42.0) == 1
+assert (0L >= 0L) == 1
+assert (0L >= 3L) == 0
+assert (0L >= 42L) == 0
+assert (3L >= 0L) == 1
+assert (3L >= 3L) == 1
+assert (3L >= 42L) == 0
+assert (42L >= 0L) == 1
+assert (42L >= 3L) == 1
+assert (42L >= 42L) == 1
+print_test('and', 3)
+assert (0 and 0) == 0
+assert (0 and 3) == 0
+assert (0 and 42) == 0
+assert (3 and 0) == 0
+assert (3 and 3) == 3
+assert (3 and 42) == 42
+assert (42 and 0) == 0
+assert (42 and 3) == 3
+assert (42 and 42) == 42
+assert (0.0 and 0.0) == 0.0
+assert (0.0 and 3.0) == 0.0
+assert (0.0 and 42.0) == 0.0
+assert (3.0 and 0.0) == 0.0
+assert (3.0 and 3.0) == 3.0
+assert (3.0 and 42.0) == 42.0
+assert (42.0 and 0.0) == 0.0
+assert (42.0 and 3.0) == 3.0
+assert (42.0 and 42.0) == 42.0
+assert (0L and 0L) == 0L
+assert (0L and 3L) == 0L
+assert (0L and 42L) == 0L
+assert (3L and 0L) == 0L
+assert (3L and 3L) == 3L
+assert (3L and 42L) == 42L
+assert (42L and 0L) == 0L
+assert (42L and 3L) == 3L
+assert (42L and 42L) == 42L
+print_test('or', 3)
+assert (0 or 0) == 0
+assert (0 or 3) == 3
+assert (0 or 42) == 42
+assert (3 or 0) == 3
+assert (3 or 3) == 3
+assert (3 or 42) == 3
+assert (42 or 0) == 42
+assert (42 or 3) == 42
+assert (42 or 42) == 42
+assert (0.0 or 0.0) == 0.0
+assert (0.0 or 3.0) == 3.0
+assert (0.0 or 42.0) == 42.0
+assert (3.0 or 0.0) == 3.0
+assert (3.0 or 3.0) == 3.0
+assert (3.0 or 42.0) == 3.0
+assert (42.0 or 0.0) == 42.0
+assert (42.0 or 3.0) == 42.0
+assert (42.0 or 42.0) == 42.0
+assert (0L or 0L) == 0L
+assert (0L or 3L) == 3L
+assert (0L or 42L) == 42L
+assert (3L or 0L) == 3L
+assert (3L or 3L) == 3L
+assert (3L or 42L) == 3L
+assert (42L or 0L) == 42L
+assert (42L or 3L) == 42L
+assert (42L or 42L) == 42L
+
+print_test('Indexing', 2)
+lst = range(5)
+
+print_test('[i]', 3)
+assert lst[0] == 0
+assert lst[3] == 3
+lst[3] = 99 
+assert lst[3] == 99
+lst[3] = 3
+
+print_test('[i:j]', 3)
+assert lst[:2] == [0,1]
+assert lst[-3:] == [2,3,4]
+assert lst[2:] == [2,3,4]
+assert lst[0:2] == [0,1]
+assert lst[1:3] == [1,2]
+
+print_test('in', 3)
+assert 2 in lst
+assert not (8 in lst)
+
+print_test('not in', 3)
+assert 8 not in lst
+assert not (2 not in lst)

data/lib/rubyfox/server/data/lib/Lib/test/test_operator.py

@@ -0,0 +1,218 @@
+import operator
+import unittest
+
+import test_support
+
+
+class OperatorTestCase(unittest.TestCase):
+    def test_lt(self):
+        self.failIf(operator.lt(1, 0))
+        self.failIf(operator.lt(1, 0.0))
+        self.failIf(operator.lt(1, 1))
+        self.failIf(operator.lt(1, 1.0))
+        self.failUnless(operator.lt(1, 2))
+        self.failUnless(operator.lt(1, 2.0))
+
+    def test_le(self):
+        self.failIf(operator.le(1, 0))
+        self.failIf(operator.le(1, 0.0))
+        self.failUnless(operator.le(1, 1))
+        self.failUnless(operator.le(1, 1.0))
+        self.failUnless(operator.le(1, 2))
+        self.failUnless(operator.le(1, 2.0))
+
+    def test_eq(self):
+        self.failIf(operator.eq(1, 0))
+        self.failIf(operator.eq(1, 0.0))
+        self.failUnless(operator.eq(1, 1))
+        self.failUnless(operator.eq(1, 1.0))
+        self.failIf(operator.eq(1, 2))
+        self.failIf(operator.eq(1, 2.0))
+
+    def test_ne(self):
+        self.failUnless(operator.ne(1, 0))
+        self.failUnless(operator.ne(1, 0.0))
+        self.failIf(operator.ne(1, 1))
+        self.failIf(operator.ne(1, 1.0))
+        self.failUnless(operator.ne(1, 2))
+        self.failUnless(operator.ne(1, 2.0))
+
+    def test_ge(self):
+        self.failUnless(operator.ge(1, 0))
+        self.failUnless(operator.ge(1, 0.0))
+        self.failUnless(operator.ge(1, 1))
+        self.failUnless(operator.ge(1, 1.0))
+        self.failIf(operator.ge(1, 2))
+        self.failIf(operator.ge(1, 2.0))
+
+    def test_gt(self):
+        self.failUnless(operator.gt(1, 0))
+        self.failUnless(operator.gt(1, 0.0))
+        self.failIf(operator.gt(1, 1))
+        self.failIf(operator.gt(1, 1.0))
+        self.failIf(operator.gt(1, 2))
+        self.failIf(operator.gt(1, 2.0))
+
+    def test_abs(self):
+        self.failUnless(operator.abs(-1) == 1)
+        self.failUnless(operator.abs(1) == 1)
+
+    def test_add(self):
+        self.failUnless(operator.add(3, 4) == 7)
+
+    def test_bitwise_and(self):
+        self.failUnless(operator.and_(0xf, 0xa) == 0xa)
+
+    def test_concat(self):
+        self.failUnless(operator.concat('py', 'thon') == 'python')
+        self.failUnless(operator.concat([1, 2], [3, 4]) == [1, 2, 3, 4])
+
+    def test_countOf(self):
+        self.failUnless(operator.countOf([1, 2, 1, 3, 1, 4], 3) == 1)
+        self.failUnless(operator.countOf([1, 2, 1, 3, 1, 4], 5) == 0)
+
+    def test_delitem(self):
+        a = [4, 3, 2, 1]
+        self.failUnless(operator.delitem(a, 1) is None)
+        self.assert_(a == [4, 2, 1])
+
+    def test_delslice(self):
+        a = range(10)
+        self.failUnless(operator.delslice(a, 2, 8) is None)
+        self.assert_(a == [0, 1, 8, 9])
+
+    def test_div(self):
+        self.failUnless(operator.floordiv(5, 2) == 2)
+
+    def test_floordiv(self):
+        self.failUnless(operator.floordiv(5, 2) == 2)
+
+    def test_truediv(self):
+        self.failUnless(operator.truediv(5, 2) == 2.5)
+
+    def test_getitem(self):
+        a = range(10)
+        self.failUnless(operator.getitem(a, 2) == 2)
+
+    def test_getslice(self):
+        a = range(10)
+        self.failUnless(operator.getslice(a, 4, 6) == [4, 5])
+
+    def test_indexOf(self):
+        self.failUnless(operator.indexOf([4, 3, 2, 1], 3) == 1)
+        self.assertRaises(ValueError, operator.indexOf, [4, 3, 2, 1], 0)
+
+    def test_invert(self):
+        self.failUnless(operator.inv(4) == -5)
+
+    def test_isCallable(self):
+        class C:
+            pass
+        def check(self, o, v):
+            self.assert_(operator.isCallable(o) == callable(o) == v)
+        check(self, 4, 0)
+        check(self, operator.isCallable, 1)
+        check(self, C, 1)
+        check(self, C(), 0)
+
+    def test_isMappingType(self):
+        self.failIf(operator.isMappingType(1))
+        self.failIf(operator.isMappingType(operator.isMappingType))
+        self.failUnless(operator.isMappingType(operator.__dict__))
+        self.failUnless(operator.isMappingType({}))
+
+    def test_isNumberType(self):
+        self.failUnless(operator.isNumberType(8))
+        self.failUnless(operator.isNumberType(8j))
+        self.failUnless(operator.isNumberType(8L))
+        self.failUnless(operator.isNumberType(8.3))
+        self.failIf(operator.isNumberType(dir()))
+
+    def test_isSequenceType(self):
+        self.failUnless(operator.isSequenceType(dir()))
+        self.failUnless(operator.isSequenceType(()))
+        self.failUnless(operator.isSequenceType(xrange(10)))
+        self.failUnless(operator.isSequenceType('yeahbuddy'))
+        self.failIf(operator.isSequenceType(3))
+
+    def test_lshift(self):
+        self.failUnless(operator.lshift(5, 1) == 10)
+        self.failUnless(operator.lshift(5, 0) == 5)
+        self.assertRaises(ValueError, operator.lshift, 2, -1)
+
+    def test_mod(self):
+        self.failUnless(operator.mod(5, 2) == 1)
+
+    def test_mul(self):
+        self.failUnless(operator.mul(5, 2) == 10)
+
+    def test_neg(self):
+        self.failUnless(operator.neg(5) == -5)
+        self.failUnless(operator.neg(-5) == 5)
+        self.failUnless(operator.neg(0) == 0)
+        self.failUnless(operator.neg(-0) == 0)
+
+    def test_bitwise_or(self):
+        self.failUnless(operator.or_(0xa, 0x5) == 0xf)
+
+    def test_pos(self):
+        self.failUnless(operator.pos(5) == 5)
+        self.failUnless(operator.pos(-5) == -5)
+        self.failUnless(operator.pos(0) == 0)
+        self.failUnless(operator.pos(-0) == 0)
+
+    def test_repeat(self):
+        a = range(3)
+        self.failUnless(operator.repeat(a, 2) == a+a)
+        self.failUnless(operator.repeat(a, 1) == a)
+        self.failUnless(operator.repeat(a, 0) == [])
+        a = (1, 2, 3)
+        self.failUnless(operator.repeat(a, 2) == a+a)
+        self.failUnless(operator.repeat(a, 1) == a)
+        self.failUnless(operator.repeat(a, 0) == ())
+        a = '123'
+        self.failUnless(operator.repeat(a, 2) == a+a)
+        self.failUnless(operator.repeat(a, 1) == a)
+        self.failUnless(operator.repeat(a, 0) == '')
+
+    def test_rshift(self):
+        self.failUnless(operator.rshift(5, 1) == 2)
+        self.failUnless(operator.rshift(5, 0) == 5)
+        self.assertRaises(ValueError, operator.rshift, 2, -1)
+
+    def test_contains(self):
+        self.failUnless(operator.contains(range(4), 2))
+        self.failIf(operator.contains(range(4), 5))
+        self.failUnless(operator.sequenceIncludes(range(4), 2))
+        self.failIf(operator.sequenceIncludes(range(4), 5))
+
+    def test_setitem(self):
+        a = range(3)
+        self.failUnless(operator.setitem(a, 0, 2) is None)
+        self.assert_(a == [2, 1, 2])
+        self.assertRaises(IndexError, operator.setitem, a, 4, 2)
+
+    def test_setslice(self):
+        a = range(4)
+        self.failUnless(operator.setslice(a, 1, 3, [2, 1]) is None)
+        self.assert_(a == [0, 2, 1, 3])
+
+    def test_sub(self):
+        self.failUnless(operator.sub(5, 2) == 3)
+
+    def test_truth(self):
+        self.failUnless(operator.truth(5))
+        self.failUnless(operator.truth([0]))
+        self.failIf(operator.truth(0))
+        self.failIf(operator.truth([]))
+
+    def test_bitwise_xor(self):
+        self.failUnless(operator.xor(0xb, 0xc) == 0x7)
+
+
+def test_main():
+    test_support.run_unittest(OperatorTestCase)
+
+
+if __name__ == "__main__":
+    test_main()