Esempio n. 1
0
    def equal_test_1(self):
        d = folded_keys_dict(_TEST_DICT)
        e = folded_keys_dict(_TEST_DICT)

        assert id(d) != id(e)
        assert d == e

        assert d.lang.english.counting == e.lang.english.counting
        assert d.lang.english.counting == {'one': 1, 'two': 2}

        assert d.lang.english.counting.one == e.lang.english.counting.one
        assert d.lang.english.counting.one == 1
Esempio n. 2
0
    def contains_test_1(self):
        d = folded_keys_dict(_TEST_DICT)

        assert 'lang' in d

        assert 'lang.english' in d
        assert 'lang.bahasa' in d
        assert 'lang.russian' not in d

        assert 'lang.english.counting' in d

        assert 'lang.english.counting.one' in d
        assert 'lang.english.counting.two' in d
        assert 'lang.english.counting.tree' not in d

        l = d['lang.bahasa']

        assert 'counting' in l
        assert 'founding' not in l

        l = d['lang.bahasa.counting']

        assert 'satu' in l
        assert 'dua' in l
        assert 'tiga' not in l
Esempio n. 3
0
    def update_test_1(self):
        d = folded_keys_dict(_TEST_DICT)
        e = d['lang.english.counting']
        d.update(e)

        assert 'one' in d
        assert 'two' in d
Esempio n. 4
0
    def ctor_test_4(self):
        d = folded_keys_dict({
            'lang.english': {
                'one': 1,
                'two': 2
            },
            'lang.bahasa': {
                'satu': 1,
                'dua': 2
            }
        })

        assert len(d) == 1
        assert 'lang' in d

        assert len(d['lang']) == 2
        assert 'english' in d['lang']
        assert 'bahasa' in d['lang']

        assert len(d['lang']['english']) == 2
        assert 'one' in d['lang']['english']
        assert 'two' in d['lang']['english']

        assert len(d['lang']['bahasa']) == 2
        assert 'satu' in d['lang']['bahasa']
        assert 'dua' in d['lang']['bahasa']
Esempio n. 5
0
    def attribute_test_1(self):
        d = folded_keys_dict(_TEST_DICT)

        # Access dict items as attributes
        assert d.lang.english.counting.one == 1
        assert d.lang.bahasa.counting.dua == 2

        assert len(d.lang) == 2
Esempio n. 6
0
    def access_test_2(self):
        d = folded_keys_dict(_TEST_DICT)
        e = folded_keys_dict({'lang.russian.counting.raz': 1})

        s = dict_stack(d, e, writable_layer=folded_keys_dict())

        assert len(s['lang']) == 3

        assert len(s['lang.english.counting']) == 2

        assert s['lang.english.counting.one'] == 1
        assert s['lang.english.counting.two'] == 2

        assert s['lang.russian.counting.raz'] == 1

        s['lang.english.counting.three'] = 3
        assert len(s['lang.english.counting']) == 3
Esempio n. 7
0
    def immutable_test_1(self):
        d = folded_keys_dict(_TEST_DICT)

        # Extracting and changing a subtree doesn't affect the source
        e = d['lang.english.counting']
        e.one = 2
        e.two = 1

        assert d['lang.english.counting.one'] == 1
        assert d['lang.english.counting.two'] == 2
Esempio n. 8
0
    def assign_test_2(self):
        d = folded_keys_dict(_TEST_DICT)

        # Use subtree to assign new values indirectory to `d`
        l = d['lang']
        l['russian.counting.raz'] = 1
        l['russian.counting.dva'] = 2

        assert 'lang.russian.counting' in d
        assert d['lang.russian.counting.raz'] == 1
        assert d['lang.russian.counting.dva'] == 2
Esempio n. 9
0
    def assign_test_1(self, capfd, expected_out):
        d = folded_keys_dict(collections.OrderedDict(),
                             node_factory=ordered_dict_node_factory())
        d['lang.english.counting.one'] = 1
        d['lang.english.counting.two'] = 2
        d['lang.bahasa.counting.satu'] = 1
        d['lang.bahasa.counting.dua'] = 2

        # No exceptions/errors expected
        import pprint
        pprint.pprint(d)

        stdout, stderr = capfd.readouterr()
        assert expected_out == stdout
Esempio n. 10
0
    def delete_test_2(self):
        d = folded_keys_dict(_TEST_DICT)

        del d['lang.english.counting.one']
        assert len(d['lang.english.counting']) == 1
        assert 'lang.english.counting.one' not in d
        assert 'lang.english.counting.two' in d

        del d['lang.english.counting']
        assert 'lang.english.counting' not in d

        del d['lang.bahasa']
        assert len(d['lang']) == 1
        assert 'lang.bahasa' not in d
        assert 'lang.bahasa.counting' not in d
        assert 'lang.english' in d
Esempio n. 11
0
    def ctor_test_2(self):
        d = folded_keys_dict({
            'english.one': 1,
            'english.two': 2,
            'bahasa.satu': 1,
            'bahasa.dua': 2
        })
        assert len(d) == 2
        assert 'english' in d
        assert 'bahasa' in d

        assert len(d['english']) == 2
        assert 'one' in d['english']
        assert 'two' in d['english']

        assert len(d['bahasa']) == 2
        assert 'satu' in d['bahasa']
        assert 'dua' in d['bahasa']
Esempio n. 12
0
    def assign_test_1(self, capfd, expected_out):
        p = value_dict_pair(data=collections.OrderedDict())
        d = folded_keys_dict(
            p, node_factory=dict_and_value_node_factory(node_prototype=p))

        d['lang.english.counting.one'] = 1
        assert d.lang.english.counting.one.value == 1

        d['lang.english.counting.one.text'] = 'one'
        assert d.lang.english.counting.one.text == 'one'

        d['lang.english.counting.two.text'] = 'two'
        d['lang.english.counting.two'] = 2

        import pprint
        pprint.pprint(d)

        stdout, stderr = capfd.readouterr()
        assert expected_out == stdout
Esempio n. 13
0
    def access_test_1(self):
        d = folded_keys_dict(_TEST_DICT)

        l = d['lang']
        assert isinstance(l, folded_keys_dict)
        assert len(l) == 2

        l = d['lang.bahasa']
        assert isinstance(l, folded_keys_dict)
        assert len(l) == 1
        assert 'counting' in l

        l = d['lang.bahasa.counting']
        assert isinstance(l, folded_keys_dict)
        assert len(l) == 2
        assert 'satu' in l
        assert 'dua' in l

        assert d['lang.english.counting.one'] == 1
Esempio n. 14
0
    def ctor_test_5(self):
        d = folded_keys_dict(_TEST_DICT)

        assert len(d) == 1
        assert 'lang' in d

        assert len(d['lang']) == 2
        assert 'english' in d['lang']
        assert 'bahasa' in d['lang']

        assert len(d['lang']['english']) == 1
        assert 'counting' in d['lang']['english']

        assert len(d['lang']['bahasa']) == 1
        assert 'counting' in d['lang']['bahasa']

        assert len(d['lang']['english']['counting']) == 2
        assert 'one' in d['lang']['english']['counting']
        assert 'two' in d['lang']['english']['counting']

        assert len(d['lang']['bahasa']['counting']) == 2
        assert 'satu' in d['lang']['bahasa']['counting']
        assert 'dua' in d['lang']['bahasa']['counting']
Esempio n. 15
0
    def assign_test_1(self):
        d = folded_keys_dict({})

        d['lang.english.one'] = 1

        assert len(d['lang']) == 1
        assert len(d['lang']['english']) == 1
        assert len(d['lang.english']) == 1

        assert d['lang']['english']['one'] == 1
        assert d['lang.english']['one'] == 1
        assert d['lang']['english.one'] == 1
        assert d['lang.english.one'] == 1

        d['lang.english.two'] = 2

        assert len(d['lang']) == 1
        assert len(d['lang']['english']) == 2
        assert len(d['lang.english']) == 2

        assert d['lang']['english']['two'] == 2
        assert d['lang.english']['two'] == 2
        assert d['lang']['english.two'] == 2
        assert d['lang.english.two'] == 2
Esempio n. 16
0
 def ctor_test_1(self):
     d = folded_keys_dict({'one': 1, 'two': 2})
     assert len(d) == 2
     assert 'one' in d
     assert 'two' in d
Esempio n. 17
0
    def access_test_2(self, key):
        d = folded_keys_dict(_TEST_DICT)

        with pytest.raises(KeyError):
            try_value = d[key]
Esempio n. 18
0
    def access_test_3(self):
        d = folded_keys_dict(_TEST_DICT)

        with pytest.raises(TypeError):
            try_value = d['lang.english.counting.one.not-existed']
Esempio n. 19
0
    def iterate_test_1(self):
        d = folded_keys_dict(_TEST_DICT)

        # No exceptions/errors expected
        for k, v in d.items():
            print('{}={}'.format(k, v))
Esempio n. 20
0
    def delete_test_1(self, key):
        d = folded_keys_dict(_TEST_DICT)

        with pytest.raises(KeyError):
            del d[key]