def test_update_in(): assert update_in({"a": 0}, ["a"], inc) == {"a": 1} assert update_in({"a": 0, "b": 1}, ["b"], str) == {"a": 0, "b": "1"} assert update_in({"t": 1, "v": {"a": 0}}, ["v", "a"], inc) == {"t": 1, "v": {"a": 1}} # Handle one missing key. assert update_in({}, ["z"], str, None) == {"z": "None"} assert update_in({}, ["z"], inc, 0) == {"z": 1} assert update_in({}, ["z"], lambda x: x + "ar", default="b") == {"z": "bar"} # Same semantics as Clojure for multiple missing keys, ie. recursively # create nested empty dictionaries to the depth specified by the # keys with the innermost value set to f(default). assert update_in({}, [0, 1], inc, default=-1) == {0: {1: 0}} assert update_in({}, [0, 1], str, default=100) == {0: {1: "100"}} assert update_in({"foo": "bar", 1: 50}, ["d", 1, 0], str, 20) == {"foo": "bar", 1: 50, "d": {1: {0: "20"}}} # Verify immutability: d = {"x": 1} oldd = d update_in(d, ["x"], inc) assert d is oldd
def test_update_in(self): D, kw = self.D, self.kw assert update_in(D({"a": 0}), ["a"], inc, **kw) == D({"a": 1}) assert update_in(D({"a": 0, "b": 1}), ["b"], str, **kw) == D({"a": 0, "b": "1"}) assert (update_in(D({"t": 1, "v": D({"a": 0})}), ["v", "a"], inc, **kw) == D({"t": 1, "v": D({"a": 1})})) # Handle one missing key. assert update_in(D({}), ["z"], str, None, **kw) == D({"z": "None"}) assert update_in(D({}), ["z"], inc, 0, **kw) == D({"z": 1}) assert update_in(D({}), ["z"], lambda x: x+"ar", default="b", **kw) == D({"z": "bar"}) # Same semantics as Clojure for multiple missing keys, ie. recursively # create nested empty dictionaries to the depth specified by the # keys with the innermost value set to f(default). assert update_in(D({}), [0, 1], inc, default=-1, **kw) == D({0: D({1: 0})}) assert update_in(D({}), [0, 1], str, default=100, **kw) == D({0: D({1: "100"})}) assert (update_in(D({"foo": "bar", 1: 50}), ["d", 1, 0], str, 20, **kw) == D({"foo": "bar", 1: 50, "d": D({1: D({0: "20"})})})) # Verify immutability: d = D({'x': 1}) oldd = d update_in(d, ['x'], inc, **kw) assert d is oldd
def test_update_in(): assert update_in({"a": 0}, ["a"], inc) == {"a": 1} assert update_in({"a": 0, "b": 1}, ["b"], str) == {"a": 0, "b": "1"} assert (update_in({ "t": 1, "v": { "a": 0 } }, ["v", "a"], inc) == { "t": 1, "v": { "a": 1 } }) # Handle one missing key. assert update_in({}, ["z"], str, None) == {"z": "None"} assert update_in({}, ["z"], inc, 0) == {"z": 1} assert update_in({}, ["z"], lambda x: x + "ar", default="b") == { "z": "bar" } # Same semantics as Clojure for multiple missing keys, ie. recursively # create nested empty dictionaries to the depth specified by the # keys with the innermost value set to f(default). assert update_in({}, [0, 1], inc, default=-1) == {0: {1: 0}} assert update_in({}, [0, 1], str, default=100) == {0: {1: "100"}} assert (update_in({ "foo": "bar", 1: 50 }, ["d", 1, 0], str, 20) == { "foo": "bar", 1: 50, "d": { 1: { 0: "20" } } }) # Verify immutability: d = {'x': 1} oldd = d update_in(d, ['x'], inc) assert d is oldd