def test_zero_items_returns_initial_empty_collection(self):
        collection = CollectingSink()

        transduce(Transducer,
                  sending(),
                  empty_iter(),
                  init=collection())

        self.assertEqual(len(collection), 0)

    def test_two_items_returns_two_element_list(self):
        collection = CollectingSink()

        transduce(Transducer,
                  sending(),
                  [23, 78],
                  init=collection())

        self.assertEqual(list(collection), [23, 78])

    def test_two_items_causes_completion(self):
        singular_sink = SingularSink()

        transduce(Transducer,
                  sending(),
                  [23, 78],
                  init=singular_sink())

        self.assertTrue(singular_sink.has_value)

 def test_ordering_preserves_mutable_sequence_type(self):
     result = transduce(transducer=ordering(),
                        reducer=appending(),
                        iterable=[4, 2, 6, 10, 8],
                        init=deque())
     self.assertIsInstance(result, deque)
     self.assertSequenceEqual(result, deque([2, 4, 6, 8, 10]))

 def test_chained_transducers(self):
     result = transduce(transducer=compose(
                       mapping(lambda x: x*x),
                       filtering(lambda x: x % 5 != 0),
                       taking(6),
                       dropping_while(lambda x: x < 15),
                       distinct()),
                   reducer=appending(),
                   iterable=range(20))
     self.assertSequenceEqual(result, [16, 36, 49])

    def test_completing_with_summing_zero_items_returns_identity(self):

        def add(a, b):
            return a + b

        summing = completing(add, identity=0)

        result = transduce(Transducer,
                           summing,
                           [])
        self.assertEqual(result, 0)

    def test_completing_with_summing_four_items(self):

        def add(a, b):
            return a + b

        summing = completing(add, identity=0)

        result = transduce(Transducer,
                           summing,
                           [4, 2, 1, 9])
        self.assertEqual(result, 16)

    def test_completing_with_multiplying_zero_items_returns_identity(self):

        def multiply(a, b):
            return a * b

        multiplying = completing(multiply, identity=1)

        result = transduce(Transducer,
                           multiplying,
                           [])
        self.assertEqual(result, 1)

    def test_completing_with_multiplying_four_items(self):

        def multiply(a, b):
            return a * b

        multiplying = completing(multiply, identity=1)

        result = transduce(Transducer,
                           multiplying,
                           [4, 2, 1, 9])
        self.assertEqual(result, 72)

 def test_windowing_padding(self):
     result = transduce(transducer=windowing(3, padding=0, window_type=list),
                        reducer=appending(),
                        iterable=[42, 12, 45, 9, 18, 3, 34, 13])
     self.assertListEqual(result,
                          [[0, 0, 42],
                           [0, 42, 12],
                           [42, 12, 45],
                           [12, 45, 9],
                           [45, 9, 18],
                           [9, 18, 3],
                           [18, 3, 34],
                           [3, 34, 13],
                           [34, 13, 0],
                           [13, 0, 0]])

 def test_zero_items_returns_initial_empty_set(self):
     result = transduce(Transducer,
                        adding(),
                        empty_iter())
     self.assertEqual(result, set())

 def test_conjoining_to_non_sequence_raises_type_error(self):
     with self.assertRaises(TypeError):
         transduce(Transducer,
                   conjoining(),
                   (23, 78),
                   init=set())

 def test_conjoining_preserves_initial_sequence_type(self):
     result = transduce(Transducer,
                        conjoining(),
                        (23, 78),
                        init=[])
     self.assertEqual(result, [23, 78])

 def test_zero_items_returns_initial_empty_tuple(self):
     result = transduce(Transducer,
                        conjoining(),
                        empty_iter())
     self.assertEqual(result, tuple())

 def test_two_items_returns_two_element_tuple(self):
     result = transduce(Transducer,
                        conjoining(),
                        [23, 78])
     self.assertEqual(result, (23, 78))

 def test_exactly_one_item(self):
     result = transduce(mapping(lambda x: x*x),
                        expecting_single(),
                        [42])
     self.assertEqual(result, 1764)

 def test_dropping_validation(self):
     with self.assertRaises(ValueError):
         transduce(transducer=dropping(-3),
                   reducer=appending(),
                   iterable=[2, 4, 5, 8, 10])

 def test_scanning_with_init(self):
     result = transduce(transducer=scanning(operator.add, 3),
                        reducer=appending(),
                        iterable=range(5))
     self.assertListEqual(result, [3, 4, 6, 9, 13])

 def test_scanning(self):
     result = transduce(transducer=scanning(operator.add),
                        reducer=appending(),
                        iterable=range(5))
     self.assertListEqual(result, [0, 1, 3, 6, 10])

 def test_enumerating_with_start(self):
     result = transduce(transducer=enumerating(start=3),
                        reducer=appending(),
                        iterable=[2, 4, 6, 8, 10])
     self.assertListEqual(result, [(3, 2), (4, 4), (5, 6), (6, 8), (7, 10)])