def test_values():
    assert list(udict().values()) == []
    ud = udict(a='aa')
    assert list(ud.values()) == ['aa']
    ud['b'] = 'bb'
    assert sorted(ud.values()) == ['aa', 'bb']
    ud['a'] = udict(b='ab')

def test_setattr_dotted_key():
    ud = udict(one=udict(two=2))
    setattr(ud, 'one.two', 'onetwo')
    assert ud['one.two'] == 2
    assert getattr(ud, 'one.two') == 'onetwo'
    assert ud['one'] == udict(two=2)
    assert getattr(ud, 'one') == udict(two=2)

def test_setdefault_value_plain_not_present():
    ud = udict()
    child = udict()
    res = ud.setdefault('child', child)
    assert ud['child'] is res
    assert ud['child'] is child
    assert set(ud.keys()) == set(['child'])

def test_clear():
    ud = udict(a='')
    ud.clear()
    assert ud == udict()

    ud = udict({'a.b': ''})
    ud.clear()
    assert ud == udict()

def test_contains_plain_not_present():
    ud = udict(foo='bar')
    assert None not in ud
    assert 'foo' in ud
    assert 'bar' not in ud
    ud.pop('foo')
    assert ud == udict()
    assert 'foo' not in ud

def test_contains_plain_present():
    assert 'foo' in udict(foo='bar')
    assert 'bar' not in udict(foo='bar')
    assert None in udict.fromdict({None: ''})
    ud = udict.fromdict({1: 2, 3: 4})
    assert 1 in ud
    assert 2 not in ud
    assert 3 in ud

def test_setattr_objectstyle():
    ud = udict()
    ud.one = 1
    assert len(ud) == 1
    ud.one = udict()
    ud.one.two = 2
    assert ud.one.two == 2
    assert ud['one']['two'] == 2

def test_todict_nested():
    ud = udict(foo=udict(bar='barbar'))
    d = ud.todict()
    assert isinstance(d['foo'], dict)
    assert not isinstance(d['foo'], udict)
    assert items(d) == [
        ('foo', {'bar': 'barbar'})
    ]

def test_getitem_nested_through_non_dict_typeerror():
    """
    TypeError should be raised when trying to traverse through
    an object that doesn't support `__getitem__`.
    """
    ud = udict(one=udict(two=2))
    with pytest.raises(TypeError):
        ud['one.two.three']

def test_fromkeys_dotted_keys():
    elems = ['a.b', 'a', 'b']
    ud = udict.fromkeys(elems, udict())
    assert items(ud) == [
        ('a', udict()),
        ('a.b', udict()),
        ('b', udict())
    ]

def test_pop_dotted():
    d = {
        'a': udict(b='a->b'),
        'b': 'bb',
        'a.b': 'a.b'
    }
    ud = udict.fromdict(d)
    val = ud.pop('a.b')
    assert val == 'a->b'
    assert ud['a'] == udict()

def test_fromkeys_value():
    ud = udict.fromkeys([], 1)
    assert ud == udict()
    assert ud == dict.fromkeys([], 1)

    ud = udict.fromkeys(range(1), 1)
    assert ud == udict.fromdict({0: 1})
    assert ud == dict.fromkeys(range(1), 1)

    ud = udict.fromkeys(range(10), 0)
    assert ud == udict((i, 0) for i in range(10))
    assert ud == dict.fromkeys(range(10), 0)

def test_init_udict_arg():
    orig = udict({
        'a': {'b': 'a->b'},
        'c': udict({'d': 'c->d'})
    })
    ud = udict(orig)
    elems = items(ud)
    assert elems == [
        ('a', {'b': 'a->b'}),
        ('c', udict(d='c->d'))
    ]
    assert type(elems[0][1]) is dict
    assert type(elems[1][1]) is udict

def test_fromdict_nested_dicts():
    d = {
        'a': {
            'b': {
                'c': 'a->b->c'
            }
        }
    }
    ud = udict.fromdict(d)
    elems = items(ud)
    assert elems == [
        ('a', udict({'b': udict({'c': 'a->b->c'})}))
    ]
    assert type(elems[0][1]) is udict

def test_delitem_second_level_success():
    ud = udict.fromdict({
        'one': {
            'two': 2,
            'blah': {
                'three': 3
            }
        }
    })
    del ud['one.blah']
    assert items(ud) == [
        ('one', udict(two=2))
    ]
    del ud['one.two']
    assert items(ud) == [('one', udict())]

def test_delitem_dotted_key():
    d = {'a.b': ''}
    ud = udict(d)
    with pytest.raises(KeyError):
        del ud['a']
    with pytest.raises(KeyError):
        del ud['a.b']

def test_delattr_dotted_key_present():
    d = {
        'one': {'two': 'one->two'}
    }
    ud = udict(d)
    del ud['one.two']
    assert items(ud) == [('one', {})]

def test_delattr_fail():
    ud = udict(one=1)
    try:
        del ud.two
        pytest.fail()
    except AttributeError as e:
        assert e.args == ("no attribute 'two'",)

def test_keys_dotted():
    d = {
        'a.b': 'a.b',
        'a': {'b': 'a->b'}
    }
    ud = udict(d)
    assert sorted(ud.keys()) == sorted(d.keys())

def test_setitem_second_level_first_missing():
    ud = udict()
    try:
        ud['one.two'] = 2
        pytest.fail()
    except KeyError as e:
        assert e.args == ('one',)