test iterator length transparency some functions or methods which accept general iterable arguments have optional more efficient code paths if they know how many items to expect for instance mapfunc iterable will preallocate the exact amount of space required whenever the iterable can report its length the desired invariant is lenitlenlistit a complication is that an iterable and iterator can be the same object to maintain the invariant an iterator needs to dynamically update its length for instance an iterable such as range10 always reports its length as ten but ititerrange10 starts at ten and then goes to nine after nextit having this capability means that map can ignore the distinction between mapfunc iterable and mapfunc iteriterable when the iterable is immutable the implementation can straightforwardly report the original length minus the cumulative number of calls to next this is the case for tuples range objects and itertools repeat some containers become temporarily immutable during iteration this includes dicts sets and collections deque their implementation is equally simple though they need to permanently set their length to zero whenever there is an attempt to iterate after a length mutation the situation slightly more involved whenever an object allows length mutation during iteration lists and sequence iterators are dynamically updatable so if a list is extended during iteration the iterator will continue through the new items if it shrinks to a point before the most recent iteration then no further items are available and the length is reported at zero reversed objects can also be wrapped around mutable objects however any appends after the current position are ignored any other approach leads to confusion and possibly returning the same item more than once the iterators not listed above such as enumerate and the other itertools are not length transparent because they have no way to distinguish between iterables that report static length and iterators whose length changes with each call i e the difference between enumerate abc and enumerateiter abc objects such as deques sets and dictionaries enforce length immutability during iteration concrete type tests types that should not be mutated during iteration types that can mutate during iteration check to make sure exceptions are not suppressed by lengthhint make sure an invalid result doesn t muckup the works objects such as deques sets and dictionaries enforce length immutability during iteration concrete type tests types that should not be mutated during iteration types that can mutate during iteration grow with append ignore append confirm invariant check to make sure exceptions are not suppressed by __length_hint__ make sure an invalid result doesn t muck up the works
import unittest
from itertools import repeat
from collections import deque
from operator import length_hint

n = 10


class TestInvariantWithoutMutations:

    def test_invariant(self):
        it = self.it
        for i in reversed(range(1, n+1)):
            self.assertEqual(length_hint(it), i)
            next(it)
        self.assertEqual(length_hint(it), 0)
        self.assertRaises(StopIteration, next, it)
        self.assertEqual(length_hint(it), 0)

class TestTemporarilyImmutable(TestInvariantWithoutMutations):

    def test_immutable_during_iteration(self):
        
        

        it = self.it
        self.assertEqual(length_hint(it), n)
        next(it)
        self.assertEqual(length_hint(it), n-1)
        self.mutate()
        self.assertRaises(RuntimeError, next, it)
        self.assertEqual(length_hint(it), 0)



class TestRepeat(TestInvariantWithoutMutations, unittest.TestCase):

    def setUp(self):
        self.it = repeat(None, n)

class TestXrange(TestInvariantWithoutMutations, unittest.TestCase):

    def setUp(self):
        self.it = iter(range(n))

class TestXrangeCustomReversed(TestInvariantWithoutMutations, unittest.TestCase):

    def setUp(self):
        self.it = reversed(range(n))

class TestTuple(TestInvariantWithoutMutations, unittest.TestCase):

    def setUp(self):
        self.it = iter(tuple(range(n)))



class TestDeque(TestTemporarilyImmutable, unittest.TestCase):

    def setUp(self):
        d = deque(range(n))
        self.it = iter(d)
        self.mutate = d.pop

class TestDequeReversed(TestTemporarilyImmutable, unittest.TestCase):

    def setUp(self):
        d = deque(range(n))
        self.it = reversed(d)
        self.mutate = d.pop

class TestDictKeys(TestTemporarilyImmutable, unittest.TestCase):

    def setUp(self):
        d = dict.fromkeys(range(n))
        self.it = iter(d)
        self.mutate = d.popitem

class TestDictItems(TestTemporarilyImmutable, unittest.TestCase):

    def setUp(self):
        d = dict.fromkeys(range(n))
        self.it = iter(d.items())
        self.mutate = d.popitem

class TestDictValues(TestTemporarilyImmutable, unittest.TestCase):

    def setUp(self):
        d = dict.fromkeys(range(n))
        self.it = iter(d.values())
        self.mutate = d.popitem

class TestSet(TestTemporarilyImmutable, unittest.TestCase):

    def setUp(self):
        d = set(range(n))
        self.it = iter(d)
        self.mutate = d.pop



class TestList(TestInvariantWithoutMutations, unittest.TestCase):

    def setUp(self):
        self.it = iter(range(n))

    def test_mutation(self):
        d = list(range(n))
        it = iter(d)
        next(it)
        next(it)
        self.assertEqual(length_hint(it), n - 2)
        d.append(n)
        self.assertEqual(length_hint(it), n - 1)  
        d[1:] = []
        self.assertEqual(length_hint(it), 0)
        self.assertEqual(list(it), [])
        d.extend(range(20))
        self.assertEqual(length_hint(it), 0)


class TestListReversed(TestInvariantWithoutMutations, unittest.TestCase):

    def setUp(self):
        self.it = reversed(range(n))

    def test_mutation(self):
        d = list(range(n))
        it = reversed(d)
        next(it)
        next(it)
        self.assertEqual(length_hint(it), n - 2)
        d.append(n)
        self.assertEqual(length_hint(it), n - 2)  
        d[1:] = []
        self.assertEqual(length_hint(it), 0)
        self.assertEqual(list(it), [])  
        d.extend(range(20))
        self.assertEqual(length_hint(it), 0)




class BadLen(object):
    def __iter__(self):
        return iter(range(10))

    def __len__(self):
        raise RuntimeError('hello')


class BadLengthHint(object):
    def __iter__(self):
        return iter(range(10))

    def __length_hint__(self):
        raise RuntimeError('hello')


class NoneLengthHint(object):
    def __iter__(self):
        return iter(range(10))

    def __length_hint__(self):
        return NotImplemented


class TestLengthHintExceptions(unittest.TestCase):

    def test_issue1242657(self):
        self.assertRaises(RuntimeError, list, BadLen())
        self.assertRaises(RuntimeError, list, BadLengthHint())
        self.assertRaises(RuntimeError, [].extend, BadLen())
        self.assertRaises(RuntimeError, [].extend, BadLengthHint())
        b = bytearray(range(10))
        self.assertRaises(RuntimeError, b.extend, BadLen())
        self.assertRaises(RuntimeError, b.extend, BadLengthHint())

    def test_invalid_hint(self):
        
        self.assertEqual(list(NoneLengthHint()), list(range(10)))


if __name__ == "__main__":
    unittest.main()