installer_files/env/Lib/site-packages/attributedict/tests/test_collections.py

# =========================================
#       DEPS
# --------------------------------------

import json

import rootpath

rootpath.append()

from attributedict.tests import helper

import attributedict
import attributedict.collections as collections

AttributeDict = collections.AttributeDict

class CustomAttributeDict(AttributeDict):
    pass


# =========================================
#       TEST
# --------------------------------------

class TestCase(helper.TestCase):

    def test__import(self):
        self.assertModule(collections)

        self.assertTrue(hasattr(attributedict.collections, 'AttributeDict'))
        self.assertEqual(attributedict.collections.AttributeDict, attributedict.collections.AttributeDict)

        self.assertTrue(hasattr(attributedict.collections, 'attributedict'))
        self.assertEqual(attributedict.collections.attributedict, attributedict.collections.AttributeDict)

        self.assertTrue(hasattr(attributedict.collections, 'attrdict'))
        self.assertEqual(attributedict.collections.attrdict, attributedict.collections.attrdict)

    def test_init(self):
        for _AttributeDict in [AttributeDict, CustomAttributeDict]:
            attr_dict = _AttributeDict()

            self.assertTrue(isinstance(attr_dict, dict))
            self.assertTrue(isinstance(attr_dict, attributedict.collections.AttributeDict))
            self.assertTrue(isinstance(attr_dict.__dict__, dict))
            self.assertDeepEqual(attr_dict, {})
            self.assertDeepEqual(attr_dict.__dict__, {})

            attr_dict = _AttributeDict(None)

            self.assertTrue(isinstance(attr_dict, dict))
            self.assertTrue(isinstance(attr_dict, attributedict.collections.AttributeDict))
            self.assertTrue(isinstance(attr_dict.__dict__, dict))
            self.assertDeepEqual(attr_dict, {})
            self.assertDeepEqual(attr_dict.__dict__, {})

            attr_dict = _AttributeDict({})

            self.assertTrue(isinstance(attr_dict, dict))
            self.assertTrue(isinstance(attr_dict, attributedict.collections.AttributeDict))
            self.assertTrue(isinstance(attr_dict.__dict__, dict))
            self.assertDeepEqual(attr_dict, {})
            self.assertDeepEqual(attr_dict.__dict__, {})

            attr_dict = _AttributeDict({'foo': None, '__reserved': True})

            self.assertTrue(isinstance(attr_dict, dict))
            self.assertTrue(isinstance(attr_dict, attributedict.collections.AttributeDict))
            self.assertTrue(isinstance(attr_dict.__dict__, dict))
            self.assertDeepEqual(attr_dict, {'foo': None})
            self.assertDeepEqual(attr_dict.__dict__, {'foo': None})

            attr_dict = _AttributeDict({'foo': {}, '__reserved': True})

            self.assertTrue(isinstance(attr_dict, dict))
            self.assertTrue(isinstance(attr_dict, attributedict.collections.AttributeDict))
            self.assertTrue(isinstance(attr_dict.__dict__, dict))
            self.assertDeepEqual(attr_dict, {'foo': {}})
            self.assertDeepEqual(attr_dict.__dict__, {'foo': _AttributeDict({})})

            attr_dict = _AttributeDict({'foo': {'bar': [1, 2, 3]}, '__reserved': True})

            self.assertTrue(isinstance(attr_dict, dict))
            self.assertTrue(isinstance(attr_dict, attributedict.collections.AttributeDict))
            self.assertTrue(isinstance(attr_dict.__dict__, dict))
            self.assertDeepEqual(attr_dict, {'foo': {'bar': [1, 2, 3]}})
            self.assertDeepEqual(attr_dict.__dict__, {'foo': _AttributeDict({'bar': [1, 2, 3]})})

    def test_update(self):
        for _AttributeDict in [AttributeDict, CustomAttributeDict]:
            attr_dict = _AttributeDict()

            attr_dict.update()

            self.assertTrue(isinstance(attr_dict, dict))
            self.assertTrue(isinstance(attr_dict, attributedict.collections.AttributeDict))
            self.assertTrue(isinstance(attr_dict.__dict__, dict))
            self.assertTrue(isinstance(attr_dict.__dict__, dict))
            self.assertDeepEqual(attr_dict, {})
            self.assertDeepEqual(attr_dict.__dict__, {})

            with self.assertRaises(TypeError):
                attr_dict.update(None)

            attr_dict.update({})

            self.assertTrue(isinstance(attr_dict, dict))
            self.assertTrue(isinstance(attr_dict, attributedict.collections.AttributeDict))
            self.assertTrue(isinstance(attr_dict.__dict__, dict))
            self.assertDeepEqual(attr_dict, {})
            self.assertDeepEqual(attr_dict.__dict__, {})

            attr_dict.update({'foo': None, '__reserved': True})

            self.assertTrue(isinstance(attr_dict, dict))
            self.assertTrue(isinstance(attr_dict, attributedict.collections.AttributeDict))
            self.assertTrue(isinstance(attr_dict.__dict__, dict))
            self.assertDeepEqual(attr_dict, {'foo': None})
            self.assertDeepEqual(attr_dict.__dict__, {'foo': None})

            attr_dict.update({'foo': {}, '__reserved': True})

            self.assertTrue(isinstance(attr_dict, dict))
            self.assertTrue(isinstance(attr_dict, attributedict.collections.AttributeDict))
            self.assertTrue(isinstance(attr_dict.__dict__, dict))
            self.assertDeepEqual(attr_dict, {'foo': {}})
            self.assertDeepEqual(attr_dict.__dict__, {'foo': AttributeDict({})}, exclude_types = {dict, attributedict.collections.AttributeDict})

            attr_dict = _AttributeDict({'foo': {'bar': [1, 2, 3]}, '__reserved': True})

            self.assertTrue(isinstance(attr_dict, dict))
            self.assertTrue(isinstance(attr_dict, attributedict.collections.AttributeDict))
            self.assertTrue(isinstance(attr_dict.__dict__, dict))
            self.assertDeepEqual(attr_dict, {'foo': {'bar': [1, 2, 3]}})
            self.assertDeepEqual(attr_dict.__dict__, {'foo': AttributeDict({'bar': [1, 2, 3]})})

    def test_keys(self):
        for _AttributeDict in [AttributeDict, CustomAttributeDict]:
            attr_dict = _AttributeDict()

            self.assertDeepEqual(list(attr_dict.keys()), [])

            # None

            attr_dict = _AttributeDict(None)

            self.assertDeepEqual(list(attr_dict.keys()), [])

            # {}

            attr_dict = _AttributeDict({})

            self.assertDeepEqual(list(attr_dict.keys()), [])

            # {'foo': NONE}

            attr_dict = _AttributeDict({'foo': None, '__reserved': True})

            self.assertDeepEqual(list(attr_dict.keys()), ['foo'])

            # {'foo': {'bar': [1, 2, 3]}}

            attr_dict = _AttributeDict({'foo': {'bar': [1, 2, 3]}, '__reserved': True})

            self.assertDeepEqual(list(attr_dict.keys()), ['foo'])

            # {'foo': {'bar': [1, 2, 3]}, 'baz': True}

            attr_dict = _AttributeDict({'foo': {'bar': [1, 2, 3]}, 'baz': True, '__reserved': True})

            self.assertDeepEqual(list(attr_dict.keys()), ['foo', 'baz'])

    def test_values(self):
        for _AttributeDict in [AttributeDict, CustomAttributeDict]:
            attr_dict = _AttributeDict()

            self.assertDeepEqual(list(attr_dict.values()), [])

            # None

            attr_dict = _AttributeDict(None)

            self.assertDeepEqual(list(attr_dict.values()), [])

            # {}

            attr_dict = _AttributeDict({})

            self.assertDeepEqual(list(attr_dict.values()), [])

            # {'foo': None}

            attr_dict = _AttributeDict({'foo': None, '__reserved': True})

            self.assertDeepEqual(list(attr_dict.values()), [None])

            # {'foo': {'bar': [1, 2, 3]}}

            attr_dict = _AttributeDict({'foo': {'bar': [1, 2, 3]}, '__reserved': True})

            self.assertDeepEqual(list(attr_dict.values()), [{'bar': [1, 2, 3]}])

            # {'foo': {'bar': [1, 2, 3]}, 'baz': True}

            attr_dict = _AttributeDict({'foo': {'bar': [1, 2, 3]}, 'baz': True, '__reserved': True})

            self.assertDeepEqual(list(attr_dict.values()), [{'bar': [1, 2, 3]}, True])

    def test_get(self):
        for _AttributeDict in [AttributeDict, CustomAttributeDict]:
            attr_dict = _AttributeDict()

            self.assertDeepEqual(attr_dict.get('foo', 'default'), 'default')
            self.assertDeepEqual(attr_dict.get('baz', 'default'), 'default')

            # None

            attr_dict = _AttributeDict(None)

            self.assertDeepEqual(attr_dict.get('foo', 'default'), 'default')
            self.assertDeepEqual(attr_dict.get('baz', 'default'), 'default')

            # {}

            attr_dict = _AttributeDict({})

            self.assertDeepEqual(attr_dict.get('foo', 'default'), 'default')
            self.assertDeepEqual(attr_dict.get('baz', 'default'), 'default')

            # {'foo': None}

            attr_dict = _AttributeDict({'foo': None, '__reserved': True})

            self.assertDeepEqual(attr_dict.get('foo', 'default'), None)
            self.assertDeepEqual(attr_dict.get('baz', 'default'), 'default')

            # {'foo': {'bar': [1, 2, 3]}}

            attr_dict = _AttributeDict({'foo': {'bar': [1, 2, 3]}, '__reserved': True})

            self.assertDeepEqual(attr_dict.get('foo', 'default'), {'bar': [1, 2, 3]})
            self.assertDeepEqual(attr_dict.get('baz', 'default'), 'default')

            # {'foo': {'bar': [1, 2, 3]}, 'baz': True}

            attr_dict = _AttributeDict({'foo': {'bar': [1, 2, 3]}, 'baz': True, '__reserved': True})

            self.assertDeepEqual(attr_dict.get('foo', 'default'), {'bar': [1, 2, 3]})
            self.assertDeepEqual(attr_dict.get('baz', 'default'), True)

    def test_pop(self):
        for _AttributeDict in [AttributeDict, CustomAttributeDict]:
            attr_dict = _AttributeDict()

            self.assertDeepEqual(attr_dict.pop('foo', 'default'), 'default')
            self.assertDeepEqual(attr_dict.pop('baz', 'default'), 'default')

            # None

            attr_dict = _AttributeDict(None)

            self.assertDeepEqual(attr_dict.pop('foo', 'default'), 'default')
            self.assertDeepEqual(attr_dict.pop('baz', 'default'), 'default')

            # {}

            attr_dict = _AttributeDict({})

            self.assertDeepEqual(attr_dict.pop('foo', 'default'), 'default')
            self.assertDeepEqual(attr_dict.pop('baz', 'default'), 'default')

            # {'foo': None}

            attr_dict = _AttributeDict({'foo': None, '__reserved': True})

            self.assertDeepEqual(attr_dict.pop('foo', 'default'), None)
            self.assertDeepEqual(attr_dict.pop('baz', 'default'), 'default')

            # {'foo': {'bar': [1, 2, 3]}}

            attr_dict = _AttributeDict({'foo': {'bar': [1, 2, 3]}, '__reserved': True})

            self.assertDeepEqual(attr_dict.pop('foo', 'default'), {'bar': [1, 2, 3]})
            self.assertDeepEqual(attr_dict.pop('baz', 'default'), 'default')

            # {'foo': {'bar': [1, 2, 3]}, 'baz': True}

            attr_dict = _AttributeDict({'foo': {'bar': [1, 2, 3]}, 'baz': True, '__reserved': True})

            self.assertDeepEqual(attr_dict.pop('foo', 'default'), {'bar': [1, 2, 3]})
            self.assertDeepEqual(attr_dict.pop('baz', 'default'), True)

    def test_setdefault(self):
        for _AttributeDict in [AttributeDict, CustomAttributeDict]:
            attr_dict = _AttributeDict()

            self.assertDeepEqual(attr_dict.setdefault('foo', 'default'), 'default')
            self.assertDeepEqual(attr_dict.get('foo'), 'default')
            self.assertDeepEqual(attr_dict.setdefault('baz', 'default'), 'default')
            self.assertDeepEqual(attr_dict.get('baz'), 'default')

            # None

            attr_dict = _AttributeDict(None)

            self.assertDeepEqual(attr_dict.setdefault('foo', 'default'), 'default')
            self.assertDeepEqual(attr_dict.get('foo'), 'default')
            self.assertDeepEqual(attr_dict.setdefault('baz', 'default'), 'default')
            self.assertDeepEqual(attr_dict.get('baz'), 'default')

            # {}

            attr_dict = _AttributeDict({})

            self.assertDeepEqual(attr_dict.setdefault('foo', 'default'), 'default')
            self.assertDeepEqual(attr_dict.get('foo'), 'default')
            self.assertDeepEqual(attr_dict.setdefault('baz', 'default'), 'default')
            self.assertDeepEqual(attr_dict.get('baz'), 'default')

            # {'foo': None}

            attr_dict = _AttributeDict({'foo': None, '__reserved': True})

            self.assertDeepEqual(attr_dict.setdefault('foo', 'default'), None)
            self.assertDeepEqual(attr_dict.get('foo'), None)
            self.assertDeepEqual(attr_dict.setdefault('baz', 'default'), 'default')
            self.assertDeepEqual(attr_dict.get('baz'), 'default')

            # {'foo': {'bar': [1, 2, 3]}}

            attr_dict = _AttributeDict({'foo': {'bar': [1, 2, 3]}, '__reserved': True})

            self.assertDeepEqual(attr_dict.setdefault('foo', 'default'), {'bar': [1, 2, 3]})
            self.assertDeepEqual(attr_dict.get('foo'), {'bar': [1, 2, 3]})
            self.assertDeepEqual(attr_dict.setdefault('baz', 'default'), 'default')
            self.assertDeepEqual(attr_dict.get('baz'), 'default')

            # {'foo': {'bar': [1, 2, 3]}, 'baz': True}

            attr_dict = _AttributeDict({'foo': {'bar': [1, 2, 3]}, 'baz': True, '__reserved': True})

            self.assertDeepEqual(attr_dict.setdefault('foo', 'default'), {'bar': [1, 2, 3]})
            self.assertDeepEqual(attr_dict.get('foo'), {'bar': [1, 2, 3]})
            self.assertDeepEqual(attr_dict.setdefault('baz', 'default'), True)
            self.assertDeepEqual(attr_dict.get('baz'), True)

    def test_copy(self):
        attr_dict = AttributeDict()

        self.assertDeepEqual(attr_dict.copy(), {})
        self.assertDeepEqual(type(attr_dict.copy()), attributedict.collections.AttributeDict)

        attr_dict = CustomAttributeDict()

        self.assertDeepEqual(attr_dict.copy(), {})
        self.assertDeepEqual(type(attr_dict.copy()), CustomAttributeDict)

        for _AttributeDict in [AttributeDict, CustomAttributeDict]:

            # None

            attr_dict = _AttributeDict(None)

            self.assertDeepEqual(attr_dict.copy(), {})

            # {}

            attr_dict = _AttributeDict({})

            self.assertDeepEqual(attr_dict.copy(), {})

            # {'foo': None}

            attr_dict = _AttributeDict({'foo': None, '__reserved': True})

            self.assertDeepEqual(attr_dict.copy(), {'foo': None})

            # {'foo': {'bar': [1, 2, 3]}}

            attr_dict = _AttributeDict({'foo': {'bar': [1, 2, 3]}, '__reserved': True})

            self.assertDeepEqual(attr_dict.copy(), {'foo': {'bar': [1, 2, 3]}})

            # {'foo': {'bar': [1, 2, 3]}, 'baz': True}

            attr_dict = _AttributeDict({'foo': {'bar': [1, 2, 3]}, 'baz': True, '__reserved': True})

            self.assertDeepEqual(attr_dict.copy(), {'foo': {'bar': [1, 2, 3]}, 'baz': True})

    def test_get_item(self):
        for _AttributeDict in [AttributeDict, CustomAttributeDict]:
            attr_dict = _AttributeDict()

            with self.assertRaises(KeyError):
                attr_dict['foo']

            with self.assertRaises(KeyError):
                attr_dict['foo']['bar']

            with self.assertRaises(KeyError):
                attr_dict['baz']

            # None

            attr_dict = _AttributeDict(None)

            with self.assertRaises(KeyError):
                attr_dict['foo']

            with self.assertRaises(KeyError):
                attr_dict['foo']['bar']

            with self.assertRaises(KeyError):
                attr_dict['baz']

            # {}

            attr_dict = _AttributeDict({})

            with self.assertRaises(KeyError):
                attr_dict['foo']

            with self.assertRaises(KeyError):
                attr_dict['foo']['bar']

            with self.assertRaises(KeyError):
                attr_dict['baz']

            # {'foo': None}

            attr_dict = _AttributeDict({'foo': None, '__reserved': True})

            self.assertDeepEqual(attr_dict['foo'], None)

            with self.assertRaises(TypeError):
                attr_dict['foo']['bar']

            with self.assertRaises(KeyError):
                attr_dict['baz']

            # {'foo': {'bar': [1, 2, 3]}}

            attr_dict = _AttributeDict({'foo': {'bar': [1, 2, 3]}, '__reserved': True})

            self.assertDeepEqual(attr_dict['foo'], {'bar': [1, 2, 3]})
            self.assertDeepEqual(attr_dict['foo']['bar'], [1, 2, 3])

            with self.assertRaises(KeyError):
                attr_dict['baz']

            # {'foo': {'bar': [1, 2, 3]}, 'baz': True}

            attr_dict = _AttributeDict({'foo': {'bar': [1, 2, 3]}, 'baz': True, '__reserved': True})

            self.assertDeepEqual(attr_dict['foo'], {'bar': [1, 2, 3]})
            self.assertDeepEqual(attr_dict['foo']['bar'], [1, 2, 3])
            self.assertDeepEqual(attr_dict['baz'], True)

    def test_set_item(self):
        for _AttributeDict in [AttributeDict, CustomAttributeDict]:
            attr_dict = _AttributeDict()

            with self.assertRaises(KeyError):
                attr_dict['foo']

            with self.assertRaises(KeyError):
                attr_dict['foo']['bar']

            attr_dict['foo'] = None

            self.assertDeepEqual(attr_dict['foo'], None)

            with self.assertRaises(TypeError):
                attr_dict['foo']['bar']

            with self.assertRaises(KeyError):
                attr_dict['baz']

            # None

            attr_dict = _AttributeDict(None)

            with self.assertRaises(KeyError):
                attr_dict['foo']

            with self.assertRaises(KeyError):
                attr_dict['foo']['bar']

            attr_dict['foo'] = None

            self.assertDeepEqual(attr_dict['foo'], None)

            with self.assertRaises(TypeError):
                attr_dict['foo']['bar']

            with self.assertRaises(KeyError):
                attr_dict['baz']

            # {}

            attr_dict = _AttributeDict({})

            with self.assertRaises(KeyError):
                attr_dict['foo']

            with self.assertRaises(KeyError):
                attr_dict['foo']['bar']

            attr_dict['foo'] = None

            self.assertDeepEqual(attr_dict['foo'], None)

            with self.assertRaises(TypeError):
                attr_dict['foo']['bar']

            with self.assertRaises(KeyError):
                attr_dict['baz']

            # {'foo': None}

            attr_dict = _AttributeDict({'foo': None, '__reserved': True})

            self.assertDeepEqual(attr_dict['foo'], None)

            attr_dict['foo'] = {}

            self.assertDeepEqual(attr_dict['foo'], {})

            with self.assertRaises(KeyError):
                attr_dict['foo']['bar']

            with self.assertRaises(KeyError):
                attr_dict['baz']

            # {'foo': {'bar': [1, 2, 3]}}

            attr_dict = _AttributeDict({'foo': {'bar': [1, 2, 3]}, '__reserved': True})

            self.assertDeepEqual(attr_dict['foo'], {'bar': [1, 2, 3]})

            attr_dict['foo'] = {}

            self.assertDeepEqual(attr_dict['foo'], {})

            with self.assertRaises(KeyError):
                attr_dict['foo']['bar']

            with self.assertRaises(KeyError):
                attr_dict['baz']

            # {'foo': {'bar': [1, 2, 3]}, 'baz': True}

            attr_dict = _AttributeDict({'foo': {'bar': [1, 2, 3]}, 'baz': True, '__reserved': True})

            self.assertDeepEqual(attr_dict['foo'], {'bar': [1, 2, 3]})
            self.assertDeepEqual(attr_dict['baz'], True)

            attr_dict['foo'] = {}
            attr_dict['baz'] = {}

            self.assertDeepEqual(attr_dict['foo'], {})

            with self.assertRaises(KeyError):
                attr_dict['foo']['bar']

            self.assertDeepEqual(attr_dict['baz'], {})

    def test_del_item(self):
        for _AttributeDict in [AttributeDict, CustomAttributeDict]:
            attr_dict = _AttributeDict()

            with self.assertRaises(KeyError):
                del attr_dict['foo']

            attr_dict['foo'] = True

            self.assertDeepEqual(attr_dict['foo'], True)

            del attr_dict['foo']

            with self.assertRaises(KeyError):
                attr_dict['foo']

            with self.assertRaises(KeyError):
                attr_dict['foo']['bar']

            with self.assertRaises(Exception):
                attr_dict['baz']

            # None

            attr_dict = _AttributeDict(None)

            with self.assertRaises(KeyError):
                del attr_dict['foo']

            attr_dict['foo'] = True

            self.assertDeepEqual(attr_dict['foo'], True)

            del attr_dict['foo']

            with self.assertRaises(KeyError):
                attr_dict['foo']

            with self.assertRaises(KeyError):
                attr_dict['foo']['bar']

            with self.assertRaises(Exception):
                attr_dict['baz']

            # {}

            attr_dict = _AttributeDict({})

            with self.assertRaises(KeyError):
                del attr_dict['foo']

            attr_dict['foo'] = True

            self.assertDeepEqual(attr_dict['foo'], True)

            del attr_dict['foo']

            with self.assertRaises(KeyError):
                attr_dict['foo']

            with self.assertRaises(KeyError):
                attr_dict['foo']['bar']

            with self.assertRaises(Exception):
                attr_dict['baz']

            # {'foo': None}

            attr_dict = _AttributeDict({'foo': None, '__reserved': True})

            del attr_dict['foo']

            attr_dict['foo'] = True

            self.assertDeepEqual(attr_dict['foo'], True)

            del attr_dict['foo']

            with self.assertRaises(KeyError):
                attr_dict['foo']

            with self.assertRaises(KeyError):
                attr_dict['foo']['bar']

            with self.assertRaises(Exception):
                attr_dict['baz']

            # {'foo': {'bar': [1, 2, 3]}}

            attr_dict = _AttributeDict({'foo': {'bar': [1, 2, 3]}, '__reserved': True})

            del attr_dict['foo']

            attr_dict['foo'] = True

            self.assertDeepEqual(attr_dict['foo'], True)

            del attr_dict['foo']

            with self.assertRaises(KeyError):
                attr_dict['foo']

            with self.assertRaises(KeyError):
                attr_dict['foo']['bar']

            with self.assertRaises(Exception):
                attr_dict['baz']

            # {'foo': {'bar': [1, 2, 3]}, 'baz': True}

            attr_dict = _AttributeDict({'foo': {'bar': [1, 2, 3]}, 'baz': True, '__reserved': True})

            del attr_dict['foo']

            attr_dict['foo'] = True

            self.assertDeepEqual(attr_dict['foo'], True)

            del attr_dict['foo']

            with self.assertRaises(KeyError):
                attr_dict['foo']

            with self.assertRaises(KeyError):
                attr_dict['foo']['bar']

            self.assertDeepEqual(attr_dict['baz'], True)

    def test_get_attribute(self):
        for _AttributeDict in [AttributeDict, CustomAttributeDict]:
            attr_dict = _AttributeDict()

            with self.assertRaises(AttributeError):
                attr_dict.foo

            with self.assertRaises(AttributeError):
                attr_dict.foo.bar

            with self.assertRaises(AttributeError):
                attr_dict.baz

            # None

            attr_dict = _AttributeDict(None)

            with self.assertRaises(AttributeError):
                attr_dict.foo

            with self.assertRaises(AttributeError):
                attr_dict.foo.bar

            with self.assertRaises(AttributeError):
                attr_dict.baz

            # {}

            attr_dict = _AttributeDict({})

            with self.assertRaises(AttributeError):
                attr_dict.foo

            with self.assertRaises(AttributeError):
                attr_dict.foo.bar

            with self.assertRaises(AttributeError):
                attr_dict.baz

            # {'foo': None}

            attr_dict = _AttributeDict({'foo': None, '__reserved': True})

            self.assertDeepEqual(attr_dict.foo, None)

            with self.assertRaises(AttributeError):
                attr_dict.foo.bar

            with self.assertRaises(AttributeError):
                attr_dict.baz

            # {'foo': {'bar': [1, 2, 3]}}

            attr_dict = _AttributeDict({'foo': {'bar': [1, 2, 3]}, '__reserved': True})

            self.assertDeepEqual(attr_dict.foo, {'bar': [1, 2, 3]})
            self.assertDeepEqual(attr_dict.foo.bar, [1, 2, 3])

            with self.assertRaises(AttributeError):
                attr_dict.baz

            # {'foo': {'bar': [1, 2, 3]}, 'baz': True}

            attr_dict = _AttributeDict({'foo': {'bar': [1, 2, 3]}, 'baz': True, '__reserved': True})

            self.assertDeepEqual(attr_dict.foo, {'bar': [1, 2, 3]})
            self.assertDeepEqual(attr_dict.foo.bar, [1, 2, 3])
            self.assertDeepEqual(attr_dict.baz, True)

    def test_set_attribute(self):
        for _AttributeDict in [AttributeDict, CustomAttributeDict]:
            attr_dict = _AttributeDict()

            with self.assertRaises(KeyError):
                attr_dict['foo']

            with self.assertRaises(KeyError):
                attr_dict['foo']['bar']

            attr_dict.foo = None

            self.assertDeepEqual(attr_dict['foo'], None)

            with self.assertRaises(TypeError):
                attr_dict['foo']['bar']

            with self.assertRaises(KeyError):
                attr_dict['baz']

            # None

            attr_dict = _AttributeDict(None)

            with self.assertRaises(KeyError):
                attr_dict['foo']

            with self.assertRaises(KeyError):
                attr_dict['foo']['bar']

            attr_dict.foo = None

            self.assertDeepEqual(attr_dict['foo'], None)

            with self.assertRaises(TypeError):
                attr_dict['foo']['bar']

            with self.assertRaises(KeyError):
                attr_dict['baz']

            # {}

            attr_dict = _AttributeDict({})

            with self.assertRaises(KeyError):
                attr_dict['foo']

            with self.assertRaises(KeyError):
                attr_dict['foo']['bar']

            attr_dict.foo = None

            self.assertDeepEqual(attr_dict['foo'], None)

            with self.assertRaises(TypeError):
                attr_dict['foo']['bar']

            with self.assertRaises(KeyError):
                attr_dict['baz']

            # {'foo': None}

            attr_dict = _AttributeDict({'foo': None, '__reserved': True})

            self.assertDeepEqual(attr_dict['foo'], None)

            attr_dict.foo = {}

            self.assertDeepEqual(attr_dict['foo'], {})

            with self.assertRaises(KeyError):
                attr_dict['foo']['bar']

            with self.assertRaises(KeyError):
                attr_dict['baz']

            # {'foo': {'bar': [1, 2, 3]}}

            attr_dict = _AttributeDict({'foo': {'bar': [1, 2, 3]}, '__reserved': True})

            self.assertDeepEqual(attr_dict['foo'], {'bar': [1, 2, 3]})

            attr_dict.foo = {}

            self.assertDeepEqual(attr_dict['foo'], {})

            with self.assertRaises(KeyError):
                attr_dict['foo']['bar']

            with self.assertRaises(KeyError):
                attr_dict['baz']

            # {'foo': {'bar': [1, 2, 3]}, 'baz': True}

            attr_dict = _AttributeDict({'foo': {'bar': [1, 2, 3]}, 'baz': True, '__reserved': True})

            self.assertDeepEqual(attr_dict['foo'], {'bar': [1, 2, 3]})
            self.assertDeepEqual(attr_dict['baz'], True)

            attr_dict.foo = {}
            attr_dict.baz = {}

            self.assertDeepEqual(attr_dict['foo'], {})

            with self.assertRaises(KeyError):
                attr_dict['foo']['bar']

            self.assertDeepEqual(attr_dict['baz'], {})

    def test_del_attribute(self):
        for _AttributeDict in [AttributeDict, CustomAttributeDict]:
            attr_dict = _AttributeDict()

            with self.assertRaises(KeyError):
                del attr_dict['foo']

            attr_dict['foo'] = True

            self.assertDeepEqual(attr_dict['foo'], True)

            del attr_dict['foo']

            with self.assertRaises(KeyError):
                attr_dict['foo']

            with self.assertRaises(KeyError):
                attr_dict['foo']['bar']

            with self.assertRaises(KeyError):
                attr_dict['baz']

            # None

            attr_dict = _AttributeDict(None)

            with self.assertRaises(AttributeError):
                del attr_dict.foo

            attr_dict['foo'] = True

            self.assertDeepEqual(attr_dict['foo'], True)

            del attr_dict.foo

            with self.assertRaises(KeyError):
                attr_dict['foo']

            with self.assertRaises(KeyError):
                attr_dict['foo']['bar']

            with self.assertRaises(KeyError):
                attr_dict['baz']

            # {}

            attr_dict = _AttributeDict({})

            with self.assertRaises(AttributeError):
                del attr_dict.foo

            attr_dict['foo'] = True

            self.assertDeepEqual(attr_dict['foo'], True)

            del attr_dict.foo

            with self.assertRaises(KeyError):
                attr_dict['foo']

            with self.assertRaises(KeyError):
                attr_dict['foo']['bar']

            with self.assertRaises(KeyError):
                attr_dict['baz']

            # {'foo': None}

            attr_dict = _AttributeDict({'foo': None, '__reserved': True})

            del attr_dict.foo

            attr_dict['foo'] = True

            self.assertDeepEqual(attr_dict['foo'], True)

            del attr_dict.foo

            with self.assertRaises(KeyError):
                attr_dict['foo']

            with self.assertRaises(KeyError):
                attr_dict['foo']['bar']

            with self.assertRaises(KeyError):
                attr_dict['baz']

            # {'foo': {'bar': [1, 2, 3]}}

            attr_dict = _AttributeDict({'foo': {'bar': [1, 2, 3]}, '__reserved': True})

            del attr_dict.foo

            attr_dict['foo'] = True

            self.assertDeepEqual(attr_dict['foo'], True)

            del attr_dict.foo

            with self.assertRaises(KeyError):
                attr_dict['foo']

            with self.assertRaises(KeyError):
                attr_dict['foo']['bar']

            with self.assertRaises(KeyError):
                attr_dict['baz']

            # {'foo': {'bar': [1, 2, 3]}, 'baz': True}

            attr_dict = _AttributeDict({'foo': {'bar': [1, 2, 3]}, 'baz': True, '__reserved': True})

            del attr_dict.foo

            attr_dict['foo'] = True

            self.assertDeepEqual(attr_dict['foo'], True)

            del attr_dict.foo

            with self.assertRaises(KeyError):
                attr_dict['foo']

            with self.assertRaises(KeyError):
                attr_dict['foo']['bar']

            self.assertDeepEqual(attr_dict['baz'], True)

    def test_str(self):
        for _AttributeDict in [AttributeDict, CustomAttributeDict]:
            attr_dict = _AttributeDict()

            self.assertEqual(str(attr_dict), "{}")

            # None

            attr_dict = _AttributeDict(None)

            self.assertEqual(str(attr_dict), "{}")

            # {}

            attr_dict = _AttributeDict({})

            self.assertEqual(str(attr_dict), "{}")

            # {'foo': NONE}

            attr_dict = _AttributeDict({'foo': None, '__reserved': True})

            self.assertEqual(str(attr_dict), "{'foo': None}")

            # {'foo': {'bar': [1, 2, 3]}}

            attr_dict = _AttributeDict({'foo': {'bar': [1, 2, 3]}, '__reserved': True})

            self.assertEqual(str(attr_dict), "{'foo': {'bar': [1, 2, 3]}}")

            # {'foo': {'bar': [1, 2, 3]}, 'baz': True}

            attr_dict = _AttributeDict({'foo': {'bar': [1, 2, 3]}, 'baz': True, '__reserved': True})

            self.assertEqual(str(attr_dict), "{'foo': {'bar': [1, 2, 3]}, 'baz': True}")

    def test_repr(self):
        for _AttributeDict in [AttributeDict, CustomAttributeDict]:
            attr_dict = _AttributeDict()

            self.assertEqual(repr(attr_dict), "{}")

            # None

            attr_dict = _AttributeDict(None)

            self.assertEqual(repr(attr_dict), "{}")

            # {}

            attr_dict = _AttributeDict({})

            self.assertEqual(repr(attr_dict), "{}")

            # {'foo': NONE}

            attr_dict = _AttributeDict({'foo': None, '__reserved': True})

            self.assertEqual(repr(attr_dict), "{'foo': None}")

            # {'foo': {'bar': [1, 2, 3]}}

            attr_dict = _AttributeDict({'foo': {'bar': [1, 2, 3]}, '__reserved': True})

            self.assertEqual(repr(attr_dict), "{'foo': {'bar': [1, 2, 3]}}")

            # {'foo': {'bar': [1, 2, 3]}, 'baz': True}

            attr_dict = _AttributeDict({'foo': {'bar': [1, 2, 3]}, 'baz': True, '__reserved': True})

            self.assertEqual(repr(attr_dict), "{'foo': {'bar': [1, 2, 3]}, 'baz': True}")

    def test_dir(self):
        for _AttributeDict in [AttributeDict, CustomAttributeDict]:
            attr_dict = _AttributeDict()

            with self.assertNotRaises(Exception):
                dir(attr_dict)

    def test_init_encode(self):
        for _AttributeDict in [AttributeDict, CustomAttributeDict]:
            attr_dict = _AttributeDict()

            self.assertDeepEqual(helper.json_encode(attr_dict), '{}')
            # self.assertDeepEqual(helper.json_encode(attr_dict.__dict__), '{}')

            attr_dict = _AttributeDict(None)

            self.assertDeepEqual(helper.json_encode(attr_dict), '{}')
            # self.assertDeepEqual(helper.json_encode(attr_dict.__dict__), '{}')

            attr_dict = _AttributeDict({})

            self.assertDeepEqual(helper.json_encode(attr_dict), '{}')
            # self.assertDeepEqual(helper.json_encode(attr_dict.__dict__), '{}')

            attr_dict = _AttributeDict({'foo': None, '__reserved': True})

            self.assertDeepEqual(helper.json_encode(attr_dict), '{"foo":null}')
            # self.assertDeepEqual(helper.json_encode(attr_dict.__dict__), '{"foo":null}')

            attr_dict = _AttributeDict({'foo': {}, '__reserved': True})

            self.assertDeepEqual(helper.json_encode(attr_dict), '{"foo":{}}')
            # self.assertDeepEqual(helper.json_encode(attr_dict.__dict__), '{"foo":{}}')

            attr_dict = _AttributeDict({'foo': {'bar': [1, 2, 3]}, '__reserved': True})

            self.assertDeepEqual(helper.json_encode(attr_dict), '{"foo":{"bar":[1,2,3]}}')
            # self.assertDeepEqual(helper.json_encode(attr_dict.__dict__), '{"foo":{"bar":[1,2,3]}}')

    def test_key_encode(self):
        for _AttributeDict in [AttributeDict, CustomAttributeDict]:
            attr_dict = _AttributeDict()

            attr_dict['foo'] = None

            self.assertDeepEqual(helper.json_encode(attr_dict), '{"foo":null}')
            self.assertDeepEqual(helper.json_encode(attr_dict.__dict__), '{"foo":null}')

            attr_dict['foo'] = {}

            self.assertDeepEqual(helper.json_encode(attr_dict), '{"foo":{}}')
            self.assertDeepEqual(helper.json_encode(attr_dict.__dict__), '{"foo":{}}')

            attr_dict['foo'] = {'bar': [1, 2, 3], '__reserved': True}

            self.assertDeepEqual(helper.json_encode(attr_dict), '{"foo":{"bar":[1,2,3]}}')
            self.assertDeepEqual(helper.json_encode(attr_dict.__dict__), '{"foo":{"bar":[1,2,3]}}')

            attr_dict['foo']['bar'] = [3, 2, 1]

            self.assertDeepEqual(helper.json_encode(attr_dict), '{"foo":{"bar":[3,2,1]}}')
            self.assertDeepEqual(helper.json_encode(attr_dict.__dict__), '{"foo":{"bar":[3,2,1]}}')

            attr_dict['baz'] = True

            self.assertDeepEqual(helper.json_encode(attr_dict), '{"foo":{"bar":[1,2,3]},"baz":true}')
            self.assertDeepEqual(helper.json_encode(attr_dict.__dict__), '{"foo":{"bar":[1,2,3]},"baz":true}')

            del attr_dict['baz']

            self.assertDeepEqual(helper.json_encode(attr_dict), '{"foo":{"bar":[1,2,3]}}')
            self.assertDeepEqual(helper.json_encode(attr_dict.__dict__), '{"foo":{"bar":[1,2,3]}}')

    def test_key_encode(self):
        for _AttributeDict in [AttributeDict, CustomAttributeDict]:
            attr_dict = _AttributeDict()

            attr_dict.foo = None

            self.assertDeepEqual(helper.json_encode(attr_dict), '{"foo":null}')
            self.assertDeepEqual(helper.json_encode(attr_dict.__dict__), '{"foo":null}')

            attr_dict.foo = {}

            self.assertDeepEqual(helper.json_encode(attr_dict), '{"foo":{}}')
            self.assertDeepEqual(helper.json_encode(attr_dict.__dict__), '{"foo":{}}')

            attr_dict.foo = {'bar': [1, 2, 3], '__reserved': True}

            self.assertDeepEqual(helper.json_encode(attr_dict), '{"foo":{"bar":[1,2,3]}}')
            self.assertDeepEqual(helper.json_encode(attr_dict.__dict__), '{"foo":{"bar":[1,2,3]}}')

            attr_dict.foo.bar = [3, 2, 1]

            self.assertDeepEqual(helper.json_encode(attr_dict), '{"foo":{"bar":[3,2,1]}}')
            self.assertDeepEqual(helper.json_encode(attr_dict.__dict__), '{"foo":{"bar":[3,2,1]}}')

            attr_dict.baz = True

            self.assertDeepEqual(helper.json_encode(attr_dict), '{"foo":{"bar":[3,2,1]},"baz":true}')
            self.assertDeepEqual(helper.json_encode(attr_dict.__dict__), '{"foo":{"bar":[3,2,1]},"baz":true}')

            del attr_dict.baz

            self.assertDeepEqual(helper.json_encode(attr_dict), '{"foo":{"bar":[3,2,1]}}')
            self.assertDeepEqual(helper.json_encode(attr_dict.__dict__), '{"foo":{"bar":[3,2,1]}}')


    def test_fromkeys(self):
        for _AttributeDict in [AttributeDict, CustomAttributeDict]:
            with self.assertRaises(TypeError):
                _AttributeDict().fromkeys()

            attr_dict = _AttributeDict().fromkeys([])

            self.assertDeepEqual(attr_dict, {})

            attr_dict = _AttributeDict().fromkeys(['foo'])

            self.assertDeepEqual(attr_dict, {'foo': None})

            attr_dict = _AttributeDict().fromkeys(['foo'], 'default')

            self.assertDeepEqual(attr_dict, {'foo': 'default'})

            attr_dict = _AttributeDict().fromkeys(['foo', 'bar'])

            self.assertDeepEqual(attr_dict, {'foo': None, 'bar': None})

            attr_dict = _AttributeDict().fromkeys(['foo', 'bar'], 'default')

            self.assertDeepEqual(attr_dict, {'foo': 'default', 'bar': 'default'})

    def test_to_dict(self):
        for _AttributeDict in [AttributeDict, CustomAttributeDict]:
            native_dict = _AttributeDict().to_dict()

            self.assertTrue(isinstance(native_dict, dict))
            self.assertDeepEqual(native_dict, {})

            native_dict = _AttributeDict(None).to_dict()

            self.assertTrue(isinstance(native_dict, dict))
            self.assertDeepEqual(native_dict, {})

            native_dict = _AttributeDict({}).to_dict()

            self.assertTrue(isinstance(native_dict, dict))
            self.assertDeepEqual(native_dict, {})

            native_dict = {'foo': {'bar': 'baz'}}
            native_dict = _AttributeDict(native_dict).to_dict()

            self.assertTrue(isinstance(native_dict, dict))
            self.assertDeepEqual(native_dict, {'foo': {'bar': 'baz'}})

            attr_dict = _AttributeDict({'foo': {'bar': 'baz'}})
            native_dict = _AttributeDict(attr_dict).to_dict()

            self.assertTrue(isinstance(attr_dict, _AttributeDict))
            self.assertTrue(isinstance(native_dict, dict))
            self.assertDeepEqual(native_dict, {'foo': {'bar': 'baz'}})

    def test_class_to_dict(self):
        for _AttributeDict in [AttributeDict, CustomAttributeDict]:
            native_dict = _AttributeDict.dict()

            self.assertTrue(isinstance(native_dict, dict))
            self.assertDeepEqual(native_dict, {})

            native_dict = _AttributeDict.dict(None)

            self.assertTrue(not isinstance(native_dict, dict))
            self.assertDeepEqual(native_dict, None)

            native_dict = _AttributeDict.dict({})

            self.assertTrue(isinstance(native_dict, dict))
            self.assertDeepEqual(native_dict, {})

            native_dict = {'foo': {'bar': 'baz'}}
            native_dict = _AttributeDict.dict(native_dict)

            self.assertTrue(isinstance(native_dict, dict))
            self.assertDeepEqual(native_dict, {'foo': {'bar': 'baz'}})

            attr_dict = _AttributeDict({'foo': {'bar': 'baz'}})
            native_dict = _AttributeDict.dict(attr_dict)

            self.assertTrue(isinstance(attr_dict, _AttributeDict))
            self.assertTrue(isinstance(native_dict, dict))
            self.assertDeepEqual(native_dict, {'foo': {'bar': 'baz'}})


# =========================================
#       MAIN
# --------------------------------------

if __name__ == '__main__':
    helper.run(TestCase)