예제 #1
0
 def test_conversions(self):
     # Convert to: set, list, dict
     s = 'she sells sea shells by the sea shore'
     self.assertEqual(sorted(Counter(s).elements()), sorted(s))
     self.assertEqual(sorted(Counter(s)), sorted(set(s)))
     self.assertEqual(dict(Counter(s)), dict(Counter(s).items()))
     self.assertEqual(set(Counter(s)), set(s))
예제 #2
0
 def test_basics(self):
     c = Counter('abcaba')
     self.assertEqual(c, Counter({'a':3 , 'b': 2, 'c': 1}))
     self.assertEqual(c, Counter(a=3, b=2, c=1))
     self.assertIsInstance(c, dict)
     self.assertIsInstance(c, Mapping)
     self.assertTrue(issubclass(Counter, dict))
     self.assertTrue(issubclass(Counter, Mapping))
     self.assertEqual(len(c), 3)
     self.assertEqual(sum(c.values()), 6)
     self.assertEqual(sorted(c.values()), [1, 2, 3])
     self.assertEqual(sorted(c.keys()), ['a', 'b', 'c'])
     self.assertEqual(sorted(c), ['a', 'b', 'c'])
     self.assertEqual(sorted(c.items()),
                      [('a', 3), ('b', 2), ('c', 1)])
     self.assertEqual(c['b'], 2)
     self.assertEqual(c['z'], 0)
     self.assertEqual(c.__contains__('c'), True)
     self.assertEqual(c.__contains__('z'), False)
     self.assertEqual(c.get('b', 10), 2)
     self.assertEqual(c.get('z', 10), 10)
     self.assertEqual(c, dict(a=3, b=2, c=1))
     self.assertEqual(repr(c), "Counter({'a': 3, 'b': 2, 'c': 1})")
     self.assertEqual(c.most_common(), [('a', 3), ('b', 2), ('c', 1)])
     for i in range(5):
         self.assertEqual(c.most_common(i),
                          [('a', 3), ('b', 2), ('c', 1)][:i])
     self.assertEqual(''.join(sorted(c.elements())), 'aaabbc')
     c['a'] += 1         # increment an existing value
     c['b'] -= 2         # sub existing value to zero
     del c['c']          # remove an entry
     del c['c']          # make sure that del doesn't raise KeyError
     c['d'] -= 2         # sub from a missing value
     c['e'] = -5         # directly assign a missing value
     c['f'] += 4         # add to a missing value
     self.assertEqual(c, dict(a=4, b=0, d=-2, e=-5, f=4))
     self.assertEqual(''.join(sorted(c.elements())), 'aaaaffff')
     self.assertEqual(c.pop('f'), 4)
     self.assertNotIn('f', c)
     for i in range(3):
         elem, cnt = c.popitem()
         self.assertNotIn(elem, c)
     c.clear()
     self.assertEqual(c, {})
     self.assertEqual(repr(c), 'Counter()')
     self.assertRaises(NotImplementedError, Counter.fromkeys, 'abc')
     self.assertRaises(TypeError, hash, c)
     c.update(dict(a=5, b=3))
     c.update(c=1)
     c.update(Counter('a' * 50 + 'b' * 30))
     c.update()          # test case with no args
     c.__init__('a' * 500 + 'b' * 300)
     c.__init__('cdc')
     c.__init__()
     self.assertEqual(c, dict(a=555, b=333, c=3, d=1))
     self.assertEqual(c.setdefault('d', 5), 1)
     self.assertEqual(c['d'], 1)
     self.assertEqual(c.setdefault('e', 5), 5)
     self.assertEqual(c['e'], 5)
예제 #3
0
 def test_inplace_operations(self):
     elements = 'abcd'
     for i in range(1000):
         # test random pairs of multisets
         p = Counter(dict((elem, randrange(-2, 4)) for elem in elements))
         p.update(e=1, f=-1, g=0)
         q = Counter(dict((elem, randrange(-2, 4)) for elem in elements))
         q.update(h=1, i=-1, j=0)
         for inplace_op, regular_op in [
             (Counter.__iadd__, Counter.__add__),
             (Counter.__isub__, Counter.__sub__),
             (Counter.__ior__, Counter.__or__),
             (Counter.__iand__, Counter.__and__),
         ]:
             c = p.copy()
             c_id = id(c)
             regular_result = regular_op(c, q)
             inplace_result = inplace_op(c, q)
             self.assertEqual(inplace_result, regular_result)
             self.assertEqual(id(inplace_result), c_id)
예제 #4
0
 def test_subtract(self):
     c = Counter(a=-5, b=0, c=5, d=10, e=15,g=40)
     c.subtract(a=1, b=2, c=-3, d=10, e=20, f=30, h=-50)
     self.assertEqual(c, Counter(a=-6, b=-2, c=8, d=0, e=-5, f=-30, g=40, h=50))
     c = Counter(a=-5, b=0, c=5, d=10, e=15,g=40)
     c.subtract(Counter(a=1, b=2, c=-3, d=10, e=20, f=30, h=-50))
     self.assertEqual(c, Counter(a=-6, b=-2, c=8, d=0, e=-5, f=-30, g=40, h=50))
     c = Counter('aaabbcd')
     c.subtract('aaaabbcce')
     self.assertEqual(c, Counter(a=-1, b=0, c=-1, d=1, e=-1))
예제 #5
0
 def test_copying(self):
     # Check that counters are copyable, deepcopyable, picklable, and
     #have a repr/eval round-trip
     words = Counter('which witch had which witches wrist watch'.split())
     update_test = Counter()
     update_test.update(words)
     for i, dup in enumerate([
             words.copy(),
             copy.copy(words),
             copy.deepcopy(words),
             pickle.loads(pickle.dumps(words, 0)),
             pickle.loads(pickle.dumps(words, 1)),
             pickle.loads(pickle.dumps(words, 2)),
             pickle.loads(pickle.dumps(words, -1)),
             eval(repr(words)),
             update_test,
             Counter(words),
     ]):
         msg = (i, dup, words)
         self.assertTrue(dup is not words)
         self.assertEqual(dup, words)
         self.assertEqual(len(dup), len(words))
         self.assertEqual(type(dup), type(words))
예제 #6
0
    def test_multiset_operations(self):
        # Verify that adding a zero counter will strip zeros and negatives
        c = Counter(a=10, b=-2, c=0) + Counter()
        self.assertEqual(dict(c), dict(a=10))

        elements = 'abcd'
        for i in range(1000):
            # test random pairs of multisets
            p = Counter(dict((elem, randrange(-2, 4)) for elem in elements))
            p.update(e=1, f=-1, g=0)
            q = Counter(dict((elem, randrange(-2, 4)) for elem in elements))
            q.update(h=1, i=-1, j=0)
            for counterop, numberop in [
                (Counter.__add__, lambda x, y: max(0, x + y)),
                (Counter.__sub__, lambda x, y: max(0, x - y)),
                (Counter.__or__, lambda x, y: max(0, x, y)),
                (Counter.__and__, lambda x, y: max(0, min(x, y))),
            ]:
                result = counterop(p, q)
                for x in elements:
                    self.assertEqual(numberop(p[x], q[x]), result[x],
                                     (counterop, x, p, q))
                # verify that results exclude non-positive counts
                self.assertTrue(x > 0 for x in result.values())

        elements = 'abcdef'
        for i in range(100):
            # verify that random multisets with no repeats are exactly like sets
            p = Counter(dict((elem, randrange(0, 2)) for elem in elements))
            q = Counter(dict((elem, randrange(0, 2)) for elem in elements))
            for counterop, setop in [
                (Counter.__sub__, set.__sub__),
                (Counter.__or__, set.__or__),
                (Counter.__and__, set.__and__),
            ]:
                counter_result = counterop(p, q)
                set_result = setop(set(p.elements()), set(q.elements()))
                self.assertEqual(counter_result, dict.fromkeys(set_result, 1))
예제 #7
0
 def test_repr_nonsortable(self):
     c = Counter(a=2, b=None)
     r = repr(c)
     self.assertIn("'a': 2", r)
     self.assertIn("'b': None", r)
예제 #8
0
 def test_unary(self):
     c = Counter(a=-5, b=0, c=5, d=10, e=15, g=40)
     self.assertEqual(dict(+c), dict(c=5, d=10, e=15, g=40))
     self.assertEqual(dict(-c), dict(a=5))
예제 #9
0
 def test_invariant_for_the_in_operator(self):
     c = Counter(a=10, b=-2, c=0)
     for elem in c:
         self.assertTrue(elem in c)
         self.assertIn(elem, c)
예제 #10
0
 def get(self, key, default):
     self.called = True
     return Counter.get(self, key, default)
예제 #11
0
 def __init__(self, *args, **kwds):
     self.called = False
     Counter.__init__(self, *args, **kwds)
예제 #12
0
 def __setitem__(self, key, value):
     self.called = True
     Counter.__setitem__(self, key, value)
예제 #13
0
 def get(self, key, default):
     self.called = True
     return Counter.get(self, key, default)
예제 #14
0
 def __init__(self, *args, **kwds):
     self.called = False
     Counter.__init__(self, *args, **kwds)
예제 #15
0
 def __setitem__(self, key, value):
     self.called = True
     Counter.__setitem__(self, key, value)