def test_obj_id(self):
     """Test filter_unique with objects using id as key, which fails."""
     # Two objects which may be equal do not necessary have the same id.
     deduped = set()
     deduper = tools.filter_unique(self.decs, container=deduped, key=id)
     self.assertEqual(len(deduped), 0)
     for _ in self.decs:
         self.assertEqual(id(next(deduper)), deduped.pop())
     self.assertRaises(StopIteration, next, deduper)
     # No. of Decimal with distinct ids != no. of Decimal with distinct value.
     deduper_ids = list(tools.filter_unique(self.decs, key=id))
     self.assertNotEqual(len(deduper_ids), len(set(deduper_ids)))

 def test_process_again(self):
     """Test filter_unique with an ignoring container."""
     deduped = ProcessAgainList()
     deduper = tools.filter_unique(self.ints, container=deduped)
     deduped_out = list(deduper)
     self.assertEqual(deduped_out, [1, 3, 2, 1, 1, 4])
     self.assertEqual(deduped, set([2, 4]))

 def test_skip(self):
     """Test filter_unique with a container that skips items."""
     deduped = SkipList()
     deduper = tools.filter_unique(self.ints, container=deduped)
     deduped_out = list(deduper)
     self.assertCountEqual(deduped, deduped_out)
     self.assertEqual(deduped, set([2, 4]))

    def test_stop(self):
        """Test filter_unique with an ignoring container."""
        deduped = ContainsStopList()
        deduped.stop_list = [2]
        deduper = tools.filter_unique(self.ints, container=deduped)
        deduped_out = list(deduper)
        self.assertCountEqual(deduped, deduped_out)
        self.assertEqual(deduped, set([1, 3]))

        # And it should not resume
        self.assertRaises(StopIteration, next, deduper)

        deduped = AddStopList()
        deduped.stop_list = [4]
        deduper = tools.filter_unique(self.ints, container=deduped)
        deduped_out = list(deduper)
        self.assertCountEqual(deduped, deduped_out)
        self.assertEqual(deduped, set([1, 2, 3]))

        # And it should not resume
        self.assertRaises(StopIteration, next, deduper)

 def test_for_resumable(self):
     """Test filter_unique is resumable after a for loop."""
     gen2 = tools.filter_unique(self.ints)
     deduped = []
     for item in gen2:
         deduped.append(item)
         if len(deduped) == 3:
             break
     self.assertEqual(deduped, [1, 3, 2])
     last = next(gen2)
     self.assertEqual(last, 4)
     self.assertRaises(StopIteration, next, gen2)

 def test_str_id(self):
     """Test str using id as key fails on Python 3."""
     # str in Python 3 behave like objects.
     deduped = set()
     deduper = tools.filter_unique(self.strs, container=deduped, key=id)
     self._test_dedup_str(deduped, deduper, id)

 def test_str_hash(self):
     """Test filter_unique with str using hash as key."""
     deduped = set()
     deduper = tools.filter_unique(self.strs, container=deduped, key=hash)
     self._test_dedup_str(deduped, deduper, hash)

 def test_str(self):
     """Test filter_unique with str."""
     deduped = set()
     deduper = tools.filter_unique(self.strs, container=deduped)
     self._test_dedup_str(deduped, deduper)

 def test_obj_id(self):
     """Test filter_unique with objects using id as key, which fails."""
     # Two objects which may be equal do not have the same id.
     deduped = set()
     deduper = tools.filter_unique(self.decs, container=deduped, key=id)
     self._test_dedup_int(deduped, deduper, id)

 def test_obj_hash(self):
     """Test filter_unique with objects using hash as key."""
     deduped = set()
     deduper = tools.filter_unique(self.decs, container=deduped, key=hash)
     self._test_dedup_int(deduped, deduper, hash)

 def test_obj(self):
     """Test filter_unique with objects."""
     deduped = set()
     deduper = tools.filter_unique(self.decs, container=deduped)
     self._test_dedup_int(deduped, deduper)

 def test_int_id(self):
     """Test filter_unique with ints using id as key."""
     deduped = set()
     deduper = tools.filter_unique(self.ints, container=deduped, key=id)
     self._test_dedup_int(deduped, deduper, id)

 def test_OrderedDict(self):
     """Test filter_unique with a OrderedDict."""
     deduped = tools.OrderedDict()
     deduper = tools.filter_unique(self.ints, container=deduped)
     self._test_dedup_int(deduped, deduper)

 def test_set(self):
     """Test filter_unique with a set."""
     deduped = set()
     deduper = tools.filter_unique(self.ints, container=deduped)
     self._test_dedup_int(deduped, deduper)