def run_ranges_tst(ranges, expected_tagmap, expected_axislist): if isinstance(ranges, list): ranges = dict([("tag%d" % n, tagrange) for n, tagrange in enumerate(ranges)]) tagmap = Ranges.calculateaxes(ranges) DictUtils.assert_dicts_equal(tagmap, expected_tagmap) axismap = Ranges.tagmaptoaxismap(tagmap) axislist = Ranges.sortaxes(axismap) assert axislist == expected_axislist
def test_missing_attr(self): d = DictUtils.setattrdict() d.VaLuE = 5 assert "HeGeMoNy" not in d.keys() assert d.get("HeGeMoNy", 5) == 5 assert raises(KeyError, d.__getitem__, "HeGeMoNy") assert getattr(d, "HeGeMoNy", 9) == 9 assert raises(AttributeError, getattr, d, "HeGeMoNy")
def test_default_attr(self): d = DictUtils.attrdict() d.VaLuE = 5 d.set_default_value(32) assert "HeGeMoNy" not in d.keys() assert d.get("HeGeMoNy", 5) == 5 assert raises(KeyError, d.__getitem__, "HeGeMoNy") assert getattr(d, "HeGeMoNy") == 32 assert getattr(d, "HeGeMoNy", 9) == 32
def test_set_attrs(self): """tests setting attributes both dict- and object-style""" d = DictUtils.setattrdict() d["VaLuE"] = 5 assert d["VaLuE"] == 5 assert d.VaLuE == 5 d.ReDeeM = "price" assert d["ReDeeM"] == "price" assert d.ReDeeM == "price"
def test_key_and_value_ordering(self): k = [5,1,2,3,7,6] v = ["a","b","c","d","e","f"] d = DictUtils.ordereddict(zip(k,v)) assert d.keys() == k assert d.values() == v assert d.items() == zip(k,v) assert list(d.iterkeys()) == k assert list(d.itervalues()) == v assert list(d.iteritems()) == zip(k,v)
def test_dict(self): # Make an empty one cleand = DictUtils.ordereddict() # Make one from another k = [5, 1, 2, 3, 7, 6] v = ["a", "b", "c", "d", "e", "f"] d = DictUtils.ordereddict(DictUtils.ordereddict(list(zip(k, v)))) def bad_dict(): d = DictUtils.ordereddict(*k) d.setdefault(5, "g") assert d.get(5, None) == "a" d.update(t="g") assert d["t"] == "g" d.update([(7, "g")]) assert d[7] == "g" d.update({8: "h"}) assert d[8] == "h" assert raises(TypeError, bad_dict) del d[1] assert d.keys() == [5, 2, 3, 7, 6, "t", 8] copyd = d.copy() assert list(copyd.keys()) == [5, 2, 3, 7, 6, "t", 8] assert list(copyd.values()) == ["a", "c", "d", "g", "f", "g", "h"] assert list(copyd.items()) assert raises(KeyError, cleand.popitem) assert copyd.popitem() == (8, "h") assert copyd.pop(9, "default") == "default" assert copyd.pop(3) == "d" assert copyd.keys() == [5, 2, 7, 6, "t"] copyd.clear() assert copyd.keys() == []
def test_setting(self): k = [5,1,2,3,7,6] v = ["a","b","c","d","e","f"] d = DictUtils.ordereddict(zip(k,v)) d.setdefault(8,"g") k.append(8) v.append("g") assert d.keys() == k assert d.values() == v assert d.items() == zip(k,v) assert list(d.iterkeys()) == k assert list(d.itervalues()) == v assert list(d.iteritems()) == zip(k,v)
def test_assert_dicts_equal(self): d1 = {1:2, 3:4} d2 = {1:2, 3:4} d3 = {1:3, 3:5} d4 = {2:1, 4:3} DictUtils.assert_dicts_equal(d1, d2) DictUtils.assert_dicts_not_equal(d1, d3) DictUtils.assert_dicts_not_equal(d1, d4)
def setup_class(cls): for prefix, dims in cls.DIMENSIONS.iteritems(): # call dim setup methods for dim in dims: dim.setup() # create attribute dictionaries for use as self.iterdata values for varnames in cls.permuteVars(prefix): cls._METHOD_DATA[(prefix,tuple(varnames))] = DictUtils.attrdict() # call prefix's class setup methods setupmeth = getattr(cls,"setup_class_" + prefix,None) if callable(setupmeth): for varnames in cls.permuteVars(prefix): cls.iterdata = cls._METHOD_DATA[(prefix,tuple(varnames))] args = cls.getMethodArgs(prefix,varnames) try: setupmeth(*args) except Exception as e: cls.iterdata['_iterativetest_setup_class_failed'] = (e,sys.exc_info()[2]) del cls.iterdata
def test_dict(self): """tests the normal dict functions, with thecidict peculiarities""" d = DictUtils.cidict({'VaLuE': 5}) def setvalue(k, v): d[k] = v def delvalue(k): del d[k] def invalue(k): return k in d assert raises(TypeError, lambda: d[5]) assert raises(IndexError, lambda: d['5']) assert raises(TypeError, setvalue, 5, 5) d['value'] = 6 assert d['VaLuE'] == 6 d.update(vaLue=7) assert d['VaLuE'] == 7 d.update([('VALUE', 8)]) assert d['VaLuE'] == 8 d.update({'VAlue': 9}) assert d['VaLuE'] == 9 assert raises(TypeError, delvalue, 5) assert raises(IndexError, delvalue, '5') d['5'] = 5 del d['5'] assert d.get('5', None) is None assert raises(TypeError, invalue, 5) assert 'VALuE' in d assert d.has_key('vALUE') assert d.get('vaLUE') == 9
def test_get_or_pop_arg(): def my_arg_function(foo, bar, jim=3): pass args = (1, 2) kw = {'jim': 3} assert Decorators.get_or_pop_arg('bar', args, kw, inspect.getargspec(my_arg_function)) == 2 assert args == (1, 2) DictUtils.assert_dicts_equal(kw, {'jim': 3}) assert Decorators.get_or_pop_arg('jim', args, kw, inspect.getargspec(my_arg_function)) == 3 assert args == (1, 2) DictUtils.assert_dicts_equal(kw, {'jim': 3}) kw['billybob'] = 4 assert Decorators.get_or_pop_arg('billybob', args, kw, inspect.getargspec(my_arg_function)) == 4 assert args == (1, 2) DictUtils.assert_dicts_equal(kw, {'jim': 3})
def test_get_right_args(): def my_arg_function(foo, bar, jim=3): pass rightargs = Decorators.getrightargs(my_arg_function, { 'foo': 1, 'bar': 2, 'bob': 3, 'mary': 4, 'jim': 5 }) DictUtils.assert_dicts_equal(rightargs, {'foo': 1, 'bar': 2, 'jim': 5}) rightargs = Decorators.getrightargs(my_arg_function, { 'foo': 1, 'bar': 2, 'bob': 3, 'mary': 4 }) DictUtils.assert_dicts_equal(rightargs, {'foo': 1, 'bar': 2}) class my_arg_class(object): def __init__(self, foo, filip): pass rightargs = Decorators.getrightargs(my_arg_class, { 'foo': 1, 'bar': 2, 'bob': 3, 'mary': 4 }) DictUtils.assert_dicts_equal(rightargs, {'foo': 1, 'filip': None}) rightargs, rightkw = Decorators.conform_to_argspec((1, 2), { 'billybob': 5, 'jim': 3 }, inspect.getargspec(my_arg_function)) assert rightargs == [1, 2, 3] assert not rightkw
def bad_dict(): d = DictUtils.ordereddict(*k)
def test_unique_items(self): l = [9, 3, 4, 2, 4, 5, 3, 9] assert list(DictUtils.unique_items(l)) == [9, 3, 4, 2, 5]
def test_attribify(self): nested = DictUtils.attribify([{"this": "is", "a": ["nested", {"dictionary": 4}]}]) assert nested[0].this == "is" assert nested[0].a[0] == "nested" assert nested[0].a[1].dictionary == 4
def test_attrs(self): d = DictUtils.attrdict() d["VaLuE"] = 5 assert d["VaLuE"] == 5 assert d.VaLuE == 5
def test_retaincase(self): """tests that the key's original case is retained""" d = DictUtils.cidict() d["VaLuE"] = 5 assert "VaLuE" in d.keys() assert "value" not in d.keys()
"3": 4, "5": 6 }) DictUtils.assert_dicts_equal(DictUtils.mapdict(td, None, valuemap), { 1: 3, 3: 5, 5: 7 }) DictUtils.assert_dicts_equal(DictUtils.mapdict(td, keymap, valuemap), { "1": 3, "3": 5, "5": 7 }) simple_od = DictUtils.ordereddict() simple_od[99] = [('a', 1), ('b', 2)] simple_od[1] = [('c', 3), ('d', 4)] simple_od[7] = [('e', 5), ('f', 6)] class OrderedDictInABox(object): def __init__(self, message, ordered_dict): self.message = message self.od = ordered_dict inner_od = DictUtils.ordereddict() inner_od['first'] = datetime_tz.datetime_tz(1979, 8, 8, 16) inner_od['second'] = {'a': 1, 'b': 2, 'c': 3} inner_od['third'] = OrderedDictInABox(
def test_get(self): d = DictUtils.cidict() d["VaLuE"] = 5 assert d["value"] == 5
def test_mapdict(self): td = {1: 2, 3: 4, 5: 6} def keymap(x): return str(x) def valuemap(y): return y + 1 DictUtils.assert_dicts_equal(DictUtils.mapdict(td, None, None), td) DictUtils.assert_dicts_equal(DictUtils.mapdict(td, keymap, None), { "1": 2, "3": 4, "5": 6 }) DictUtils.assert_dicts_equal(DictUtils.mapdict(td, None, valuemap), { 1: 3, 3: 5, 5: 7 }) DictUtils.assert_dicts_equal(DictUtils.mapdict(td, keymap, valuemap), { "1": 3, "3": 5, "5": 7 })