def test_reorderm(m): def invert_inner(d): return {k: u.invertm(v) for k, v in d.items()} flipped = u.flipm(m) # flipping the inner map. assert u.reorderm(m, (0, 2, 1)) == invert_inner(m) # Flipping the outer keys is equivalent to calling flipm once. assert u.reorderm(m, (1, 0, 2)) == flipped # Reordering the inner keys is equiv to flipping the outer keys the # flipping the new inner dictionary. assert u.reorderm(m, (1, 2, 0)) == invert_inner(flipped) # Flipping again brings the original list entry out. assert u.reorderm(m, (2, 1, 0)) == u.flipm(invert_inner(flipped))
def test_flipm_unit(self): m = {"a": {1: "a_one", 2: "a_two"}, "b": {1: "b_one", 3: "b_three"}} expected = { 1: { "a": "a_one", "b": "b_one" }, 2: { "a": "a_two" }, 3: { "b": "b_three" } } # Flipping does what we expect! self.assertDictEqual(u.flipm(m), expected)
def test_flipm_unit(): m = {"a": {1: "a_one", 2: "a_two"}, "b": {1: "b_one", 3: "b_three"}} expected = { 1: { "a": "a_one", "b": "b_one" }, 2: { "a": "a_two" }, 3: { "b": "b_three" } } # Flipping does what we expect! assert u.flipm(m) == expected
def test_flipm_empty_values(self, ks): """Flipping a dictionary with empty values always equals the empty map.""" m = u.dict_by(ks, lambda k: {}) self.assertDictEqual({}, u.flipm(m))
def test_flipm(self, m): # As long as an inner dictionary isn't empty, flipping is invertible. self.assertDictEqual(m, u.flipm(u.flipm(m)))
def test_flipm_empty_values(ks): """Flipping a dictionary with empty values always equals the empty map.""" m = u.dict_by(ks, lambda k: {}) assert {} == u.flipm(m)
def test_flipm(m): # As long as an inner dictionary isn't empty, flipping is invertible. assert m == u.flipm(u.flipm(m))