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
})
