Example #1
0
    def test99(self):
        """Make sure that direct calls to update
           do not clear previous contents"""

        L = DictSet(a='1', b='2')
        L.__init__(b='3', c='4')
        self.assertEqual(d2l(L), s2l('a1b23c4'))
Example #2
0
    def test1(self):
        L = DictSet(s2d('a1 c5678'))
        M = L.copy()
        M.add('d', '9')
        R2 = s2l('a1 c5678 d9')

        self.assertEqual(d2l(M), R2)
Example #3
0
    def test3(self):
        L = DictSet(s2d('a12 c5666788 d12345'))
        g = L.unique_combinations(keys=['c', 'a'])

        self.assertEqual([v for v in g],
                         [['5', '1'], ['5', '2'], ['6', '1'], ['6', '2'],
                          ['7', '1'], ['7', '2'], ['8', '1'], ['8', '2']])
Example #4
0
    def test1(self):
        L = DictSet(s2d('a12 c5666788 d0'))
        g = L.unique_combinations()

        self.assertEqual([v for v in g],
                         [['1', '5'], ['1', '6'], ['1', '7'], ['1', '8'],
                          ['2', '5'], ['2', '6'], ['2', '7'], ['2', '8']])
Example #5
0
    def test2(self):
        L = DictSet(s2d('a12 c5666788 d12345'))
        g = L.unique_combinations(keys=['a', 'c'])

        self.assertEqual([v for v in g],
                         [['1', '5'], ['1', '6'], ['1', '7'], ['1', '8'],
                          ['2', '5'], ['2', '6'], ['2', '7'], ['2', '8']])
Example #6
0
    def test1(self):
        L = DictSet(s2d('a1 c5678'))
        R1 = s2l('a1 c5678')
        M = L.fromkeys(['a', 'b'], '567')

        self.assertEqual(d2l(L), R1)
        self.assertEqual(d2l(M), s2l('a567b567'))
Example #7
0
    def test0(self):
        L = DictSet(s2d('a1 c5678'))
        R1 = s2l('a1 c5678')
        M = L.fromkeys(['a', 'b'])

        self.assertEqual(d2l(L), R1)
        self.assertEqual(d2l(M), s2l('a0b0'))
Example #8
0
    def test0(self):
        L = DictSet(s2d('a1 c5678'))
        R1 = s2l('a1 c5678')
        M = L.copy()
        M.add('d', '9')

        self.assertEqual(d2l(L), R1)
Example #9
0
    def test4(self):
        L = DictSet(s2d('a1 c5666788'))

        with self.assertRaises(TypeError) as cm:
            L.add('d', [])

        self.assertEqual(str(cm.exception), "unhashable type: 'list'")
Example #10
0
    def test0(self):
        L = DictSet(s2d('a1 c5666788'))
        R = s2l('a1 c56  7')

        with self.assertRaises(TypeError) as cm:
            L.__setitem__([], '8')

        self.assertEqual(str(cm.exception), "unhashable type: 'list'")
Example #11
0
    def test1(self):
        L = DictSet(s2d('a1 c5666788'))
        R = s2l('a1 c56  7')

        with self.assertRaises(TypeError) as cm:
            L.__setitem__('a', 42)

        self.assertEqual(str(cm.exception), "'int' object is not iterable")
Example #12
0
    def test4(self):
        L = DictSet(s2d('a12 c568 d123 e78'))
        g = L.unique_combinations()

        self.assertEqual(
            ''.join([''.join(v) for v in g]),
            '151715181527152815371538161716181627162816371638'
            '181718181827182818371838251725182527252825372538'
            '261726182627262826372638281728182827282828372838')
Example #13
0
    def test2(self):
        L = DictSet(s2d('a1        c567889'))
        M = s2d('a123 b324 c5 78')
        R = s2l('a1        c5 78 ')

        self.assertTrue(isinstance(L.intersection(M), DictSet))
        self.assertEqual(d2l(L.intersection(M)), R)
        self.assertEqual(d2l(L), s2l('a1        c56789'))
        self.assertEqual(d2l(M), s2l('a123 b324 c5 78'))
Example #14
0
    def test1(self):
        L = DictSet(s2d(''))
        M = s2d('a1 c5666788')
        R = s2l('')

        self.assertTrue(isinstance(L.difference(M), DictSet))
        self.assertEqual(d2l(L.difference(M)), R)
        self.assertEqual(d2l(L), s2l(''))
        self.assertEqual(d2l(M), s2l('a1 c5666788'))
Example #15
0
    def test0(self):
        L = DictSet(s2d('a1 c5666788 e0'))
        M = s2d('')
        R = s2l('a1 c56  78')

        self.assertTrue(isinstance(L.symmetric_difference(M), DictSet))
        self.assertEqual(d2l(L.symmetric_difference(M)), R)
        self.assertEqual(d2l(L), s2l('a1 c5678 e0'))
        self.assertEqual(d2l(M), s2l(''))
Example #16
0
    def test3(self):
        L = DictSet(s2d('a123 b324'))
        M = s2d('a1        c5666788')
        R = s2l('a123 b324 c56  78')

        self.assertTrue(isinstance(L.union(M), DictSet))
        self.assertEqual(d2l(L.union(M)), R)
        self.assertEqual(d2l(L), s2l('a123 b234'))
        self.assertEqual(d2l(M), s2l('a1        c5666788'))
Example #17
0
    def test3(self):
        L = DictSet(s2d('a123 b324 c5 78 d0'))
        M = s2d('a1        c56788 e0')
        R = s2l('a 23 b324 c 6')

        self.assertTrue(isinstance(L.symmetric_difference(M), DictSet))
        self.assertEqual(d2l(L.symmetric_difference(M)), R)
        self.assertEqual(d2l(L), s2l('a123 b234 c5 78 d0'))
        self.assertEqual(d2l(M), s2l('a1        c56788 e0'))
Example #18
0
    def test3(self):
        L = DictSet(s2d('a123 b324 c5 78'))
        M = s2d('a1        c567889')
        R = s2l('a1        c5 78 ')
        L.intersection_update(M)

        self.assertTrue(isinstance(L, DictSet))
        self.assertTrue(isinstance(M, dict))
        self.assertEqual(d2l(L), R)  # L is updated
        self.assertEqual(d2l(M), s2l('a1        c567889'))
Example #19
0
    def test3(self):
        L = DictSet(s2d('a123 b324 c5 78'))
        M = s2d('a1        c56788')
        R = s2l('a 23 b324 c 6')
        L.symmetric_difference_update(M)

        self.assertTrue(isinstance(L, DictSet))
        self.assertTrue(isinstance(M, dict))
        self.assertEqual(d2l(L), R)  # L is updated
        self.assertEqual(d2l(M), s2l('a1        c56788'))
Example #20
0
    def test1(self):
        L = DictSet(s2d(''))
        M = s2d('a1 c5666788')
        R = s2l('')
        L.difference_update(M)

        self.assertTrue(isinstance(L, DictSet))
        self.assertTrue(isinstance(M, dict))
        self.assertEqual(d2l(L), R)  # L is updated
        self.assertEqual(d2l(M), s2l('a1 c5666788'))
Example #21
0
    def test2(self):
        L = DictSet(s2d('a1        c5666788'))
        M = s2d('a123 b324')
        R = s2l('a123 b324 c56  78')
        L.update(M)

        self.assertTrue(isinstance(L, DictSet))
        self.assertTrue(isinstance(M, dict))
        self.assertEqual(d2l(L), R)  # L is updated
        self.assertEqual(d2l(M), s2l('a123 b324'))
Example #22
0
    def test2(self):
        L = DictSet(s2d('a1 c5678'))
        R1 = s2l('a1 c5678')

        with self.assertRaises(TypeError) as cm:
            M = L.fromkeys(['a', 'b'], 5)

        self.assertEqual(str(cm.exception), "'int' object is not iterable")

        self.assertEqual(d2l(L), R1)
Example #23
0
    def test1(self):
        L = DictSet()

        if sys.version_info[0] == 2:
            R = "DictSet()"
        elif sys.version_info[0] == 3:
            R = "DictSet()"

        self.assertEqual(L.__repr__(), R)
        self.assertEqual(d2l(eval(R)), d2l(L))
Example #24
0
 def test22(self):
     """DictSet(iterable)"""
     self.assertEqual(
         d2l(DictSet([
             ('a', ''),
             ('b', '123'),
             ('c', '45556'),
         ])), s2l('a  0     b   123     c   45  6'))
Example #25
0
    def test1(self):
        L = DictSet(s2d('a123 b456'))
        del L['a']

        with self.assertRaises(KeyError) as cm:
            del L['a']

        self.assertEqual(str(cm.exception), "'a'")
Example #26
0
    def test0(self):
        L = DictSet(s2d('a1c5666788'))
        M = s2d('')
        R = s2l('a1c56  78')

        self.assertTrue(isinstance(L | M, DictSet))
        self.assertEqual(d2l(L | M), R)
        self.assertEqual(d2l(L), s2l('a1c5678'))
        self.assertEqual(d2l(M), s2l(''))
Example #27
0
    def test2(self):
        L = DictSet(s2d('a1        c56788 e0'))
        M = s2d('a123 b324 c5 78 d0')
        R = s2l('a 23 b324 c 6')

        self.assertTrue(isinstance(L ^ M, DictSet))
        self.assertEqual(d2l(L ^ M), R)
        self.assertEqual(d2l(L), s2l('a1 c5678 e0'))
        self.assertEqual(d2l(M), s2l('a123 b324 c5 78 d0'))
Example #28
0
    def test3(self):
        L = DictSet(s2d('a123 b324 c5 78 e0'))
        M = s2d('a1        c567889 d0')
        R = s2l('a1        c5 78 ')

        self.assertTrue(isinstance(L & M, DictSet))
        self.assertEqual(d2l(L & M), R)
        self.assertEqual(d2l(L), s2l('a123 b234 c5 78 e0'))
        self.assertEqual(d2l(M), s2l('a1        c567889 d0'))
Example #29
0
 def test4(self):
     L = DictSet(s2d('a1 c5666788'))
     R = s2l('a1 c56  7')
     L.remove('c', '8')
     if sys.version_info[0] == 2:
         with self.assertRaises(KeyError) as cm:
             L.remove([], '8')
         self.assertEqual(str(cm.exception), '[]')
     elif sys.version_info[0] == 3:
         with self.assertRaises(TypeError) as cm:
             L.remove([], '8')
         self.assertEqual(str(cm.exception), "unhashable type: 'list'")
Example #30
0
    def test7(self):
        L = DictSet(s2d('a123 b456'))
        L.remove('a')

        with self.assertRaises(KeyError) as cm:
            L.remove('a')

        self.assertEqual(str(cm.exception), "'a'")