/Lib/test/test_iter.py

http://unladen-swallow.googlecode.com/ · Python · 886 lines · 696 code · 128 blank · 62 comment · 147 complexity · ab9d4cf7288196b2759758c34c729b36 MD5 · raw file

  1. # Test iterators.
  2. import unittest
  3. from test.test_support import run_unittest, TESTFN, unlink, have_unicode
  4. # Test result of triple loop (too big to inline)
  5. TRIPLETS = [(0, 0, 0), (0, 0, 1), (0, 0, 2),
  6. (0, 1, 0), (0, 1, 1), (0, 1, 2),
  7. (0, 2, 0), (0, 2, 1), (0, 2, 2),
  8. (1, 0, 0), (1, 0, 1), (1, 0, 2),
  9. (1, 1, 0), (1, 1, 1), (1, 1, 2),
  10. (1, 2, 0), (1, 2, 1), (1, 2, 2),
  11. (2, 0, 0), (2, 0, 1), (2, 0, 2),
  12. (2, 1, 0), (2, 1, 1), (2, 1, 2),
  13. (2, 2, 0), (2, 2, 1), (2, 2, 2)]
  14. # Helper classes
  15. class BasicIterClass:
  16. def __init__(self, n):
  17. self.n = n
  18. self.i = 0
  19. def next(self):
  20. res = self.i
  21. if res >= self.n:
  22. raise StopIteration
  23. self.i = res + 1
  24. return res
  25. class IteratingSequenceClass:
  26. def __init__(self, n):
  27. self.n = n
  28. def __iter__(self):
  29. return BasicIterClass(self.n)
  30. class SequenceClass:
  31. def __init__(self, n):
  32. self.n = n
  33. def __getitem__(self, i):
  34. if 0 <= i < self.n:
  35. return i
  36. else:
  37. raise IndexError
  38. # Main test suite
  39. class TestCase(unittest.TestCase):
  40. # Helper to check that an iterator returns a given sequence
  41. def check_iterator(self, it, seq):
  42. res = []
  43. while 1:
  44. try:
  45. val = it.next()
  46. except StopIteration:
  47. break
  48. res.append(val)
  49. self.assertEqual(res, seq)
  50. # Helper to check that a for loop generates a given sequence
  51. def check_for_loop(self, expr, seq):
  52. res = []
  53. for val in expr:
  54. res.append(val)
  55. self.assertEqual(res, seq)
  56. # Test basic use of iter() function
  57. def test_iter_basic(self):
  58. self.check_iterator(iter(range(10)), range(10))
  59. # Test that iter(iter(x)) is the same as iter(x)
  60. def test_iter_idempotency(self):
  61. seq = range(10)
  62. it = iter(seq)
  63. it2 = iter(it)
  64. self.assert_(it is it2)
  65. # Test that for loops over iterators work
  66. def test_iter_for_loop(self):
  67. self.check_for_loop(iter(range(10)), range(10))
  68. # Test several independent iterators over the same list
  69. def test_iter_independence(self):
  70. seq = range(3)
  71. res = []
  72. for i in iter(seq):
  73. for j in iter(seq):
  74. for k in iter(seq):
  75. res.append((i, j, k))
  76. self.assertEqual(res, TRIPLETS)
  77. # Test triple list comprehension using iterators
  78. def test_nested_comprehensions_iter(self):
  79. seq = range(3)
  80. res = [(i, j, k)
  81. for i in iter(seq) for j in iter(seq) for k in iter(seq)]
  82. self.assertEqual(res, TRIPLETS)
  83. # Test triple list comprehension without iterators
  84. def test_nested_comprehensions_for(self):
  85. seq = range(3)
  86. res = [(i, j, k) for i in seq for j in seq for k in seq]
  87. self.assertEqual(res, TRIPLETS)
  88. # Test a class with __iter__ in a for loop
  89. def test_iter_class_for(self):
  90. self.check_for_loop(IteratingSequenceClass(10), range(10))
  91. # Test a class with __iter__ with explicit iter()
  92. def test_iter_class_iter(self):
  93. self.check_iterator(iter(IteratingSequenceClass(10)), range(10))
  94. # Test for loop on a sequence class without __iter__
  95. def test_seq_class_for(self):
  96. self.check_for_loop(SequenceClass(10), range(10))
  97. # Test iter() on a sequence class without __iter__
  98. def test_seq_class_iter(self):
  99. self.check_iterator(iter(SequenceClass(10)), range(10))
  100. # Test two-argument iter() with callable instance
  101. def test_iter_callable(self):
  102. class C:
  103. def __init__(self):
  104. self.i = 0
  105. def __call__(self):
  106. i = self.i
  107. self.i = i + 1
  108. if i > 100:
  109. raise IndexError # Emergency stop
  110. return i
  111. self.check_iterator(iter(C(), 10), range(10))
  112. # Test two-argument iter() with function
  113. def test_iter_function(self):
  114. def spam(state=[0]):
  115. i = state[0]
  116. state[0] = i+1
  117. return i
  118. self.check_iterator(iter(spam, 10), range(10))
  119. # Test two-argument iter() with function that raises StopIteration
  120. def test_iter_function_stop(self):
  121. def spam(state=[0]):
  122. i = state[0]
  123. if i == 10:
  124. raise StopIteration
  125. state[0] = i+1
  126. return i
  127. self.check_iterator(iter(spam, 20), range(10))
  128. # Test exception propagation through function iterator
  129. def test_exception_function(self):
  130. def spam(state=[0]):
  131. i = state[0]
  132. state[0] = i+1
  133. if i == 10:
  134. raise RuntimeError
  135. return i
  136. res = []
  137. try:
  138. for x in iter(spam, 20):
  139. res.append(x)
  140. except RuntimeError:
  141. self.assertEqual(res, range(10))
  142. else:
  143. self.fail("should have raised RuntimeError")
  144. # Test exception propagation through sequence iterator
  145. def test_exception_sequence(self):
  146. class MySequenceClass(SequenceClass):
  147. def __getitem__(self, i):
  148. if i == 10:
  149. raise RuntimeError
  150. return SequenceClass.__getitem__(self, i)
  151. res = []
  152. try:
  153. for x in MySequenceClass(20):
  154. res.append(x)
  155. except RuntimeError:
  156. self.assertEqual(res, range(10))
  157. else:
  158. self.fail("should have raised RuntimeError")
  159. # Test for StopIteration from __getitem__
  160. def test_stop_sequence(self):
  161. class MySequenceClass(SequenceClass):
  162. def __getitem__(self, i):
  163. if i == 10:
  164. raise StopIteration
  165. return SequenceClass.__getitem__(self, i)
  166. self.check_for_loop(MySequenceClass(20), range(10))
  167. # Test a big range
  168. def test_iter_big_range(self):
  169. self.check_for_loop(iter(range(10000)), range(10000))
  170. # Test an empty list
  171. def test_iter_empty(self):
  172. self.check_for_loop(iter([]), [])
  173. # Test a tuple
  174. def test_iter_tuple(self):
  175. self.check_for_loop(iter((0,1,2,3,4,5,6,7,8,9)), range(10))
  176. # Test an xrange
  177. def test_iter_xrange(self):
  178. self.check_for_loop(iter(xrange(10)), range(10))
  179. # Test a string
  180. def test_iter_string(self):
  181. self.check_for_loop(iter("abcde"), ["a", "b", "c", "d", "e"])
  182. # Test a Unicode string
  183. if have_unicode:
  184. def test_iter_unicode(self):
  185. self.check_for_loop(iter(unicode("abcde")),
  186. [unicode("a"), unicode("b"), unicode("c"),
  187. unicode("d"), unicode("e")])
  188. # Test a directory
  189. def test_iter_dict(self):
  190. dict = {}
  191. for i in range(10):
  192. dict[i] = None
  193. self.check_for_loop(dict, dict.keys())
  194. # Test a file
  195. def test_iter_file(self):
  196. f = open(TESTFN, "w")
  197. try:
  198. for i in range(5):
  199. f.write("%d\n" % i)
  200. finally:
  201. f.close()
  202. f = open(TESTFN, "r")
  203. try:
  204. self.check_for_loop(f, ["0\n", "1\n", "2\n", "3\n", "4\n"])
  205. self.check_for_loop(f, [])
  206. finally:
  207. f.close()
  208. try:
  209. unlink(TESTFN)
  210. except OSError:
  211. pass
  212. # Test list()'s use of iterators.
  213. def test_builtin_list(self):
  214. self.assertEqual(list(SequenceClass(5)), range(5))
  215. self.assertEqual(list(SequenceClass(0)), [])
  216. self.assertEqual(list(()), [])
  217. self.assertEqual(list(range(10, -1, -1)), range(10, -1, -1))
  218. d = {"one": 1, "two": 2, "three": 3}
  219. self.assertEqual(list(d), d.keys())
  220. self.assertRaises(TypeError, list, list)
  221. self.assertRaises(TypeError, list, 42)
  222. f = open(TESTFN, "w")
  223. try:
  224. for i in range(5):
  225. f.write("%d\n" % i)
  226. finally:
  227. f.close()
  228. f = open(TESTFN, "r")
  229. try:
  230. self.assertEqual(list(f), ["0\n", "1\n", "2\n", "3\n", "4\n"])
  231. f.seek(0, 0)
  232. self.assertEqual(list(f),
  233. ["0\n", "1\n", "2\n", "3\n", "4\n"])
  234. finally:
  235. f.close()
  236. try:
  237. unlink(TESTFN)
  238. except OSError:
  239. pass
  240. # Test tuples()'s use of iterators.
  241. def test_builtin_tuple(self):
  242. self.assertEqual(tuple(SequenceClass(5)), (0, 1, 2, 3, 4))
  243. self.assertEqual(tuple(SequenceClass(0)), ())
  244. self.assertEqual(tuple([]), ())
  245. self.assertEqual(tuple(()), ())
  246. self.assertEqual(tuple("abc"), ("a", "b", "c"))
  247. d = {"one": 1, "two": 2, "three": 3}
  248. self.assertEqual(tuple(d), tuple(d.keys()))
  249. self.assertRaises(TypeError, tuple, list)
  250. self.assertRaises(TypeError, tuple, 42)
  251. f = open(TESTFN, "w")
  252. try:
  253. for i in range(5):
  254. f.write("%d\n" % i)
  255. finally:
  256. f.close()
  257. f = open(TESTFN, "r")
  258. try:
  259. self.assertEqual(tuple(f), ("0\n", "1\n", "2\n", "3\n", "4\n"))
  260. f.seek(0, 0)
  261. self.assertEqual(tuple(f),
  262. ("0\n", "1\n", "2\n", "3\n", "4\n"))
  263. finally:
  264. f.close()
  265. try:
  266. unlink(TESTFN)
  267. except OSError:
  268. pass
  269. # Test filter()'s use of iterators.
  270. def test_builtin_filter(self):
  271. self.assertEqual(filter(None, SequenceClass(5)), range(1, 5))
  272. self.assertEqual(filter(None, SequenceClass(0)), [])
  273. self.assertEqual(filter(None, ()), ())
  274. self.assertEqual(filter(None, "abc"), "abc")
  275. d = {"one": 1, "two": 2, "three": 3}
  276. self.assertEqual(filter(None, d), d.keys())
  277. self.assertRaises(TypeError, filter, None, list)
  278. self.assertRaises(TypeError, filter, None, 42)
  279. class Boolean:
  280. def __init__(self, truth):
  281. self.truth = truth
  282. def __nonzero__(self):
  283. return self.truth
  284. bTrue = Boolean(1)
  285. bFalse = Boolean(0)
  286. class Seq:
  287. def __init__(self, *args):
  288. self.vals = args
  289. def __iter__(self):
  290. class SeqIter:
  291. def __init__(self, vals):
  292. self.vals = vals
  293. self.i = 0
  294. def __iter__(self):
  295. return self
  296. def next(self):
  297. i = self.i
  298. self.i = i + 1
  299. if i < len(self.vals):
  300. return self.vals[i]
  301. else:
  302. raise StopIteration
  303. return SeqIter(self.vals)
  304. seq = Seq(*([bTrue, bFalse] * 25))
  305. self.assertEqual(filter(lambda x: not x, seq), [bFalse]*25)
  306. self.assertEqual(filter(lambda x: not x, iter(seq)), [bFalse]*25)
  307. # Test max() and min()'s use of iterators.
  308. def test_builtin_max_min(self):
  309. self.assertEqual(max(SequenceClass(5)), 4)
  310. self.assertEqual(min(SequenceClass(5)), 0)
  311. self.assertEqual(max(8, -1), 8)
  312. self.assertEqual(min(8, -1), -1)
  313. d = {"one": 1, "two": 2, "three": 3}
  314. self.assertEqual(max(d), "two")
  315. self.assertEqual(min(d), "one")
  316. self.assertEqual(max(d.itervalues()), 3)
  317. self.assertEqual(min(iter(d.itervalues())), 1)
  318. f = open(TESTFN, "w")
  319. try:
  320. f.write("medium line\n")
  321. f.write("xtra large line\n")
  322. f.write("itty-bitty line\n")
  323. finally:
  324. f.close()
  325. f = open(TESTFN, "r")
  326. try:
  327. self.assertEqual(min(f), "itty-bitty line\n")
  328. f.seek(0, 0)
  329. self.assertEqual(max(f), "xtra large line\n")
  330. finally:
  331. f.close()
  332. try:
  333. unlink(TESTFN)
  334. except OSError:
  335. pass
  336. # Test map()'s use of iterators.
  337. def test_builtin_map(self):
  338. self.assertEqual(map(None, SequenceClass(5)), range(5))
  339. self.assertEqual(map(lambda x: x+1, SequenceClass(5)), range(1, 6))
  340. d = {"one": 1, "two": 2, "three": 3}
  341. self.assertEqual(map(None, d), d.keys())
  342. self.assertEqual(map(lambda k, d=d: (k, d[k]), d), d.items())
  343. dkeys = d.keys()
  344. expected = [(i < len(d) and dkeys[i] or None,
  345. i,
  346. i < len(d) and dkeys[i] or None)
  347. for i in range(5)]
  348. self.assertEqual(map(None, d,
  349. SequenceClass(5),
  350. iter(d.iterkeys())),
  351. expected)
  352. f = open(TESTFN, "w")
  353. try:
  354. for i in range(10):
  355. f.write("xy" * i + "\n") # line i has len 2*i+1
  356. finally:
  357. f.close()
  358. f = open(TESTFN, "r")
  359. try:
  360. self.assertEqual(map(len, f), range(1, 21, 2))
  361. finally:
  362. f.close()
  363. try:
  364. unlink(TESTFN)
  365. except OSError:
  366. pass
  367. # Test zip()'s use of iterators.
  368. def test_builtin_zip(self):
  369. self.assertEqual(zip(), [])
  370. self.assertEqual(zip(*[]), [])
  371. self.assertEqual(zip(*[(1, 2), 'ab']), [(1, 'a'), (2, 'b')])
  372. self.assertRaises(TypeError, zip, None)
  373. self.assertRaises(TypeError, zip, range(10), 42)
  374. self.assertRaises(TypeError, zip, range(10), zip)
  375. self.assertEqual(zip(IteratingSequenceClass(3)),
  376. [(0,), (1,), (2,)])
  377. self.assertEqual(zip(SequenceClass(3)),
  378. [(0,), (1,), (2,)])
  379. d = {"one": 1, "two": 2, "three": 3}
  380. self.assertEqual(d.items(), zip(d, d.itervalues()))
  381. # Generate all ints starting at constructor arg.
  382. class IntsFrom:
  383. def __init__(self, start):
  384. self.i = start
  385. def __iter__(self):
  386. return self
  387. def next(self):
  388. i = self.i
  389. self.i = i+1
  390. return i
  391. f = open(TESTFN, "w")
  392. try:
  393. f.write("a\n" "bbb\n" "cc\n")
  394. finally:
  395. f.close()
  396. f = open(TESTFN, "r")
  397. try:
  398. self.assertEqual(zip(IntsFrom(0), f, IntsFrom(-100)),
  399. [(0, "a\n", -100),
  400. (1, "bbb\n", -99),
  401. (2, "cc\n", -98)])
  402. finally:
  403. f.close()
  404. try:
  405. unlink(TESTFN)
  406. except OSError:
  407. pass
  408. self.assertEqual(zip(xrange(5)), [(i,) for i in range(5)])
  409. # Classes that lie about their lengths.
  410. class NoGuessLen5:
  411. def __getitem__(self, i):
  412. if i >= 5:
  413. raise IndexError
  414. return i
  415. class Guess3Len5(NoGuessLen5):
  416. def __len__(self):
  417. return 3
  418. class Guess30Len5(NoGuessLen5):
  419. def __len__(self):
  420. return 30
  421. self.assertEqual(len(Guess3Len5()), 3)
  422. self.assertEqual(len(Guess30Len5()), 30)
  423. self.assertEqual(zip(NoGuessLen5()), zip(range(5)))
  424. self.assertEqual(zip(Guess3Len5()), zip(range(5)))
  425. self.assertEqual(zip(Guess30Len5()), zip(range(5)))
  426. expected = [(i, i) for i in range(5)]
  427. for x in NoGuessLen5(), Guess3Len5(), Guess30Len5():
  428. for y in NoGuessLen5(), Guess3Len5(), Guess30Len5():
  429. self.assertEqual(zip(x, y), expected)
  430. # Test reduces()'s use of iterators.
  431. def test_builtin_reduce(self):
  432. from operator import add
  433. self.assertEqual(reduce(add, SequenceClass(5)), 10)
  434. self.assertEqual(reduce(add, SequenceClass(5), 42), 52)
  435. self.assertRaises(TypeError, reduce, add, SequenceClass(0))
  436. self.assertEqual(reduce(add, SequenceClass(0), 42), 42)
  437. self.assertEqual(reduce(add, SequenceClass(1)), 0)
  438. self.assertEqual(reduce(add, SequenceClass(1), 42), 42)
  439. d = {"one": 1, "two": 2, "three": 3}
  440. self.assertEqual(reduce(add, d), "".join(d.keys()))
  441. # This test case will be removed if we don't have Unicode
  442. def test_unicode_join_endcase(self):
  443. # This class inserts a Unicode object into its argument's natural
  444. # iteration, in the 3rd position.
  445. class OhPhooey:
  446. def __init__(self, seq):
  447. self.it = iter(seq)
  448. self.i = 0
  449. def __iter__(self):
  450. return self
  451. def next(self):
  452. i = self.i
  453. self.i = i+1
  454. if i == 2:
  455. return unicode("fooled you!")
  456. return self.it.next()
  457. f = open(TESTFN, "w")
  458. try:
  459. f.write("a\n" + "b\n" + "c\n")
  460. finally:
  461. f.close()
  462. f = open(TESTFN, "r")
  463. # Nasty: string.join(s) can't know whether unicode.join() is needed
  464. # until it's seen all of s's elements. But in this case, f's
  465. # iterator cannot be restarted. So what we're testing here is
  466. # whether string.join() can manage to remember everything it's seen
  467. # and pass that on to unicode.join().
  468. try:
  469. got = " - ".join(OhPhooey(f))
  470. self.assertEqual(got, unicode("a\n - b\n - fooled you! - c\n"))
  471. finally:
  472. f.close()
  473. try:
  474. unlink(TESTFN)
  475. except OSError:
  476. pass
  477. if not have_unicode:
  478. def test_unicode_join_endcase(self): pass
  479. # Test iterators with 'x in y' and 'x not in y'.
  480. def test_in_and_not_in(self):
  481. for sc5 in IteratingSequenceClass(5), SequenceClass(5):
  482. for i in range(5):
  483. self.assert_(i in sc5)
  484. for i in "abc", -1, 5, 42.42, (3, 4), [], {1: 1}, 3-12j, sc5:
  485. self.assert_(i not in sc5)
  486. self.assertRaises(TypeError, lambda: 3 in 12)
  487. self.assertRaises(TypeError, lambda: 3 not in map)
  488. d = {"one": 1, "two": 2, "three": 3, 1j: 2j}
  489. for k in d:
  490. self.assert_(k in d)
  491. self.assert_(k not in d.itervalues())
  492. for v in d.values():
  493. self.assert_(v in d.itervalues())
  494. self.assert_(v not in d)
  495. for k, v in d.iteritems():
  496. self.assert_((k, v) in d.iteritems())
  497. self.assert_((v, k) not in d.iteritems())
  498. f = open(TESTFN, "w")
  499. try:
  500. f.write("a\n" "b\n" "c\n")
  501. finally:
  502. f.close()
  503. f = open(TESTFN, "r")
  504. try:
  505. for chunk in "abc":
  506. f.seek(0, 0)
  507. self.assert_(chunk not in f)
  508. f.seek(0, 0)
  509. self.assert_((chunk + "\n") in f)
  510. finally:
  511. f.close()
  512. try:
  513. unlink(TESTFN)
  514. except OSError:
  515. pass
  516. # Test iterators with operator.countOf (PySequence_Count).
  517. def test_countOf(self):
  518. from operator import countOf
  519. self.assertEqual(countOf([1,2,2,3,2,5], 2), 3)
  520. self.assertEqual(countOf((1,2,2,3,2,5), 2), 3)
  521. self.assertEqual(countOf("122325", "2"), 3)
  522. self.assertEqual(countOf("122325", "6"), 0)
  523. self.assertRaises(TypeError, countOf, 42, 1)
  524. self.assertRaises(TypeError, countOf, countOf, countOf)
  525. d = {"one": 3, "two": 3, "three": 3, 1j: 2j}
  526. for k in d:
  527. self.assertEqual(countOf(d, k), 1)
  528. self.assertEqual(countOf(d.itervalues(), 3), 3)
  529. self.assertEqual(countOf(d.itervalues(), 2j), 1)
  530. self.assertEqual(countOf(d.itervalues(), 1j), 0)
  531. f = open(TESTFN, "w")
  532. try:
  533. f.write("a\n" "b\n" "c\n" "b\n")
  534. finally:
  535. f.close()
  536. f = open(TESTFN, "r")
  537. try:
  538. for letter, count in ("a", 1), ("b", 2), ("c", 1), ("d", 0):
  539. f.seek(0, 0)
  540. self.assertEqual(countOf(f, letter + "\n"), count)
  541. finally:
  542. f.close()
  543. try:
  544. unlink(TESTFN)
  545. except OSError:
  546. pass
  547. # Test iterators with operator.indexOf (PySequence_Index).
  548. def test_indexOf(self):
  549. from operator import indexOf
  550. self.assertEqual(indexOf([1,2,2,3,2,5], 1), 0)
  551. self.assertEqual(indexOf((1,2,2,3,2,5), 2), 1)
  552. self.assertEqual(indexOf((1,2,2,3,2,5), 3), 3)
  553. self.assertEqual(indexOf((1,2,2,3,2,5), 5), 5)
  554. self.assertRaises(ValueError, indexOf, (1,2,2,3,2,5), 0)
  555. self.assertRaises(ValueError, indexOf, (1,2,2,3,2,5), 6)
  556. self.assertEqual(indexOf("122325", "2"), 1)
  557. self.assertEqual(indexOf("122325", "5"), 5)
  558. self.assertRaises(ValueError, indexOf, "122325", "6")
  559. self.assertRaises(TypeError, indexOf, 42, 1)
  560. self.assertRaises(TypeError, indexOf, indexOf, indexOf)
  561. f = open(TESTFN, "w")
  562. try:
  563. f.write("a\n" "b\n" "c\n" "d\n" "e\n")
  564. finally:
  565. f.close()
  566. f = open(TESTFN, "r")
  567. try:
  568. fiter = iter(f)
  569. self.assertEqual(indexOf(fiter, "b\n"), 1)
  570. self.assertEqual(indexOf(fiter, "d\n"), 1)
  571. self.assertEqual(indexOf(fiter, "e\n"), 0)
  572. self.assertRaises(ValueError, indexOf, fiter, "a\n")
  573. finally:
  574. f.close()
  575. try:
  576. unlink(TESTFN)
  577. except OSError:
  578. pass
  579. iclass = IteratingSequenceClass(3)
  580. for i in range(3):
  581. self.assertEqual(indexOf(iclass, i), i)
  582. self.assertRaises(ValueError, indexOf, iclass, -1)
  583. # Test iterators with file.writelines().
  584. def test_writelines(self):
  585. f = file(TESTFN, "w")
  586. try:
  587. self.assertRaises(TypeError, f.writelines, None)
  588. self.assertRaises(TypeError, f.writelines, 42)
  589. f.writelines(["1\n", "2\n"])
  590. f.writelines(("3\n", "4\n"))
  591. f.writelines({'5\n': None})
  592. f.writelines({})
  593. # Try a big chunk too.
  594. class Iterator:
  595. def __init__(self, start, finish):
  596. self.start = start
  597. self.finish = finish
  598. self.i = self.start
  599. def next(self):
  600. if self.i >= self.finish:
  601. raise StopIteration
  602. result = str(self.i) + '\n'
  603. self.i += 1
  604. return result
  605. def __iter__(self):
  606. return self
  607. class Whatever:
  608. def __init__(self, start, finish):
  609. self.start = start
  610. self.finish = finish
  611. def __iter__(self):
  612. return Iterator(self.start, self.finish)
  613. f.writelines(Whatever(6, 6+2000))
  614. f.close()
  615. f = file(TESTFN)
  616. expected = [str(i) + "\n" for i in range(1, 2006)]
  617. self.assertEqual(list(f), expected)
  618. finally:
  619. f.close()
  620. try:
  621. unlink(TESTFN)
  622. except OSError:
  623. pass
  624. # Test iterators on RHS of unpacking assignments.
  625. def test_unpack_iter(self):
  626. a, b = 1, 2
  627. self.assertEqual((a, b), (1, 2))
  628. a, b, c = IteratingSequenceClass(3)
  629. self.assertEqual((a, b, c), (0, 1, 2))
  630. try: # too many values
  631. a, b = IteratingSequenceClass(3)
  632. except ValueError:
  633. pass
  634. else:
  635. self.fail("should have raised ValueError")
  636. try: # not enough values
  637. a, b, c = IteratingSequenceClass(2)
  638. except ValueError:
  639. pass
  640. else:
  641. self.fail("should have raised ValueError")
  642. try: # not iterable
  643. a, b, c = len
  644. except TypeError:
  645. pass
  646. else:
  647. self.fail("should have raised TypeError")
  648. a, b, c = {1: 42, 2: 42, 3: 42}.itervalues()
  649. self.assertEqual((a, b, c), (42, 42, 42))
  650. f = open(TESTFN, "w")
  651. lines = ("a\n", "bb\n", "ccc\n")
  652. try:
  653. for line in lines:
  654. f.write(line)
  655. finally:
  656. f.close()
  657. f = open(TESTFN, "r")
  658. try:
  659. a, b, c = f
  660. self.assertEqual((a, b, c), lines)
  661. finally:
  662. f.close()
  663. try:
  664. unlink(TESTFN)
  665. except OSError:
  666. pass
  667. (a, b), (c,) = IteratingSequenceClass(2), {42: 24}
  668. self.assertEqual((a, b, c), (0, 1, 42))
  669. # Test reference count behavior
  670. class C(object):
  671. count = 0
  672. def __new__(cls):
  673. cls.count += 1
  674. return object.__new__(cls)
  675. def __del__(self):
  676. cls = self.__class__
  677. assert cls.count > 0
  678. cls.count -= 1
  679. x = C()
  680. self.assertEqual(C.count, 1)
  681. del x
  682. self.assertEqual(C.count, 0)
  683. l = [C(), C(), C()]
  684. self.assertEqual(C.count, 3)
  685. try:
  686. a, b = iter(l)
  687. except ValueError:
  688. pass
  689. del l
  690. self.assertEqual(C.count, 0)
  691. # Make sure StopIteration is a "sink state".
  692. # This tests various things that weren't sink states in Python 2.2.1,
  693. # plus various things that always were fine.
  694. def test_sinkstate_list(self):
  695. # This used to fail
  696. a = range(5)
  697. b = iter(a)
  698. self.assertEqual(list(b), range(5))
  699. a.extend(range(5, 10))
  700. self.assertEqual(list(b), [])
  701. def test_sinkstate_tuple(self):
  702. a = (0, 1, 2, 3, 4)
  703. b = iter(a)
  704. self.assertEqual(list(b), range(5))
  705. self.assertEqual(list(b), [])
  706. def test_sinkstate_string(self):
  707. a = "abcde"
  708. b = iter(a)
  709. self.assertEqual(list(b), ['a', 'b', 'c', 'd', 'e'])
  710. self.assertEqual(list(b), [])
  711. def test_sinkstate_sequence(self):
  712. # This used to fail
  713. a = SequenceClass(5)
  714. b = iter(a)
  715. self.assertEqual(list(b), range(5))
  716. a.n = 10
  717. self.assertEqual(list(b), [])
  718. def test_sinkstate_callable(self):
  719. # This used to fail
  720. def spam(state=[0]):
  721. i = state[0]
  722. state[0] = i+1
  723. if i == 10:
  724. raise AssertionError, "shouldn't have gotten this far"
  725. return i
  726. b = iter(spam, 5)
  727. self.assertEqual(list(b), range(5))
  728. self.assertEqual(list(b), [])
  729. def test_sinkstate_dict(self):
  730. # XXX For a more thorough test, see towards the end of:
  731. # http://mail.python.org/pipermail/python-dev/2002-July/026512.html
  732. a = {1:1, 2:2, 0:0, 4:4, 3:3}
  733. for b in iter(a), a.iterkeys(), a.iteritems(), a.itervalues():
  734. b = iter(a)
  735. self.assertEqual(len(list(b)), 5)
  736. self.assertEqual(list(b), [])
  737. def test_sinkstate_yield(self):
  738. def gen():
  739. for i in range(5):
  740. yield i
  741. b = gen()
  742. self.assertEqual(list(b), range(5))
  743. self.assertEqual(list(b), [])
  744. def test_sinkstate_range(self):
  745. a = xrange(5)
  746. b = iter(a)
  747. self.assertEqual(list(b), range(5))
  748. self.assertEqual(list(b), [])
  749. def test_sinkstate_enumerate(self):
  750. a = range(5)
  751. e = enumerate(a)
  752. b = iter(e)
  753. self.assertEqual(list(b), zip(range(5), range(5)))
  754. self.assertEqual(list(b), [])
  755. def test_main():
  756. run_unittest(TestCase)
  757. if __name__ == "__main__":
  758. test_main()