예제 #1
0
def test_none():
    '''Test that `CuteSleekValueDict` can handle a value of `None`.'''

    d = {
        1: None,
        2: None,
        (1, ): None,
        (1, (1, )): None,
        sum: None,
        None: None
    }

    csvd = CuteSleekValueDict(counter, d)

    assert sequence_tools.are_equal_regardless_of_order(
        list(csvd.keys()), list(d.keys()))

    assert sequence_tools.are_equal_regardless_of_order(
        list(csvd.values()), list(d.values()))

    assert sequence_tools.are_equal_regardless_of_order(
        list(csvd.items()), list(d.items()))

    for key in csvd.keys():
        assert key in csvd
        assert csvd[key] is None
예제 #2
0
def test_none():
    '''Test that `CuteSleekValueDict` can handle a value of `None`.'''

    d = {
        1: None,
        2: None,
        (1,): None,
        (1, (1,)): None,
        sum: None,
        None: None
    }
    
    csvd = CuteSleekValueDict(
        counter,
        d
    )
    

    assert sequence_tools.are_equal_regardless_of_order(list(csvd.keys()),
                                                        list(d.keys()))
    
    assert sequence_tools.are_equal_regardless_of_order(list(csvd.values()),
                                                        list(d.values()))
    
    assert sequence_tools.are_equal_regardless_of_order(list(csvd.items()),
                                                        list(d.items()))
    

    for key in csvd.keys():
        assert key in csvd
        assert csvd[key] is None
예제 #3
0
    def test_keys(self):
        d = CuteSleekValueDict(null_callback)
        self.assertEqual(d.keys(), [])
        d = CuteSleekValueDict(null_callback, {'a': 1, 'b': 2})
        k = d.keys()
        self.assertTrue(d.has_key('a'))
        self.assertTrue(d.has_key('b'))

        self.assertRaises(TypeError, d.keys, None)
    def test_keys(self):
        d = CuteSleekValueDict(null_callback)
        self.assertEqual(list(d.keys()), [])
        d = CuteSleekValueDict(null_callback, {'a': 1, 'b': 2})
        k = list(d.keys())
        self.assertTrue('a' in d)
        self.assertTrue('b' in d)

        self.assertRaises(TypeError, d.keys, None)
예제 #5
0
    def test_keys(self):
        d = CuteSleekValueDict(null_callback)
        self.assertEqual(list(d.keys()), [])
        d = CuteSleekValueDict(null_callback, {'a': 1, 'b': 2})
        k = list(d.keys())
        self.assertTrue('a' in d)
        self.assertTrue('b' in d)

        self.assertRaises(TypeError, d.keys, None)
    def test_keys(self):
        d = CuteSleekValueDict(null_callback)
        self.assertEqual(d.keys(), [])
        d = CuteSleekValueDict(null_callback, {'a': 1, 'b': 2})
        k = d.keys()
        self.assertTrue(d.has_key('a'))
        self.assertTrue(d.has_key('b'))

        self.assertRaises(TypeError, d.keys, None)
예제 #7
0
    def test_has_key(self):
        d = CuteSleekValueDict(null_callback)
        self.assertFalse(d.has_key('a'))
        d = CuteSleekValueDict(null_callback, {'a': 1, 'b': 2})
        k = d.keys()
        k.sort()
        self.assertEqual(k, ['a', 'b'])

        self.assertRaises(TypeError, d.has_key)
예제 #8
0
        class SimpleUserDict:
            def __init__(self):
                self.d = CuteSleekValueDict(null_callback, {1: 1, 2: 2, 3: 3})

            def keys(self):
                return self.d.keys()

            def __getitem__(self, i):
                return self.d[i]
    def test_has_key(self):
        d = CuteSleekValueDict(null_callback)
        self.assertFalse('a' in d)
        d = CuteSleekValueDict(null_callback, {'a': 1, 'b': 2})
        k = list(d.keys())
        k.sort()
        self.assertEqual(k, ['a', 'b'])

        self.assertRaises(TypeError, d.has_key)
 class SimpleUserDict:
     def __init__(self):
         self.d = CuteSleekValueDict(
             null_callback,
             {1: 1, 2: 2, 3: 3}
         )
     def keys(self):
         return list(self.d.keys())
     def __getitem__(self, i):
         return self.d[i]