def test_add_in_order(self):
d = OrderedDict()
d[1] = "a"
d[2] = "b"
d[3] = "c"
d[4] = "d"
d[5] = "e"
d[6] = "f"
d[7] = "g"
self.assertEqual([1, 2, 3, 4, 5, 6, 7], list(d.keys()))
self.assertEqual(["a", "b", "c", "d", "e", "f", "g"], list(d.values()))
def diff_ecdf_plot(self):
"""Generate ECDF plot of differences between test classes."""
if not self.draw_ecdf_plot:
return
data = self.load_data()
fig = Figure(figsize=(16, 12))
canvas = FigureCanvas(fig)
axes = fig.add_subplot(1, 1, 1)
classnames = iter(data)
base = next(classnames)
base_data = data.loc[:, base]
# parameters for the zoomed-in graphs of ecdf
zoom_params = OrderedDict([("98", (0.01, 0.99)), ("33", (0.33, 0.66)),
("10", (0.45, 0.55))])
zoom_values = OrderedDict(
(name, [float("inf"), float("-inf")])
for name in zoom_params.keys())
for classname in classnames:
# calculate the ECDF
values = data.loc[:, classname]
levels = np.linspace(1. / len(values), 1, len(values))
values = sorted(values - base_data)
axes.step(values, levels, where='post')
# calculate the bounds for the zoom positions
quantiles = np.quantile(values, list(chain(*zoom_params.values())))
quantiles = iter(quantiles)
for low, high, name in \
zip(quantiles, quantiles, zoom_params.keys()):
zoom_values[name][0] = min(zoom_values[name][0], low)
zoom_values[name][1] = max(zoom_values[name][1], high)
fig.legend(list("{0}-0".format(i)
for i in range(1, len(list(values)))),
ncol=6,
loc='upper center',
bbox_to_anchor=(0.5, -0.05))
axes.set_title("Empirical Cumulative Distribution Function of "
"class differences")
axes.set_xlabel("Time")
axes.set_ylabel("Cumulative probability")
formatter = mpl.ticker.EngFormatter('s')
axes.get_xaxis().set_major_formatter(formatter)
canvas.print_figure(join(self.output, "diff_ecdf_plot.png"),
bbox_inches="tight")
# now graph progressive zooms of the central portion
for name, quantiles, values in \
zip(zoom_params.keys(), zoom_params.values(),
zoom_values.values()):
axes.set_ylim(quantiles)
# make the bounds a little weaker so that the extreme positions
# are visible of graph too
axes.set_xlim([values[0] * 0.98, values[1] * 1.02])
canvas.print_figure(join(
self.output, "diff_ecdf_plot_zoom_in_{0}.png".format(name)),
bbox_inches="tight")
class TestOrderedDict(unittest.TestCase):
def setUp(self):
self.d = OrderedDict()
self.d[1] = "a"
self.d[2] = "b"
self.d[3] = "c"
def test___init__(self):
d = OrderedDict()
self.assertIsInstance(d, dict)
def test___init___with_invalid_params(self):
with self.assertRaises(TypeError):
OrderedDict(12, "a")
def test___init___with_dict(self):
d = OrderedDict({12: "a", 14: "b"})
self.assertEqual({12: "a", 14: "b"}, d)
def test_add_in_order(self):
d = OrderedDict()
d[1] = "a"
d[2] = "b"
d[3] = "c"
d[4] = "d"
d[5] = "e"
d[6] = "f"
d[7] = "g"
self.assertEqual([1, 2, 3, 4, 5, 6, 7], list(d.keys()))
self.assertEqual(["a", "b", "c", "d", "e", "f", "g"], list(d.values()))
def test_del(self):
del self.d[2]
self.assertEqual([1, 3], list(self.d.keys()))
self.assertEqual(["a", "c"], list(self.d.values()))
def test_iter(self):
self.assertEqual([1, 2, 3], list(iter(self.d)))
def test_popitem(self):
n, v = self.d.popitem()
self.assertEqual(n, 3)
self.assertEqual(v, "c")
self.assertEqual([1, 2], list(self.d.keys()))
self.assertEqual(["a", "b"], list(self.d.values()))
def test_popitem_on_empty(self):
d = OrderedDict()
with self.assertRaises(KeyError):
d.popitem()
def test_popitem_first(self):
if type(self.d) is dict:
self.skipTest("not popitem(last=False) in dict")
else:
n, v = self.d.popitem(last=False)
self.assertEqual(n, 1)
self.assertEqual(v, "a")
self.assertEqual([2, 3], list(self.d.keys()))
self.assertEqual(["b", "c"], list(self.d.values()))
def test_items(self):
self.assertEqual([(1, "a"), (2, "b"), (3, "c")], list(self.d.items()))
def test_iterkeys(self):
if type(self.d) is dict:
self.skipTest("no iterkeys in dict")
else:
self.assertEqual(list(self.d.iterkeys()), list(iter(self.d)))
def test_clear(self):
self.d.clear()
self.assertEqual([], list(self.d.items()))
def test_itervalues(self):
if type(self.d) is dict:
self.skipTest("no itervalues in dict")
else:
self.assertEqual(list(self.d.itervalues()), self.d.values())
def test_update_with_too_many_args(self):
with self.assertRaises(TypeError):
self.d.update(0, None)
def test_update_with_dict(self):
self.d.update({0: None})
self.assertEqual([(1, "a"), (2, "b"), (3, "c"), (0, None)],
list(self.d.items()))
def test_update_with_list_of_tuples(self):
d = OrderedDict()
d.update([(3, "c"), (2, "b"), (1, "a")])
self.assertEqual([3, 2, 1], list(d.keys()))
self.assertEqual(["c", "b", "a"], list(d.values()))
def test_update_with_keyword_args(self):
d = OrderedDict()
d.update(a='1', b='2', c='3')
self.assertEqual(set(['1', '2', '3']), set(d.values()))
self.assertEqual(set(['a', 'b', 'c']), set(d.keys()))
def test_pop(self):
v = self.d.pop(2)
self.assertEqual(v, "b")
self.assertEqual([(1, "a"), (3, "c")], list(self.d.items()))
def test_pop_non_existent(self):
with self.assertRaises(KeyError):
self.d.pop(4)
def test_pop_with_default(self):
if type(self.d) is dict:
a = self.d.pop(0, "foo")
self.assertEqual(a, "foo")
else:
a = self.d.pop(0, default="foo")
self.assertEqual(a, "foo")
def test_repr(self):
if type(self.d) is dict:
self.assertEqual("{1: 'a', 2: 'b', 3: 'c'}", repr(self.d))
else:
self.assertEqual("OrderedDict([(1, 'a'), (2, 'b'), (3, 'c')])",
repr(self.d))
def test_repr_with_circular_dependancy(self):
del self.d[2]
self.d[2] = self.d
if type(self.d) is dict:
self.assertEqual("{1: 'a', 3: 'c', 2: {...}}", repr(self.d))
else:
self.assertEqual("OrderedDict([(1, 'a'), (3, 'c'), (2, ...)])",
repr(self.d))
def test_repr_with_empty(self):
d = OrderedDict()
if type(self.d) is dict:
self.assertEqual("{}", repr(d))
else:
self.assertEqual("OrderedDict()", repr(d))
def test_compare_different_order(self):
d2 = OrderedDict()
d2[1] = "a"
d2[3] = "c"
d2[2] = "b"
self.assertNotEqual(list(self.d.items()), list(d2.items()))
def test_update_with_keyword_args(self):
d = OrderedDict()
d.update(a='1', b='2', c='3')
self.assertEqual(set(['1', '2', '3']), set(d.values()))
self.assertEqual(set(['a', 'b', 'c']), set(d.keys()))
def test_update_with_list_of_tuples(self):
d = OrderedDict()
d.update([(3, "c"), (2, "b"), (1, "a")])
self.assertEqual([3, 2, 1], list(d.keys()))
self.assertEqual(["c", "b", "a"], list(d.values()))