/Lib/test/seq_tests.py

http://unladen-swallow.googlecode.com/ · Python · 392 lines · 321 code · 55 blank · 16 comment · 17 complexity · 1433367b537871fc7dd46c643c0bbe4b MD5 · raw file

  1. """
  2. Tests common to tuple, list and UserList.UserList
  3. """
  4. import unittest
  5. import sys
  6. # Various iterables
  7. # This is used for checking the constructor (here and in test_deque.py)
  8. def iterfunc(seqn):
  9. 'Regular generator'
  10. for i in seqn:
  11. yield i
  12. class Sequence:
  13. 'Sequence using __getitem__'
  14. def __init__(self, seqn):
  15. self.seqn = seqn
  16. def __getitem__(self, i):
  17. return self.seqn[i]
  18. class IterFunc:
  19. 'Sequence using iterator protocol'
  20. def __init__(self, seqn):
  21. self.seqn = seqn
  22. self.i = 0
  23. def __iter__(self):
  24. return self
  25. def next(self):
  26. if self.i >= len(self.seqn): raise StopIteration
  27. v = self.seqn[self.i]
  28. self.i += 1
  29. return v
  30. class IterGen:
  31. 'Sequence using iterator protocol defined with a generator'
  32. def __init__(self, seqn):
  33. self.seqn = seqn
  34. self.i = 0
  35. def __iter__(self):
  36. for val in self.seqn:
  37. yield val
  38. class IterNextOnly:
  39. 'Missing __getitem__ and __iter__'
  40. def __init__(self, seqn):
  41. self.seqn = seqn
  42. self.i = 0
  43. def next(self):
  44. if self.i >= len(self.seqn): raise StopIteration
  45. v = self.seqn[self.i]
  46. self.i += 1
  47. return v
  48. class IterNoNext:
  49. 'Iterator missing next()'
  50. def __init__(self, seqn):
  51. self.seqn = seqn
  52. self.i = 0
  53. def __iter__(self):
  54. return self
  55. class IterGenExc:
  56. 'Test propagation of exceptions'
  57. def __init__(self, seqn):
  58. self.seqn = seqn
  59. self.i = 0
  60. def __iter__(self):
  61. return self
  62. def next(self):
  63. 3 // 0
  64. class IterFuncStop:
  65. 'Test immediate stop'
  66. def __init__(self, seqn):
  67. pass
  68. def __iter__(self):
  69. return self
  70. def next(self):
  71. raise StopIteration
  72. from itertools import chain, imap
  73. def itermulti(seqn):
  74. 'Test multiple tiers of iterators'
  75. return chain(imap(lambda x:x, iterfunc(IterGen(Sequence(seqn)))))
  76. class CommonTest(unittest.TestCase):
  77. # The type to be tested
  78. type2test = None
  79. def test_constructors(self):
  80. l0 = []
  81. l1 = [0]
  82. l2 = [0, 1]
  83. u = self.type2test()
  84. u0 = self.type2test(l0)
  85. u1 = self.type2test(l1)
  86. u2 = self.type2test(l2)
  87. uu = self.type2test(u)
  88. uu0 = self.type2test(u0)
  89. uu1 = self.type2test(u1)
  90. uu2 = self.type2test(u2)
  91. v = self.type2test(tuple(u))
  92. class OtherSeq:
  93. def __init__(self, initseq):
  94. self.__data = initseq
  95. def __len__(self):
  96. return len(self.__data)
  97. def __getitem__(self, i):
  98. return self.__data[i]
  99. s = OtherSeq(u0)
  100. v0 = self.type2test(s)
  101. self.assertEqual(len(v0), len(s))
  102. s = "this is also a sequence"
  103. vv = self.type2test(s)
  104. self.assertEqual(len(vv), len(s))
  105. # Create from various iteratables
  106. for s in ("123", "", range(1000), ('do', 1.2), xrange(2000,2200,5)):
  107. for g in (Sequence, IterFunc, IterGen,
  108. itermulti, iterfunc):
  109. self.assertEqual(self.type2test(g(s)), self.type2test(s))
  110. self.assertEqual(self.type2test(IterFuncStop(s)), self.type2test())
  111. self.assertEqual(self.type2test(c for c in "123"), self.type2test("123"))
  112. self.assertRaises(TypeError, self.type2test, IterNextOnly(s))
  113. self.assertRaises(TypeError, self.type2test, IterNoNext(s))
  114. self.assertRaises(ZeroDivisionError, self.type2test, IterGenExc(s))
  115. def test_truth(self):
  116. self.assert_(not self.type2test())
  117. self.assert_(self.type2test([42]))
  118. def test_getitem(self):
  119. u = self.type2test([0, 1, 2, 3, 4])
  120. for i in xrange(len(u)):
  121. self.assertEqual(u[i], i)
  122. self.assertEqual(u[long(i)], i)
  123. for i in xrange(-len(u), -1):
  124. self.assertEqual(u[i], len(u)+i)
  125. self.assertEqual(u[long(i)], len(u)+i)
  126. self.assertRaises(IndexError, u.__getitem__, -len(u)-1)
  127. self.assertRaises(IndexError, u.__getitem__, len(u))
  128. self.assertRaises(ValueError, u.__getitem__, slice(0,10,0))
  129. u = self.type2test()
  130. self.assertRaises(IndexError, u.__getitem__, 0)
  131. self.assertRaises(IndexError, u.__getitem__, -1)
  132. self.assertRaises(TypeError, u.__getitem__)
  133. a = self.type2test([10, 11])
  134. self.assertEqual(a[0], 10)
  135. self.assertEqual(a[1], 11)
  136. self.assertEqual(a[-2], 10)
  137. self.assertEqual(a[-1], 11)
  138. self.assertRaises(IndexError, a.__getitem__, -3)
  139. self.assertRaises(IndexError, a.__getitem__, 3)
  140. def test_getslice(self):
  141. l = [0, 1, 2, 3, 4]
  142. u = self.type2test(l)
  143. self.assertEqual(u[0:0], self.type2test())
  144. self.assertEqual(u[1:2], self.type2test([1]))
  145. self.assertEqual(u[-2:-1], self.type2test([3]))
  146. self.assertEqual(u[-1000:1000], u)
  147. self.assertEqual(u[1000:-1000], self.type2test([]))
  148. self.assertEqual(u[:], u)
  149. self.assertEqual(u[1:None], self.type2test([1, 2, 3, 4]))
  150. self.assertEqual(u[None:3], self.type2test([0, 1, 2]))
  151. # Extended slices
  152. self.assertEqual(u[::], u)
  153. self.assertEqual(u[::2], self.type2test([0, 2, 4]))
  154. self.assertEqual(u[1::2], self.type2test([1, 3]))
  155. self.assertEqual(u[::-1], self.type2test([4, 3, 2, 1, 0]))
  156. self.assertEqual(u[::-2], self.type2test([4, 2, 0]))
  157. self.assertEqual(u[3::-2], self.type2test([3, 1]))
  158. self.assertEqual(u[3:3:-2], self.type2test([]))
  159. self.assertEqual(u[3:2:-2], self.type2test([3]))
  160. self.assertEqual(u[3:1:-2], self.type2test([3]))
  161. self.assertEqual(u[3:0:-2], self.type2test([3, 1]))
  162. self.assertEqual(u[::-100], self.type2test([4]))
  163. self.assertEqual(u[100:-100:], self.type2test([]))
  164. self.assertEqual(u[-100:100:], u)
  165. self.assertEqual(u[100:-100:-1], u[::-1])
  166. self.assertEqual(u[-100:100:-1], self.type2test([]))
  167. self.assertEqual(u[-100L:100L:2L], self.type2test([0, 2, 4]))
  168. # Test extreme cases with long ints
  169. a = self.type2test([0,1,2,3,4])
  170. self.assertEqual(a[ -pow(2,128L): 3 ], self.type2test([0,1,2]))
  171. self.assertEqual(a[ 3: pow(2,145L) ], self.type2test([3,4]))
  172. self.assertRaises(TypeError, u.__getslice__)
  173. def test_contains(self):
  174. u = self.type2test([0, 1, 2])
  175. for i in u:
  176. self.assert_(i in u)
  177. for i in min(u)-1, max(u)+1:
  178. self.assert_(i not in u)
  179. self.assertRaises(TypeError, u.__contains__)
  180. def test_contains_fake(self):
  181. class AllEq:
  182. # Sequences must use rich comparison against each item
  183. # (unless "is" is true, or an earlier item answered)
  184. # So instances of AllEq must be found in all non-empty sequences.
  185. def __eq__(self, other):
  186. return True
  187. __hash__ = None # Can't meet hash invariant requirements
  188. self.assert_(AllEq() not in self.type2test([]))
  189. self.assert_(AllEq() in self.type2test([1]))
  190. def test_contains_order(self):
  191. # Sequences must test in-order. If a rich comparison has side
  192. # effects, these will be visible to tests against later members.
  193. # In this test, the "side effect" is a short-circuiting raise.
  194. class DoNotTestEq(Exception):
  195. pass
  196. class StopCompares:
  197. def __eq__(self, other):
  198. raise DoNotTestEq
  199. checkfirst = self.type2test([1, StopCompares()])
  200. self.assert_(1 in checkfirst)
  201. checklast = self.type2test([StopCompares(), 1])
  202. self.assertRaises(DoNotTestEq, checklast.__contains__, 1)
  203. def test_len(self):
  204. self.assertEqual(len(self.type2test()), 0)
  205. self.assertEqual(len(self.type2test([])), 0)
  206. self.assertEqual(len(self.type2test([0])), 1)
  207. self.assertEqual(len(self.type2test([0, 1, 2])), 3)
  208. def test_minmax(self):
  209. u = self.type2test([0, 1, 2])
  210. self.assertEqual(min(u), 0)
  211. self.assertEqual(max(u), 2)
  212. def test_addmul(self):
  213. u1 = self.type2test([0])
  214. u2 = self.type2test([0, 1])
  215. self.assertEqual(u1, u1 + self.type2test())
  216. self.assertEqual(u1, self.type2test() + u1)
  217. self.assertEqual(u1 + self.type2test([1]), u2)
  218. self.assertEqual(self.type2test([-1]) + u1, self.type2test([-1, 0]))
  219. self.assertEqual(self.type2test(), u2*0)
  220. self.assertEqual(self.type2test(), 0*u2)
  221. self.assertEqual(self.type2test(), u2*0L)
  222. self.assertEqual(self.type2test(), 0L*u2)
  223. self.assertEqual(u2, u2*1)
  224. self.assertEqual(u2, 1*u2)
  225. self.assertEqual(u2, u2*1L)
  226. self.assertEqual(u2, 1L*u2)
  227. self.assertEqual(u2+u2, u2*2)
  228. self.assertEqual(u2+u2, 2*u2)
  229. self.assertEqual(u2+u2, u2*2L)
  230. self.assertEqual(u2+u2, 2L*u2)
  231. self.assertEqual(u2+u2+u2, u2*3)
  232. self.assertEqual(u2+u2+u2, 3*u2)
  233. class subclass(self.type2test):
  234. pass
  235. u3 = subclass([0, 1])
  236. self.assertEqual(u3, u3*1)
  237. self.assert_(u3 is not u3*1)
  238. def test_iadd(self):
  239. u = self.type2test([0, 1])
  240. u += self.type2test()
  241. self.assertEqual(u, self.type2test([0, 1]))
  242. u += self.type2test([2, 3])
  243. self.assertEqual(u, self.type2test([0, 1, 2, 3]))
  244. u += self.type2test([4, 5])
  245. self.assertEqual(u, self.type2test([0, 1, 2, 3, 4, 5]))
  246. u = self.type2test("spam")
  247. u += self.type2test("eggs")
  248. self.assertEqual(u, self.type2test("spameggs"))
  249. def test_imul(self):
  250. u = self.type2test([0, 1])
  251. u *= 3
  252. self.assertEqual(u, self.type2test([0, 1, 0, 1, 0, 1]))
  253. def test_getitemoverwriteiter(self):
  254. # Verify that __getitem__ overrides are not recognized by __iter__
  255. class T(self.type2test):
  256. def __getitem__(self, key):
  257. return str(key) + '!!!'
  258. self.assertEqual(iter(T((1,2))).next(), 1)
  259. def test_repeat(self):
  260. for m in xrange(4):
  261. s = tuple(range(m))
  262. for n in xrange(-3, 5):
  263. self.assertEqual(self.type2test(s*n), self.type2test(s)*n)
  264. self.assertEqual(self.type2test(s)*(-4), self.type2test([]))
  265. self.assertEqual(id(s), id(s*1))
  266. def test_bigrepeat(self):
  267. import sys
  268. if sys.maxint <= 2147483647:
  269. x = self.type2test([0])
  270. x *= 2**16
  271. self.assertRaises(MemoryError, x.__mul__, 2**16)
  272. if hasattr(x, '__imul__'):
  273. self.assertRaises(MemoryError, x.__imul__, 2**16)
  274. def test_subscript(self):
  275. a = self.type2test([10, 11])
  276. self.assertEqual(a.__getitem__(0L), 10)
  277. self.assertEqual(a.__getitem__(1L), 11)
  278. self.assertEqual(a.__getitem__(-2L), 10)
  279. self.assertEqual(a.__getitem__(-1L), 11)
  280. self.assertRaises(IndexError, a.__getitem__, -3)
  281. self.assertRaises(IndexError, a.__getitem__, 3)
  282. self.assertEqual(a.__getitem__(slice(0,1)), self.type2test([10]))
  283. self.assertEqual(a.__getitem__(slice(1,2)), self.type2test([11]))
  284. self.assertEqual(a.__getitem__(slice(0,2)), self.type2test([10, 11]))
  285. self.assertEqual(a.__getitem__(slice(0,3)), self.type2test([10, 11]))
  286. self.assertEqual(a.__getitem__(slice(3,5)), self.type2test([]))
  287. self.assertRaises(ValueError, a.__getitem__, slice(0, 10, 0))
  288. self.assertRaises(TypeError, a.__getitem__, 'x')
  289. def test_count(self):
  290. a = self.type2test([0, 1, 2])*3
  291. self.assertEqual(a.count(0), 3)
  292. self.assertEqual(a.count(1), 3)
  293. self.assertEqual(a.count(3), 0)
  294. self.assertRaises(TypeError, a.count)
  295. class BadExc(Exception):
  296. pass
  297. class BadCmp:
  298. def __eq__(self, other):
  299. if other == 2:
  300. raise BadExc()
  301. return False
  302. self.assertRaises(BadExc, a.count, BadCmp())
  303. def test_index(self):
  304. u = self.type2test([0, 1])
  305. self.assertEqual(u.index(0), 0)
  306. self.assertEqual(u.index(1), 1)
  307. self.assertRaises(ValueError, u.index, 2)
  308. u = self.type2test([-2, -1, 0, 0, 1, 2])
  309. self.assertEqual(u.count(0), 2)
  310. self.assertEqual(u.index(0), 2)
  311. self.assertEqual(u.index(0, 2), 2)
  312. self.assertEqual(u.index(-2, -10), 0)
  313. self.assertEqual(u.index(0, 3), 3)
  314. self.assertEqual(u.index(0, 3, 4), 3)
  315. self.assertRaises(ValueError, u.index, 2, 0, -10)
  316. self.assertRaises(TypeError, u.index)
  317. class BadExc(Exception):
  318. pass
  319. class BadCmp:
  320. def __eq__(self, other):
  321. if other == 2:
  322. raise BadExc()
  323. return False
  324. a = self.type2test([0, 1, 2, 3])
  325. self.assertRaises(BadExc, a.index, BadCmp())
  326. a = self.type2test([-2, -1, 0, 0, 1, 2])
  327. self.assertEqual(a.index(0), 2)
  328. self.assertEqual(a.index(0, 2), 2)
  329. self.assertEqual(a.index(0, -4), 2)
  330. self.assertEqual(a.index(-2, -10), 0)
  331. self.assertEqual(a.index(0, 3), 3)
  332. self.assertEqual(a.index(0, -3), 3)
  333. self.assertEqual(a.index(0, 3, 4), 3)
  334. self.assertEqual(a.index(0, -3, -2), 3)
  335. self.assertEqual(a.index(0, -4*sys.maxint, 4*sys.maxint), 2)
  336. self.assertRaises(ValueError, a.index, 0, 4*sys.maxint,-4*sys.maxint)
  337. self.assertRaises(ValueError, a.index, 2, 0, -10)