diff --git a/Tools/pybench/OrderedDict.py b/Tools/pybench/OrderedDict.py new file mode 100644 --- /dev/null +++ b/Tools/pybench/OrderedDict.py @@ -0,0 +1,2027 @@ +from pybench import Test +from test.support import import_fresh_module + + +WITH_CALIBRATION = False + + +TYPES = {'Dict': dict, + 'Py': import_fresh_module('collections', blocked=['_collections'] + ).OrderedDict, + 'C': import_fresh_module('collections', fresh=['_collections'] + ).OrderedDict, + } + + +def register_tests(prefix, version, operations, rounds, calibrate=None): + if not WITH_CALIBRATION or not calibrate: + calibrate = ODictTest.calibrate + kwargs = locals().copy() + kwargs.pop('prefix') + def decorator(f): + basename = "ODict" + prefix + "".join(word.capitalize() + for word in f.__name__.split("_")) + base = type(basename, (Test,), kwargs) + for targetname, targettype in TYPES.items(): + testname = "{}_{}".format(basename, targetname) + ns = {'TYPE': targettype, 'test': f, 'calibrate': calibrate} + test = type(testname, (base,), ns) + globals()[testname] = test + return f + return decorator + + +class TestMeta(type): + @classmethod + def __prepare__(meta, name, bases): + ns = {} + ns['__name__'] = name + return ns + + +class ODictTest(metaclass=TestMeta): + + def calibrate(self): + TYPE = self.TYPE + for i in range(self.rounds): + pass + + +################################################# +# creation + +class Call(ODictTest): + + version = 2.1 + + @register_tests(__name__, version, 6 * 5, 1000, ODictTest.calibrate) + def empty(self): + TYPE = self.TYPE + for i in range(self.rounds): + d1 = TYPE() + d2 = TYPE() + d3 = TYPE() + d4 = TYPE() + d5 = TYPE() + + d1 = TYPE() + d2 = TYPE() + d3 = TYPE() + d4 = TYPE() + d5 = TYPE() + + d1 = TYPE() + d2 = TYPE() + d3 = TYPE() + d4 = TYPE() + d5 = TYPE() + + d1 = TYPE() + d2 = TYPE() + d3 = TYPE() + d4 = TYPE() + d5 = TYPE() + + d1 = TYPE() + d2 = TYPE() + d3 = TYPE() + d4 = TYPE() + d5 = TYPE() + + d1 = TYPE() + d2 = TYPE() + d3 = TYPE() + d4 = TYPE() + d5 = TYPE() + + def calibrate(self): + TYPE = self.TYPE + iterable = [(i, i) for i in range(3)] + for i in range(self.rounds): + pass + + @register_tests(__name__, version, 6 * 5, 200, calibrate) + def sml_iterable(self): + TYPE = self.TYPE + iterable = [(i, i) for i in range(3)] + for i in range(self.rounds): + d1 = TYPE(iterable) + d2 = TYPE(iterable) + d3 = TYPE(iterable) + d4 = TYPE(iterable) + d5 = TYPE(iterable) + + d1 = TYPE(iterable) + d2 = TYPE(iterable) + d3 = TYPE(iterable) + d4 = TYPE(iterable) + d5 = TYPE(iterable) + + d1 = TYPE(iterable) + d2 = TYPE(iterable) + d3 = TYPE(iterable) + d4 = TYPE(iterable) + d5 = TYPE(iterable) + + d1 = TYPE(iterable) + d2 = TYPE(iterable) + d3 = TYPE(iterable) + d4 = TYPE(iterable) + d5 = TYPE(iterable) + + d1 = TYPE(iterable) + d2 = TYPE(iterable) + d3 = TYPE(iterable) + d4 = TYPE(iterable) + d5 = TYPE(iterable) + + d1 = TYPE(iterable) + d2 = TYPE(iterable) + d3 = TYPE(iterable) + d4 = TYPE(iterable) + d5 = TYPE(iterable) + + def calibrate(self): + TYPE = self.TYPE + iterable = [(i, i) for i in range(30)] + for i in range(self.rounds): + pass + + @register_tests(__name__, version, 6 * 5, 100, calibrate) + def med_iterable(self): + TYPE = self.TYPE + iterable = [(i, i) for i in range(30)] + for i in range(self.rounds): + d1 = TYPE(iterable) + d2 = TYPE(iterable) + d3 = TYPE(iterable) + d4 = TYPE(iterable) + d5 = TYPE(iterable) + + d1 = TYPE(iterable) + d2 = TYPE(iterable) + d3 = TYPE(iterable) + d4 = TYPE(iterable) + d5 = TYPE(iterable) + + d1 = TYPE(iterable) + d2 = TYPE(iterable) + d3 = TYPE(iterable) + d4 = TYPE(iterable) + d5 = TYPE(iterable) + + d1 = TYPE(iterable) + d2 = TYPE(iterable) + d3 = TYPE(iterable) + d4 = TYPE(iterable) + d5 = TYPE(iterable) + + d1 = TYPE(iterable) + d2 = TYPE(iterable) + d3 = TYPE(iterable) + d4 = TYPE(iterable) + d5 = TYPE(iterable) + + d1 = TYPE(iterable) + d2 = TYPE(iterable) + d3 = TYPE(iterable) + d4 = TYPE(iterable) + d5 = TYPE(iterable) + + def calibrate(self): + TYPE = self.TYPE + mapping = {1:1, 2:2, 3:3} + for i in range(self.rounds): + pass + + @register_tests(__name__, version, 6 * 5, 700, calibrate) + def sml_dict(self): + TYPE = self.TYPE + mapping = {1:1, 2:2, 3:3} + for i in range(self.rounds): + d1 = TYPE(mapping) + d2 = TYPE(mapping) + d3 = TYPE(mapping) + d4 = TYPE(mapping) + d5 = TYPE(mapping) + + d1 = TYPE(mapping) + d2 = TYPE(mapping) + d3 = TYPE(mapping) + d4 = TYPE(mapping) + d5 = TYPE(mapping) + + d1 = TYPE(mapping) + d2 = TYPE(mapping) + d3 = TYPE(mapping) + d4 = TYPE(mapping) + d5 = TYPE(mapping) + + d1 = TYPE(mapping) + d2 = TYPE(mapping) + d3 = TYPE(mapping) + d4 = TYPE(mapping) + d5 = TYPE(mapping) + + d1 = TYPE(mapping) + d2 = TYPE(mapping) + d3 = TYPE(mapping) + d4 = TYPE(mapping) + d5 = TYPE(mapping) + + d1 = TYPE(mapping) + d2 = TYPE(mapping) + d3 = TYPE(mapping) + d4 = TYPE(mapping) + d5 = TYPE(mapping) + + @register_tests(__name__, version, 6 * 5, 500, ODictTest.calibrate) + def sml_kwargs(self): + TYPE = self.TYPE + for i in range(self.rounds): + d1 = TYPE(a=1, b=2, c=3) + d2 = TYPE(a=1, b=2, c=3) + d3 = TYPE(a=1, b=2, c=3) + d4 = TYPE(a=1, b=2, c=3) + d5 = TYPE(a=1, b=2, c=3) + + d1 = TYPE(a=1, b=2, c=3) + d2 = TYPE(a=1, b=2, c=3) + d3 = TYPE(a=1, b=2, c=3) + d4 = TYPE(a=1, b=2, c=3) + d5 = TYPE(a=1, b=2, c=3) + + d1 = TYPE(a=1, b=2, c=3) + d2 = TYPE(a=1, b=2, c=3) + d3 = TYPE(a=1, b=2, c=3) + d4 = TYPE(a=1, b=2, c=3) + d5 = TYPE(a=1, b=2, c=3) + + d1 = TYPE(a=1, b=2, c=3) + d2 = TYPE(a=1, b=2, c=3) + d3 = TYPE(a=1, b=2, c=3) + d4 = TYPE(a=1, b=2, c=3) + d5 = TYPE(a=1, b=2, c=3) + + d1 = TYPE(a=1, b=2, c=3) + d2 = TYPE(a=1, b=2, c=3) + d3 = TYPE(a=1, b=2, c=3) + d4 = TYPE(a=1, b=2, c=3) + d5 = TYPE(a=1, b=2, c=3) + + d1 = TYPE(a=1, b=2, c=3) + d2 = TYPE(a=1, b=2, c=3) + d3 = TYPE(a=1, b=2, c=3) + d4 = TYPE(a=1, b=2, c=3) + d5 = TYPE(a=1, b=2, c=3) + + def calibrate(self): + TYPE = self.TYPE + iterable = [(i, i) for i in range(30)] + mapping = {'d': 4, 'e': 5, 'f': 6} + for i in range(self.rounds): + pass + + @register_tests(__name__, version, 6 * 5, 70, calibrate) + def mixed(self): + TYPE = self.TYPE + iterable = [(i, i) for i in range(30)] + mapping = {'d': 4, 'e': 5, 'f': 6} + for i in range(self.rounds): + d1 = TYPE(iterable, a=1, b=2, c=3, **mapping) + d2 = TYPE(iterable, a=1, b=2, c=3, **mapping) + d3 = TYPE(iterable, a=1, b=2, c=3, **mapping) + d4 = TYPE(iterable, a=1, b=2, c=3, **mapping) + d5 = TYPE(iterable, a=1, b=2, c=3, **mapping) + + d1 = TYPE(iterable, a=1, b=2, c=3, **mapping) + d2 = TYPE(iterable, a=1, b=2, c=3, **mapping) + d3 = TYPE(iterable, a=1, b=2, c=3, **mapping) + d4 = TYPE(iterable, a=1, b=2, c=3, **mapping) + d5 = TYPE(iterable, a=1, b=2, c=3, **mapping) + + d1 = TYPE(iterable, a=1, b=2, c=3, **mapping) + d2 = TYPE(iterable, a=1, b=2, c=3, **mapping) + d3 = TYPE(iterable, a=1, b=2, c=3, **mapping) + d4 = TYPE(iterable, a=1, b=2, c=3, **mapping) + d5 = TYPE(iterable, a=1, b=2, c=3, **mapping) + + d1 = TYPE(iterable, a=1, b=2, c=3, **mapping) + d2 = TYPE(iterable, a=1, b=2, c=3, **mapping) + d3 = TYPE(iterable, a=1, b=2, c=3, **mapping) + d4 = TYPE(iterable, a=1, b=2, c=3, **mapping) + d5 = TYPE(iterable, a=1, b=2, c=3, **mapping) + + d1 = TYPE(iterable, a=1, b=2, c=3, **mapping) + d2 = TYPE(iterable, a=1, b=2, c=3, **mapping) + d3 = TYPE(iterable, a=1, b=2, c=3, **mapping) + d4 = TYPE(iterable, a=1, b=2, c=3, **mapping) + d5 = TYPE(iterable, a=1, b=2, c=3, **mapping) + + d1 = TYPE(iterable, a=1, b=2, c=3, **mapping) + d2 = TYPE(iterable, a=1, b=2, c=3, **mapping) + d3 = TYPE(iterable, a=1, b=2, c=3, **mapping) + d4 = TYPE(iterable, a=1, b=2, c=3, **mapping) + d5 = TYPE(iterable, a=1, b=2, c=3, **mapping) + + +class Copy(ODictTest): + + version = 2.1 + + def calibrate(self): + obj = self.TYPE((i, i) for i in range(3)) + for i in range(self.rounds): + pass + + @register_tests(__name__, version, 6 * 5, 1500, calibrate) + def small(self): + obj = self.TYPE((i, i) for i in range(3)) + for i in range(self.rounds): + d1 = obj.copy() + d2 = obj.copy() + d3 = obj.copy() + d4 = obj.copy() + d5 = obj.copy() + + d1 = obj.copy() + d2 = obj.copy() + d3 = obj.copy() + d4 = obj.copy() + d5 = obj.copy() + + d1 = obj.copy() + d2 = obj.copy() + d3 = obj.copy() + d4 = obj.copy() + d5 = obj.copy() + + d1 = obj.copy() + d2 = obj.copy() + d3 = obj.copy() + d4 = obj.copy() + d5 = obj.copy() + + d1 = obj.copy() + d2 = obj.copy() + d3 = obj.copy() + d4 = obj.copy() + d5 = obj.copy() + + d1 = obj.copy() + d2 = obj.copy() + d3 = obj.copy() + d4 = obj.copy() + d5 = obj.copy() + + def calibrate(self): + obj = self.TYPE((i, i) for i in range(30)) + for i in range(self.rounds): + pass + + @register_tests(__name__, version, 6 * 5, 400, calibrate) + def medium(self): + obj = self.TYPE((i, i) for i in range(30)) + for i in range(self.rounds): + d1 = obj.copy() + d2 = obj.copy() + d3 = obj.copy() + d4 = obj.copy() + d5 = obj.copy() + + d1 = obj.copy() + d2 = obj.copy() + d3 = obj.copy() + d4 = obj.copy() + d5 = obj.copy() + + d1 = obj.copy() + d2 = obj.copy() + d3 = obj.copy() + d4 = obj.copy() + d5 = obj.copy() + + d1 = obj.copy() + d2 = obj.copy() + d3 = obj.copy() + d4 = obj.copy() + d5 = obj.copy() + + d1 = obj.copy() + d2 = obj.copy() + d3 = obj.copy() + d4 = obj.copy() + d5 = obj.copy() + + d1 = obj.copy() + d2 = obj.copy() + d3 = obj.copy() + d4 = obj.copy() + d5 = obj.copy() + + +class FromKeys(ODictTest): + + version = 2.1 + + def calibrate(self): + TYPE = self.TYPE + keys = [i for i in range(3)] + for i in range(self.rounds): + pass + + @register_tests(__name__, version, 6 * 5, 500, calibrate) + def small(self): + TYPE = self.TYPE + keys = [i for i in range(3)] + for i in range(self.rounds): + d1 = TYPE.fromkeys(keys) + d2 = TYPE.fromkeys(keys) + d3 = TYPE.fromkeys(keys) + d4 = TYPE.fromkeys(keys) + d5 = TYPE.fromkeys(keys) + + d1 = TYPE.fromkeys(keys) + d2 = TYPE.fromkeys(keys) + d3 = TYPE.fromkeys(keys) + d4 = TYPE.fromkeys(keys) + d5 = TYPE.fromkeys(keys) + + d1 = TYPE.fromkeys(keys) + d2 = TYPE.fromkeys(keys) + d3 = TYPE.fromkeys(keys) + d4 = TYPE.fromkeys(keys) + d5 = TYPE.fromkeys(keys) + + d1 = TYPE.fromkeys(keys) + d2 = TYPE.fromkeys(keys) + d3 = TYPE.fromkeys(keys) + d4 = TYPE.fromkeys(keys) + d5 = TYPE.fromkeys(keys) + + d1 = TYPE.fromkeys(keys) + d2 = TYPE.fromkeys(keys) + d3 = TYPE.fromkeys(keys) + d4 = TYPE.fromkeys(keys) + d5 = TYPE.fromkeys(keys) + + d1 = TYPE.fromkeys(keys) + d2 = TYPE.fromkeys(keys) + d3 = TYPE.fromkeys(keys) + d4 = TYPE.fromkeys(keys) + d5 = TYPE.fromkeys(keys) + + def calibrate(self): + TYPE = self.TYPE + keys = [i for i in range(30)] + for i in range(self.rounds): + pass + + @register_tests(__name__, version, 6 * 5, 150, calibrate) + def medium(self): + TYPE = self.TYPE + keys = [i for i in range(30)] + for i in range(self.rounds): + d1 = TYPE.fromkeys(keys) + d2 = TYPE.fromkeys(keys) + d3 = TYPE.fromkeys(keys) + d4 = TYPE.fromkeys(keys) + d5 = TYPE.fromkeys(keys) + + d1 = TYPE.fromkeys(keys) + d2 = TYPE.fromkeys(keys) + d3 = TYPE.fromkeys(keys) + d4 = TYPE.fromkeys(keys) + d5 = TYPE.fromkeys(keys) + + d1 = TYPE.fromkeys(keys) + d2 = TYPE.fromkeys(keys) + d3 = TYPE.fromkeys(keys) + d4 = TYPE.fromkeys(keys) + d5 = TYPE.fromkeys(keys) + + d1 = TYPE.fromkeys(keys) + d2 = TYPE.fromkeys(keys) + d3 = TYPE.fromkeys(keys) + d4 = TYPE.fromkeys(keys) + d5 = TYPE.fromkeys(keys) + + d1 = TYPE.fromkeys(keys) + d2 = TYPE.fromkeys(keys) + d3 = TYPE.fromkeys(keys) + d4 = TYPE.fromkeys(keys) + d5 = TYPE.fromkeys(keys) + + d1 = TYPE.fromkeys(keys) + d2 = TYPE.fromkeys(keys) + d3 = TYPE.fromkeys(keys) + d4 = TYPE.fromkeys(keys) + d5 = TYPE.fromkeys(keys) + + +################################################# +# modification + +class SetItem(ODictTest): + + version = 2.1 + + def calibrate(self): + TYPE = self.TYPE + for i in range(self.rounds): + obj = TYPE() + obj = TYPE() + obj = TYPE() + obj = TYPE() + obj = TYPE() + obj = TYPE() + + @register_tests(__name__, version, 6 * 5, 3000, calibrate) + def small(self): + TYPE = self.TYPE + for i in range(self.rounds): + obj = TYPE() + obj[1] = 1 + obj[2] = 2 + obj[3] = 3 + obj[4] = 4 + obj[5] = 5 + + obj = TYPE() + obj[1] = 1 + obj[2] = 2 + obj[3] = 3 + obj[4] = 4 + obj[5] = 5 + + obj = TYPE() + obj[1] = 1 + obj[2] = 2 + obj[3] = 3 + obj[4] = 4 + obj[5] = 5 + + obj = TYPE() + obj[1] = 1 + obj[2] = 2 + obj[3] = 3 + obj[4] = 4 + obj[5] = 5 + + obj = TYPE() + obj[1] = 1 + obj[2] = 2 + obj[3] = 3 + obj[4] = 4 + obj[5] = 5 + + obj = TYPE() + obj[1] = 1 + obj[2] = 2 + obj[3] = 3 + obj[4] = 4 + obj[5] = 5 + + def calibrate(self): + obj = self.TYPE() + for i in range(self.rounds): + pass + + @register_tests(__name__, version, 1 * 30, 7000, calibrate) + def medium(self): + obj = self.TYPE() + for i in range(self.rounds): + obj[1] = 1 + obj[2] = 2 + obj[3] = 3 + obj[4] = 4 + obj[5] = 5 + obj[6] = 6 + obj[7] = 7 + obj[8] = 8 + obj[9] = 9 + obj[10] = 10 + obj[11] = 11 + obj[12] = 12 + obj[13] = 13 + obj[14] = 14 + obj[15] = 15 + obj[16] = 16 + obj[17] = 17 + obj[18] = 18 + obj[19] = 19 + obj[20] = 20 + obj[21] = 21 + obj[22] = 22 + obj[23] = 23 + obj[24] = 24 + obj[25] = 25 + obj[26] = 26 + obj[27] = 27 + obj[28] = 28 + obj[29] = 29 + obj[30] = 30 + + def calibrate(self): + obj = self.TYPE((i, i) for i in range(30)) + for i in range(self.rounds): + pass + + @register_tests(__name__, version, 6 * 5, 7000, calibrate) + def replace(self): + obj = self.TYPE((i, i) for i in range(30)) + for i in range(self.rounds): + obj[1] = 1 + obj[3] = 3 + obj[5] = 5 + obj[7] = 7 + obj[9] = 9 + + obj[1] = 1 + obj[3] = 3 + obj[5] = 5 + obj[7] = 7 + obj[9] = 9 + + obj[1] = 1 + obj[3] = 3 + obj[5] = 5 + obj[7] = 7 + obj[9] = 9 + + obj[1] = 1 + obj[3] = 3 + obj[5] = 5 + obj[7] = 7 + obj[9] = 9 + + obj[1] = 1 + obj[3] = 3 + obj[5] = 5 + obj[7] = 7 + obj[9] = 9 + + obj[1] = 1 + obj[3] = 3 + obj[5] = 5 + obj[7] = 7 + obj[9] = 9 + + +class SetDefault(ODictTest): + + version = 2.1 + + def calibrate(self): + TYPE = self.TYPE + for i in range(self.rounds): + obj = TYPE() + + @register_tests(__name__, version, 1 * 30, 2000, calibrate) + def new(self): + TYPE = self.TYPE + for i in range(self.rounds): + obj = TYPE() + + x = obj.setdefault(1, 1) + x = obj.setdefault(2, 1) + x = obj.setdefault(3, 1) + x = obj.setdefault(4, 1) + x = obj.setdefault(5, 1) + x = obj.setdefault(6, 1) + x = obj.setdefault(7, 1) + x = obj.setdefault(8, 1) + x = obj.setdefault(9, 1) + x = obj.setdefault(10, 1) + x = obj.setdefault(11, 1) + x = obj.setdefault(12, 1) + x = obj.setdefault(13, 1) + x = obj.setdefault(14, 1) + x = obj.setdefault(15, 1) + x = obj.setdefault(16, 1) + x = obj.setdefault(17, 1) + x = obj.setdefault(18, 1) + x = obj.setdefault(19, 1) + x = obj.setdefault(20, 1) + x = obj.setdefault(21, 1) + x = obj.setdefault(22, 1) + x = obj.setdefault(23, 1) + x = obj.setdefault(24, 1) + x = obj.setdefault(25, 1) + x = obj.setdefault(26, 1) + x = obj.setdefault(27, 1) + x = obj.setdefault(28, 1) + x = obj.setdefault(29, 1) + x = obj.setdefault(30, 1) + + def calibrate(self): + obj = self.TYPE([(1, 2), (3, 4), (5, 6), (7, 8), (9, 10)]) + for i in range(self.rounds): + pass + + @register_tests(__name__, version, 6 * 5, 2500, calibrate) + def existing(self): + obj = self.TYPE([(1, 2), (3, 4), (5, 6), (7, 8), (9, 10)]) + for i in range(self.rounds): + x = obj.setdefault(1, 1) + x = obj.setdefault(3, 1) + x = obj.setdefault(5, 1) + x = obj.setdefault(7, 1) + x = obj.setdefault(9, 1) + + x = obj.setdefault(1, 1) + x = obj.setdefault(3, 1) + x = obj.setdefault(5, 1) + x = obj.setdefault(7, 1) + x = obj.setdefault(9, 1) + + x = obj.setdefault(1, 1) + x = obj.setdefault(3, 1) + x = obj.setdefault(5, 1) + x = obj.setdefault(7, 1) + x = obj.setdefault(9, 1) + + x = obj.setdefault(1, 1) + x = obj.setdefault(3, 1) + x = obj.setdefault(5, 1) + x = obj.setdefault(7, 1) + x = obj.setdefault(9, 1) + + x = obj.setdefault(1, 1) + x = obj.setdefault(3, 1) + x = obj.setdefault(5, 1) + x = obj.setdefault(7, 1) + x = obj.setdefault(9, 1) + + x = obj.setdefault(1, 1) + x = obj.setdefault(3, 1) + x = obj.setdefault(5, 1) + x = obj.setdefault(7, 1) + x = obj.setdefault(9, 1) + + +class Update(ODictTest): + + version = 2.1 + + def calibrate(self): + TYPE = self.TYPE + pairs1 = [(i, i) for i in range(3)] + pairs2 = [(i, i) for i in range(3, 6)] + pairs3 = [(i, i) for i in range(6, 9)] + pairs4 = [(i, i) for i in range(9, 12)] + pairs5 = [(i, i) for i in range(12, 15)] + for i in range(self.rounds): + obj = TYPE() + obj = TYPE() + obj = TYPE() + obj = TYPE() + obj = TYPE() + obj = TYPE() + + @register_tests(__name__, version, 6 * 5, 200, calibrate) + def new(self): + TYPE = self.TYPE + pairs1 = [(i, i) for i in range(3)] + pairs2 = [(i, i) for i in range(3, 6)] + pairs3 = [(i, i) for i in range(6, 9)] + pairs4 = [(i, i) for i in range(9, 12)] + pairs5 = [(i, i) for i in range(12, 15)] + for i in range(self.rounds): + obj = TYPE() + obj.update(pairs1) + obj.update(pairs2) + obj.update(pairs3) + obj.update(pairs4) + obj.update(pairs5) + + obj = TYPE() + obj.update(pairs1) + obj.update(pairs2) + obj.update(pairs3) + obj.update(pairs4) + obj.update(pairs5) + + obj = TYPE() + obj.update(pairs1) + obj.update(pairs2) + obj.update(pairs3) + obj.update(pairs4) + obj.update(pairs5) + + obj = TYPE() + obj.update(pairs1) + obj.update(pairs2) + obj.update(pairs3) + obj.update(pairs4) + obj.update(pairs5) + + obj = TYPE() + obj.update(pairs1) + obj.update(pairs2) + obj.update(pairs3) + obj.update(pairs4) + obj.update(pairs5) + + obj = TYPE() + obj.update(pairs1) + obj.update(pairs2) + obj.update(pairs3) + obj.update(pairs4) + obj.update(pairs5) + + def calibrate(self): + TYPE = self.TYPE + pairs = [(i, i) for i in range(3)] + for i in range(self.rounds): + obj = TYPE(pairs) + obj = TYPE(pairs) + obj = TYPE(pairs) + obj = TYPE(pairs) + obj = TYPE(pairs) + obj = TYPE(pairs) + + @register_tests(__name__, version, 6 * 5, 200, calibrate) + def existing(self): + TYPE = self.TYPE + pairs = [(i, i) for i in range(3)] + for i in range(self.rounds): + obj = TYPE(pairs) + obj.update(pairs) + obj.update(pairs) + obj.update(pairs) + obj.update(pairs) + obj.update(pairs) + + obj = TYPE(pairs) + obj.update(pairs) + obj.update(pairs) + obj.update(pairs) + obj.update(pairs) + obj.update(pairs) + + obj = TYPE(pairs) + obj.update(pairs) + obj.update(pairs) + obj.update(pairs) + obj.update(pairs) + obj.update(pairs) + + obj = TYPE(pairs) + obj.update(pairs) + obj.update(pairs) + obj.update(pairs) + obj.update(pairs) + obj.update(pairs) + + obj = TYPE(pairs) + obj.update(pairs) + obj.update(pairs) + obj.update(pairs) + obj.update(pairs) + obj.update(pairs) + + obj = TYPE(pairs) + obj.update(pairs) + obj.update(pairs) + obj.update(pairs) + obj.update(pairs) + obj.update(pairs) + + def calibrate(self): + TYPE = self.TYPE + pairs1 = [(i, i) for i in range(5)] + pairs2 = [(i, i) for i in range(6, 2)] + for i in range(self.rounds): + obj = TYPE(pairs1) + obj = TYPE(pairs1) + obj = TYPE(pairs1) + obj = TYPE(pairs1) + obj = TYPE(pairs1) + obj = TYPE(pairs1) + + @register_tests(__name__, version, 6 * 3, 250, calibrate) + def mixed(self): + TYPE = self.TYPE + pairs1 = [(i, i) for i in range(5)] + pairs2 = [(i, i) for i in range(6, 2)] + for i in range(self.rounds): + obj = TYPE(pairs1) + obj.update(pairs2) + obj.update(pairs1) + obj.update(pairs2) + + obj = TYPE(pairs1) + obj.update(pairs2) + obj.update(pairs1) + obj.update(pairs2) + + obj = TYPE(pairs1) + obj.update(pairs2) + obj.update(pairs1) + obj.update(pairs2) + + obj = TYPE(pairs1) + obj.update(pairs2) + obj.update(pairs1) + obj.update(pairs2) + + obj = TYPE(pairs1) + obj.update(pairs2) + obj.update(pairs1) + obj.update(pairs2) + + obj = TYPE(pairs1) + obj.update(pairs2) + obj.update(pairs1) + obj.update(pairs2) + + +################################################# +# Deletion + +class DelItem(ODictTest): + + version = 2.1 + + def calibrate(self): + TYPE = self.TYPE + pairs = [(i, i) for i in range(30)] + for i in range(self.rounds): + obj = TYPE(pairs) + obj = TYPE(pairs) + obj = TYPE(pairs) + + @register_tests(__name__, version, 3 * 10, 700, calibrate) + def first(self): + TYPE = self.TYPE + pairs = [(i, i) for i in range(30)] + for i in range(self.rounds): + obj = TYPE(pairs) + del obj[1] + del obj[2] + del obj[3] + del obj[4] + del obj[5] + del obj[6] + del obj[7] + del obj[8] + del obj[9] + del obj[10] + + obj = TYPE(pairs) + del obj[1] + del obj[2] + del obj[3] + del obj[4] + del obj[5] + del obj[6] + del obj[7] + del obj[8] + del obj[9] + del obj[10] + + obj = TYPE(pairs) + del obj[1] + del obj[2] + del obj[3] + del obj[4] + del obj[5] + del obj[6] + del obj[7] + del obj[8] + del obj[9] + del obj[10] + + def calibrate(self): + TYPE = self.TYPE + pairs = [(i, i) for i in range(30)] + for i in range(self.rounds): + obj = TYPE(pairs) + obj = TYPE(pairs) + obj = TYPE(pairs) + + @register_tests(__name__, version, 3 * 10, 700, calibrate) + def last(self): + TYPE = self.TYPE + pairs = [(i, i) for i in range(30)] + for i in range(self.rounds): + obj = TYPE(pairs) + del obj[29] + del obj[28] + del obj[27] + del obj[26] + del obj[25] + del obj[24] + del obj[23] + del obj[22] + del obj[21] + del obj[20] + + obj = TYPE(pairs) + del obj[29] + del obj[28] + del obj[27] + del obj[26] + del obj[25] + del obj[24] + del obj[23] + del obj[22] + del obj[21] + del obj[20] + + obj = TYPE(pairs) + del obj[29] + del obj[28] + del obj[27] + del obj[26] + del obj[25] + del obj[24] + del obj[23] + del obj[22] + del obj[21] + del obj[20] + + def calibrate(self): + TYPE = self.TYPE + pairs = [(i, i) for i in range(30)] + for i in range(self.rounds): + obj = TYPE(pairs) + obj = TYPE(pairs) + obj = TYPE(pairs) + + @register_tests(__name__, version, 3 * 10, 700, calibrate) + def middle(self): + TYPE = self.TYPE + pairs = [(i, i) for i in range(30)] + for i in range(self.rounds): + obj = TYPE(pairs) + del obj[28] + del obj[26] + del obj[24] + del obj[22] + del obj[20] + del obj[18] + del obj[16] + del obj[14] + del obj[12] + del obj[10] + + obj = TYPE(pairs) + del obj[28] + del obj[26] + del obj[24] + del obj[22] + del obj[20] + del obj[18] + del obj[16] + del obj[14] + del obj[12] + del obj[10] + + obj = TYPE(pairs) + del obj[28] + del obj[26] + del obj[24] + del obj[22] + del obj[20] + del obj[18] + del obj[16] + del obj[14] + del obj[12] + del obj[10] + + +class Pop(ODictTest): + + version = 2.1 + + def calibrate(self): + TYPE = self.TYPE + pairs = [(i, i) for i in range(30)] + for i in range(self.rounds): + obj = TYPE(pairs) + obj = TYPE(pairs) + obj = TYPE(pairs) + + @register_tests(__name__, version, 3 * 10, 600, calibrate) + def existing(self): + TYPE = self.TYPE + pairs = [(i, i) for i in range(30)] + for i in range(self.rounds): + obj = TYPE(pairs) + x = obj.pop(28) + x = obj.pop(26) + x = obj.pop(24) + x = obj.pop(22) + x = obj.pop(20) + x = obj.pop(18) + x = obj.pop(16) + x = obj.pop(14) + x = obj.pop(12) + x = obj.pop(10) + + obj = TYPE(pairs) + x = obj.pop(28) + x = obj.pop(26) + x = obj.pop(24) + x = obj.pop(22) + x = obj.pop(20) + x = obj.pop(18) + x = obj.pop(16) + x = obj.pop(14) + x = obj.pop(12) + x = obj.pop(10) + + obj = TYPE(pairs) + x = obj.pop(28) + x = obj.pop(26) + x = obj.pop(24) + x = obj.pop(22) + x = obj.pop(20) + x = obj.pop(18) + x = obj.pop(16) + x = obj.pop(14) + x = obj.pop(12) + x = obj.pop(10) + + def calibrate(self): + obj = self.TYPE((i, i) for i in range(3)) + for i in range(self.rounds): + pass + + @register_tests(__name__, version, 6 * 5, 2500, calibrate) + def default(self): + obj = self.TYPE((i, i) for i in range(3)) + for i in range(self.rounds): + x = obj.pop(7, 0) + x = obj.pop(17, 0) + x = obj.pop(27, 0) + x = obj.pop(37, 0) + x = obj.pop(47, 0) + + x = obj.pop(7, 0) + x = obj.pop(17, 0) + x = obj.pop(27, 0) + x = obj.pop(37, 0) + x = obj.pop(47, 0) + + x = obj.pop(7, 0) + x = obj.pop(17, 0) + x = obj.pop(27, 0) + x = obj.pop(37, 0) + x = obj.pop(47, 0) + + x = obj.pop(7, 0) + x = obj.pop(17, 0) + x = obj.pop(27, 0) + x = obj.pop(37, 0) + x = obj.pop(47, 0) + + x = obj.pop(7, 0) + x = obj.pop(17, 0) + x = obj.pop(27, 0) + x = obj.pop(37, 0) + x = obj.pop(47, 0) + + x = obj.pop(7, 0) + x = obj.pop(17, 0) + x = obj.pop(27, 0) + x = obj.pop(37, 0) + x = obj.pop(47, 0) + + def calibrate(self): + TYPE = self.TYPE + pairs = [(i, i) for i in range(30)] + for i in range(self.rounds): + obj = TYPE(pairs) + obj = TYPE(pairs) + obj = TYPE(pairs) + + @register_tests(__name__, version, 3 * 10, 600, calibrate) + def mixed(self): + TYPE = self.TYPE + pairs = [(i, i) for i in range(30)] + for i in range(self.rounds): + obj = TYPE(pairs) + x = obj.pop(30, 0) + x = obj.pop(5, 0) + x = obj.pop(35, 0) + x = obj.pop(10, 0) + x = obj.pop(40, 0) + x = obj.pop(15, 0) + x = obj.pop(45, 0) + x = obj.pop(20, 0) + x = obj.pop(50, 0) + x = obj.pop(25, 0) + x = obj.pop(55, 0) + + obj = TYPE(pairs) + x = obj.pop(30, 0) + x = obj.pop(5, 0) + x = obj.pop(35, 0) + x = obj.pop(10, 0) + x = obj.pop(40, 0) + x = obj.pop(15, 0) + x = obj.pop(45, 0) + x = obj.pop(20, 0) + x = obj.pop(50, 0) + x = obj.pop(25, 0) + x = obj.pop(55, 0) + + obj = TYPE(pairs) + x = obj.pop(30, 0) + x = obj.pop(5, 0) + x = obj.pop(35, 0) + x = obj.pop(10, 0) + x = obj.pop(40, 0) + x = obj.pop(15, 0) + x = obj.pop(45, 0) + x = obj.pop(20, 0) + x = obj.pop(50, 0) + x = obj.pop(25, 0) + x = obj.pop(55, 0) + + +class PopItem(ODictTest): + + version = 2.1 + + def calibrate(self): + TYPE = self.TYPE + pairs = [(i, i) for i in range(30)] + for i in range(self.rounds): + obj = TYPE(pairs) + obj = TYPE(pairs) + obj = TYPE(pairs) + + @register_tests(__name__, version, 3 * 10, 700, calibrate) + def last(self): + TYPE = self.TYPE + pairs = [(i, i) for i in range(30)] + for i in range(self.rounds): + obj = TYPE(pairs) + x = obj.popitem() + x = obj.popitem() + x = obj.popitem() + x = obj.popitem() + x = obj.popitem() + x = obj.popitem() + x = obj.popitem() + x = obj.popitem() + x = obj.popitem() + x = obj.popitem() + + obj = TYPE(pairs) + x = obj.popitem() + x = obj.popitem() + x = obj.popitem() + x = obj.popitem() + x = obj.popitem() + x = obj.popitem() + x = obj.popitem() + x = obj.popitem() + x = obj.popitem() + x = obj.popitem() + + obj = TYPE(pairs) + x = obj.popitem() + x = obj.popitem() + x = obj.popitem() + x = obj.popitem() + x = obj.popitem() + x = obj.popitem() + x = obj.popitem() + x = obj.popitem() + x = obj.popitem() + x = obj.popitem() + + def calibrate(self): + TYPE = self.TYPE + pairs = [(i, i) for i in range(30)] + for i in range(self.rounds): + if type(obj) == dict: + obj = TYPE(pairs) + obj = TYPE(pairs) + obj = TYPE(pairs) + else: + obj = TYPE(pairs) + obj = TYPE(pairs) + obj = TYPE(pairs) + + @register_tests(__name__, version, 3 * 10, 500, calibrate) + def first(self): + TYPE = self.TYPE + pairs = [(i, i) for i in range(30)] + for i in range(self.rounds): + obj = TYPE(pairs) + if type(obj) == dict: + obj = TYPE(pairs) + x = obj.popitem() + x = obj.popitem() + x = obj.popitem() + x = obj.popitem() + x = obj.popitem() + x = obj.popitem() + x = obj.popitem() + x = obj.popitem() + x = obj.popitem() + x = obj.popitem() + + obj = TYPE(pairs) + x = obj.popitem() + x = obj.popitem() + x = obj.popitem() + x = obj.popitem() + x = obj.popitem() + x = obj.popitem() + x = obj.popitem() + x = obj.popitem() + x = obj.popitem() + x = obj.popitem() + + obj = TYPE(pairs) + x = obj.popitem() + x = obj.popitem() + x = obj.popitem() + x = obj.popitem() + x = obj.popitem() + x = obj.popitem() + x = obj.popitem() + x = obj.popitem() + x = obj.popitem() + x = obj.popitem() + else: + x = obj.popitem(False) + x = obj.popitem(False) + x = obj.popitem(False) + x = obj.popitem(False) + x = obj.popitem(False) + x = obj.popitem(False) + x = obj.popitem(False) + x = obj.popitem(False) + x = obj.popitem(False) + x = obj.popitem(False) + + obj = TYPE(pairs) + x = obj.popitem(False) + x = obj.popitem(False) + x = obj.popitem(False) + x = obj.popitem(False) + x = obj.popitem(False) + x = obj.popitem(False) + x = obj.popitem(False) + x = obj.popitem(False) + x = obj.popitem(False) + x = obj.popitem(False) + + obj = TYPE(pairs) + x = obj.popitem(False) + x = obj.popitem(False) + x = obj.popitem(False) + x = obj.popitem(False) + x = obj.popitem(False) + x = obj.popitem(False) + x = obj.popitem(False) + x = obj.popitem(False) + x = obj.popitem(False) + x = obj.popitem(False) + + +class Clear(ODictTest): + + version = 2.1 + + def calibrate(self): + TYPE = self.TYPE + for i in range(self.rounds): + obj = TYPE() + obj = TYPE() + obj = TYPE() + obj = TYPE() + obj = TYPE() + obj = TYPE() + + @register_tests(__name__, version, 6 * 5, 2500, calibrate) + def empty(self): + TYPE = self.TYPE + for i in range(self.rounds): + obj = TYPE() + obj.clear() + obj.clear() + obj.clear() + obj.clear() + obj.clear() + + obj = TYPE() + obj.clear() + obj.clear() + obj.clear() + obj.clear() + obj.clear() + + obj = TYPE() + obj.clear() + obj.clear() + obj.clear() + obj.clear() + obj.clear() + + obj = TYPE() + obj.clear() + obj.clear() + obj.clear() + obj.clear() + obj.clear() + + obj = TYPE() + obj.clear() + obj.clear() + obj.clear() + obj.clear() + obj.clear() + + obj = TYPE() + obj.clear() + obj.clear() + obj.clear() + obj.clear() + obj.clear() + + def calibrate(self): + TYPE = self.TYPE + pairs = [(i, i) for i in range(3)] + for i in range(self.rounds): + obj = TYPE(pairs) + obj.update(pairs) # not quite right + + @register_tests(__name__, version, 6 * 2, 500, calibrate) + def small(self): + TYPE = self.TYPE + pairs = [(i, i) for i in range(3)] + for i in range(self.rounds): + obj = TYPE(pairs) + obj.clear() + obj.update(pairs) + obj.clear() + + obj = TYPE(pairs) + obj.clear() + obj.update(pairs) + obj.clear() + + obj = TYPE(pairs) + obj.clear() + obj.update(pairs) + obj.clear() + + obj = TYPE(pairs) + obj.clear() + obj.update(pairs) + obj.clear() + + obj = TYPE(pairs) + obj.clear() + obj.update(pairs) + obj.clear() + + obj = TYPE(pairs) + obj.clear() + obj.update(pairs) + obj.clear() + + def calibrate(self): + TYPE = self.TYPE + pairs = [(i, i) for i in range(30)] + for i in range(self.rounds): + obj = TYPE(pairs) + obj.update(pairs) # not quite right + + @register_tests(__name__, version, 6 * 2, 250, calibrate) + def medium(self): + TYPE = self.TYPE + pairs = [(i, i) for i in range(30)] + for i in range(self.rounds): + obj = TYPE(pairs) + obj.clear() + obj.update(pairs) + obj.clear() + + obj = TYPE(pairs) + obj.clear() + obj.update(pairs) + obj.clear() + + obj = TYPE(pairs) + obj.clear() + obj.update(pairs) + obj.clear() + + obj = TYPE(pairs) + obj.clear() + obj.update(pairs) + obj.clear() + + obj = TYPE(pairs) + obj.clear() + obj.update(pairs) + obj.clear() + + obj = TYPE(pairs) + obj.clear() + obj.update(pairs) + obj.clear() + + +################################################# +# iteration + +class Iter(ODictTest): + + version = 2.1 + + def calibrate(self): + TYPE = self.TYPE + obj = self.TYPE((i, i) for i in range(3)) + for i in range(self.rounds): + pass + + @register_tests(__name__, version, 5, 7000, calibrate) + def small(self): + TYPE = self.TYPE + obj = self.TYPE((i, i) for i in range(3)) + for i in range(self.rounds): + for key in iter(obj): + pass + for key in iter(obj): + pass + for key in iter(obj): + pass + for key in iter(obj): + pass + for key in iter(obj): + pass + + def calibrate(self): + TYPE = self.TYPE + obj = self.TYPE((i, i) for i in range(30)) + for i in range(self.rounds): + pass + + @register_tests(__name__, version, 5, 2500, calibrate) + def medium(self): + TYPE = self.TYPE + obj = self.TYPE((i, i) for i in range(30)) + for i in range(self.rounds): + for key in iter(obj): + pass + for key in iter(obj): + pass + for key in iter(obj): + pass + for key in iter(obj): + pass + for key in iter(obj): + pass + + +class Keys(ODictTest): + + version = 2.1 + + def calibrate(self): + TYPE = self.TYPE + obj = self.TYPE((i, i) for i in range(3)) + for i in range(self.rounds): + pass + + @register_tests(__name__, version, 5, 5000, calibrate) + def small(self): + TYPE = self.TYPE + obj = self.TYPE((i, i) for i in range(3)) + for i in range(self.rounds): + for key in obj.keys(): + pass + for key in obj.keys(): + pass + for key in obj.keys(): + pass + for key in obj.keys(): + pass + for key in obj.keys(): + pass + + def calibrate(self): + TYPE = self.TYPE + obj = self.TYPE((i, i) for i in range(30)) + for i in range(self.rounds): + pass + + @register_tests(__name__, version, 5, 2500, calibrate) + def medium(self): + TYPE = self.TYPE + obj = self.TYPE((i, i) for i in range(30)) + for i in range(self.rounds): + for key in obj.keys(): + pass + for key in obj.keys(): + pass + for key in obj.keys(): + pass + for key in obj.keys(): + pass + for key in obj.keys(): + pass + + +class Values(ODictTest): + + version = 2.1 + + def calibrate(self): + TYPE = self.TYPE + obj = self.TYPE((i, i) for i in range(3)) + for i in range(self.rounds): + pass + + @register_tests(__name__, version, 5, 5000, calibrate) + def small(self): + TYPE = self.TYPE + obj = self.TYPE((i, i) for i in range(3)) + for i in range(self.rounds): + for value in obj.values(): + pass + for value in obj.values(): + pass + for value in obj.values(): + pass + for value in obj.values(): + pass + for value in obj.values(): + pass + + def calibrate(self): + TYPE = self.TYPE + obj = self.TYPE((i, i) for i in range(30)) + for i in range(self.rounds): + pass + + @register_tests(__name__, version, 5, 2500, calibrate) + def medium(self): + TYPE = self.TYPE + obj = self.TYPE((i, i) for i in range(30)) + for i in range(self.rounds): + for value in obj.values(): + pass + for value in obj.values(): + pass + for value in obj.values(): + pass + for value in obj.values(): + pass + for value in obj.values(): + pass + + +class Items(ODictTest): + + version = 2.1 + + def calibrate(self): + TYPE = self.TYPE + obj = self.TYPE((i, i) for i in range(3)) + for i in range(self.rounds): + pass + + @register_tests(__name__, version, 5, 5000, calibrate) + def small(self): + TYPE = self.TYPE + obj = self.TYPE((i, i) for i in range(3)) + for i in range(self.rounds): + for item in obj.items(): + pass + for item in obj.items(): + pass + for item in obj.items(): + pass + for item in obj.items(): + pass + for item in obj.items(): + pass + + def calibrate(self): + TYPE = self.TYPE + obj = self.TYPE((i, i) for i in range(30)) + for i in range(self.rounds): + pass + + @register_tests(__name__, version, 5, 1500, calibrate) + def medium(self): + TYPE = self.TYPE + obj = self.TYPE((i, i) for i in range(30)) + for i in range(self.rounds): + for item in obj.items(): + pass + for item in obj.items(): + pass + for item in obj.items(): + pass + for item in obj.items(): + pass + for item in obj.items(): + pass + + +################################################# +# inspection + +class Equals(ODictTest): + + version = 2.1 + + def calibrate(self): + obj1 = self.TYPE((i, i) for i in range(3)) + obj2 = self.TYPE((i, i) for i in range(3)) + for i in range(self.rounds): + pass + + @register_tests(__name__, version, 5, 15000, calibrate) + def varied(self): + obj1 = self.TYPE((i, i) for i in range(3)) + obj2 = self.TYPE((i, i) for i in range(3)) + for i in range(self.rounds): + x = (obj1 == obj1) + x = (obj1 == 5) + x = (obj1 == {0: 0, 1: 1, 2: 2}) + x = (obj1 == None) + x = (obj1 == obj2) + + +################################################# +# should be same as dict + +class Contains(ODictTest): + + version = 2.1 + + def calibrate(self): + TYPE = self.TYPE + obj = self.TYPE((i, i) for i in range(1, 10, 2)) + for i in range(self.rounds): + pass + + @register_tests(__name__, version, 3 * 10, 10000, calibrate) + def small(self): + TYPE = self.TYPE + obj = self.TYPE((i, i) for i in range(1, 10, 2)) + for i in range(self.rounds): + x = (1 in obj) + x = (2 in obj) + x = (3 in obj) + x = (4 in obj) + x = (5 in obj) + x = (6 in obj) + x = (7 in obj) + x = (8 in obj) + x = (9 in obj) + x = (10 in obj) + + x = (1 in obj) + x = (2 in obj) + x = (3 in obj) + x = (4 in obj) + x = (5 in obj) + x = (6 in obj) + x = (7 in obj) + x = (8 in obj) + x = (9 in obj) + x = (10 in obj) + + x = (1 in obj) + x = (2 in obj) + x = (3 in obj) + x = (4 in obj) + x = (5 in obj) + x = (6 in obj) + x = (7 in obj) + x = (8 in obj) + x = (9 in obj) + x = (10 in obj) + + +class Size(ODictTest): + + version = 2.1 + + def calibrate(self): + obj1 = self.TYPE() + obj2 = self.TYPE((i, i) for i in range(3)) + obj3 = self.TYPE((i, i) for i in range(10)) + obj4 = self.TYPE((i, i) for i in range(30)) + obj5 = self.TYPE((i, i) for i in range(100)) + for i in range(self.rounds): + pass + + @register_tests(__name__, version, 5, 30000, calibrate) + def varied(self): + obj1 = self.TYPE() + obj2 = self.TYPE((i, i) for i in range(3)) + obj3 = self.TYPE((i, i) for i in range(10)) + obj4 = self.TYPE((i, i) for i in range(30)) + obj5 = self.TYPE((i, i) for i in range(100)) + for i in range(self.rounds): + x = len(obj1) + x = len(obj2) + x = len(obj3) + x = len(obj4) + x = len(obj5) + + +class GetItem(ODictTest): + + version = 2.1 + + def calibrate(self): + obj = self.TYPE((i, i) for i in range(5)) + for i in range(self.rounds): + pass + + @register_tests(__name__, version, 6 * 5, 10000, calibrate) + def small(self): + obj = self.TYPE((i, i) for i in range(5)) + for i in range(self.rounds): + x = obj[0] + x = obj[1] + x = obj[2] + x = obj[3] + x = obj[4] + + x = obj[0] + x = obj[1] + x = obj[2] + x = obj[3] + x = obj[4] + + x = obj[0] + x = obj[1] + x = obj[2] + x = obj[3] + x = obj[4] + + x = obj[0] + x = obj[1] + x = obj[2] + x = obj[3] + x = obj[4] + + x = obj[0] + x = obj[1] + x = obj[2] + x = obj[3] + x = obj[4] + + x = obj[0] + x = obj[1] + x = obj[2] + x = obj[3] + x = obj[4] + + def calibrate(self): + obj = self.TYPE((i, i) for i in range(30)) + for i in range(self.rounds): + pass + + @register_tests(__name__, version, 6 * 5, 10000, calibrate) + def medium(self): + obj = self.TYPE((i, i) for i in range(30)) + for i in range(self.rounds): + x = obj[0] + x = obj[1] + x = obj[2] + x = obj[3] + x = obj[4] + + x = obj[0] + x = obj[1] + x = obj[2] + x = obj[3] + x = obj[4] + + x = obj[0] + x = obj[1] + x = obj[2] + x = obj[3] + x = obj[4] + + x = obj[0] + x = obj[1] + x = obj[2] + x = obj[3] + x = obj[4] + + x = obj[0] + x = obj[1] + x = obj[2] + x = obj[3] + x = obj[4] + + x = obj[0] + x = obj[1] + x = obj[2] + x = obj[3] + x = obj[4] + + +class Get(ODictTest): + + version = 2.1 + + def calibrate(self): + obj = self.TYPE((i, i) for i in range(3)) + for i in range(self.rounds): + pass + + @register_tests(__name__, version, 6 * 5, 2500, calibrate) + def small(self): + obj = self.TYPE((i, i) for i in range(3)) + for i in range(self.rounds): + x = obj.get(0) + x = obj.get(1) + x = obj.get(2) + x = obj.get(3) + x = obj.get(4) + + x = obj.get(0) + x = obj.get(1) + x = obj.get(2) + x = obj.get(3) + x = obj.get(4) + + x = obj.get(0) + x = obj.get(1) + x = obj.get(2) + x = obj.get(3) + x = obj.get(4) + + x = obj.get(0) + x = obj.get(1) + x = obj.get(2) + x = obj.get(3) + x = obj.get(4) + + x = obj.get(0) + x = obj.get(1) + x = obj.get(2) + x = obj.get(3) + x = obj.get(4) + + x = obj.get(0) + x = obj.get(1) + x = obj.get(2) + x = obj.get(3) + x = obj.get(4) + + def calibrate(self): + obj = self.TYPE((i, i) for i in range(30)) + for i in range(self.rounds): + pass + + @register_tests(__name__, version, 6 * 5, 2500, calibrate) + def medium(self): + obj = self.TYPE((i, i) for i in range(30)) + for i in range(self.rounds): + x = obj.get(0) + x = obj.get(1) + x = obj.get(2) + x = obj.get(3) + x = obj.get(4) + + x = obj.get(0) + x = obj.get(1) + x = obj.get(2) + x = obj.get(3) + x = obj.get(4) + + x = obj.get(0) + x = obj.get(1) + x = obj.get(2) + x = obj.get(3) + x = obj.get(4) + + x = obj.get(0) + x = obj.get(1) + x = obj.get(2) + x = obj.get(3) + x = obj.get(4) + + x = obj.get(0) + x = obj.get(1) + x = obj.get(2) + x = obj.get(3) + x = obj.get(4) + + x = obj.get(0) + x = obj.get(1) + x = obj.get(2) + x = obj.get(3) + x = obj.get(4) diff --git a/Tools/pybench/Setup.py b/Tools/pybench/Setup.py --- a/Tools/pybench/Setup.py +++ b/Tools/pybench/Setup.py @@ -41,3 +41,8 @@ from Unicode import * except (ImportError, SyntaxError): pass +try: + from OrderedDict import * +#except (ImportError, SyntaxError): +except (ImportError): + pass