def test_ranges_by_all():
rd1 = RangeDictionary(10, defaults)
view = rd1[1, 2, 4, 5, 6, 7]
view["a"] = "foo"
assert [(0, 1, {
"a": "alpha",
"b": "bravo"
}), (1, 3, {
"a": "foo",
"b": "bravo"
}), (3, 4, {
"a": "alpha",
"b": "bravo"
}), (4, 8, {
"a": "foo",
"b": "bravo"
}), (8, 10, {
"a": "alpha",
"b": "bravo"
})] == rd1.get_ranges()
assert [(1, 3, {
"a": "foo",
"b": "bravo"
}), (4, 8, {
"a": "foo",
"b": "bravo"
})] == view.get_ranges()
rd1[5]["a"] = "bar"
assert [(1, 3, {"a": "foo", "b": "bravo"}),
(4, 5, {"a": "foo", "b": "bravo"}),
(5, 6, {"a": "bar", "b": "bravo"}),
(6, 8, {"a": "foo", "b": "bravo"})] \
== view.get_ranges()
def test_copy():
rd = RangeDictionary(3)
a_list1 = RangedList(3, [1, 2, 3])
a_list2 = RangedList(3, 5)
a_calc1 = a_list1 * 4
a_calc2 = a_list2 * 4
rd["list1"] = a_list1
rd["list2"] = a_list2
rd["calc1"] = a_calc1
rd["calc2"] = a_calc2
rd2 = rd.copy()
a_list1_copy = rd2["list1"]
assert a_list1_copy == [1, 2, 3]
assert list(a_list1_copy.iter_ranges()) == \
[(0, 1, 1), (1, 2, 2), (2, 3, 3)]
a_list2_copy = rd2["list2"]
assert list(a_list2_copy.iter_ranges()) == [(0, 3, 5)]
assert a_list2_copy == [5, 5, 5]
calc1_copy = rd2["calc1"]
assert calc1_copy == [4, 8, 12]
assert list(calc1_copy.iter_ranges()) == \
[(0, 1, 4), (1, 2, 8), (2, 3, 12)]
calc2_copy = rd2["calc2"]
assert calc2_copy == [20, 20, 20]
assert list(calc2_copy.iter_ranges()) == [(0, 3, 20)]
def test_ranges_by_key():
rd1 = RangeDictionary(10, defaults)
single1 = rd1[4]
assert [(4, 5, "alpha")] == list(single1.iter_ranges(key="a"))
single1["a"] = "foo"
assert [(0, 4, "alpha"), (4, 5, "foo"), (5, 10, "alpha")] == \
rd1.get_ranges(key="a")
assert [(4, 5, "foo")] == list(single1.iter_ranges(key="a"))
def test_ranges_by_key():
rd1 = RangeDictionary(10, defaults)
view = rd1[1, 2, 4, 5, 6, 7]
view["a"] = "foo"
assert [(0, 1, "alpha"), (1, 3, "foo"), (3, 4, "alpha"), (4, 8, "foo"),
(8, 10, "alpha")] == list(rd1.iter_ranges(key="a"))
assert [(1, 3, "foo"), (4, 8, "foo")] == list(view.iter_ranges(key="a"))
rd1[5]["a"] = "bar"
assert [(1, 3, "foo"), (4, 5, "foo"), (5, 6, "bar"), (6, 8, "foo")] \
== list(view.iter_ranges(key="a"))
def test_ranges_by_key():
rd1 = RangeDictionary(10, defaults)
slice_view1 = rd1[4:7]
assert [(4, 7, "alpha")] == list(slice_view1.iter_ranges(key="a"))
slice_view1["a"] = "foo"
assert [(0, 4, "alpha"), (4, 7, "foo"), (7, 10, "alpha")] \
== rd1.get_ranges(key="a")
assert [(4, 7, "foo")] == list(slice_view1.iter_ranges(key="a"))
rd1[5]["a"] = "bar"
assert [(4, 5, "foo"), (5, 6, "bar"), (6, 7, "foo")] \
== list(slice_view1.iter_ranges(key="a"))
def test_empty():
rd1 = RangeDictionary(10)
rl = RangedList(10, "gamma")
rd1["g"] = rl
rd1["a"] = "alpha"
rd1["b"] = [
"bravo", "bravo", "bravo", "bravo", "bravo", "bravo", "bravo", "bravo",
"bravo", "bravo"
]
new_dict = {"a": "alpha", "b": "bravo", "g": "gamma"}
assert new_dict == rd1.get_value()
def test_iter_by_slice():
rd1 = RangeDictionary(10)
rd1["g"] = "gamma"
rd1["a"] = "alpha"
rd1["b"] = [
"bravo0", "bravo1", "bravo2", "bravo3", "bravo4", "bravo5", "bravo6",
"bravo7", "bravo8+", "bravo9"
]
slice_view1 = rd1[2:4]
iterator = slice_view1.iter_all_values()
assert {"a": "alpha", "b": "bravo2", "g": "gamma"} == next(iterator)
assert {"a": "alpha", "b": "bravo3", "g": "gamma"} == next(iterator)
with pytest.raises(StopIteration):
next(iterator)
iterator = slice_view1.iter_all_values(update_save=True)
assert {"a": "alpha", "b": "bravo2", "g": "gamma"} == next(iterator)
rd1["b"][3] = "new3"
assert {"a": "alpha", "b": "new3", "g": "gamma"} == next(iterator)
with pytest.raises(StopIteration):
next(iterator)
rd1["b"][3] = "bravo3"
iterator = slice_view1.iter_all_values(key="b")
assert "bravo2" == next(iterator)
assert "bravo3" == next(iterator)
with pytest.raises(StopIteration):
next(iterator)
iterator = slice_view1.iter_all_values(update_save=True, key="b")
assert "bravo2" == next(iterator)
rd1["b"][3] = "new3"
assert "new3" == next(iterator)
with pytest.raises(StopIteration):
next(iterator)
rd1["b"][3] = "bravo3"
iterator = rd1.iter_values_by_slice(2, 4, key=["b", "a"])
assert {"a": "alpha", "b": "bravo2"} == next(iterator)
assert {"a": "alpha", "b": "bravo3"} == next(iterator)
with pytest.raises(StopIteration):
next(iterator)
iterator = rd1.iter_values_by_slice(2, 4, key=["b", "a"], update_save=True)
assert {"a": "alpha", "b": "bravo2"} == next(iterator)
rd1["b"][3] = "new3"
assert {"a": "alpha", "b": "new3"} == next(iterator)
with pytest.raises(StopIteration):
next(iterator)
rd1["b"][3] = "bravo3"
def test_ranges_all():
rd1 = RangeDictionary(10, defaults)
assert [(0, 10, {"a": "alpha", "b": "bravo"})] == rd1.get_ranges()
rd1[4]["a"] = "foo"
assert [(0, 4, {
"a": "alpha",
"b": "bravo"
}), (4, 5, {
"a": "foo",
"b": "bravo"
}), (5, 10, {
"a": "alpha",
"b": "bravo"
})] == rd1.get_ranges()
def test_iter_values():
rd1 = RangeDictionary(10, defaults)
single1 = rd1[4]
aware = rd1.iter_all_values(key="a", update_save=True)
fast = rd1.iter_all_values(key="a", update_save=False)
assert [
"alpha", "alpha", "alpha", "alpha", "alpha", "alpha", "alpha", "alpha",
"alpha", "alpha"
] == list(fast)
single1["a"] = "Foo"
assert [
"alpha", "alpha", "alpha", "alpha", "Foo", "alpha", "alpha", "alpha",
"alpha", "alpha"
] == list(aware)
def test_iter_tests():
rd1 = RangeDictionary(10)
rl = RangedList(10, "gamma")
rd1["g"] = rl
rd1["a"] = "alpha"
rd1["b"] = [
"bravo", "bravo", "bravo", "bravo", "bravo", "bravo", "bravo", "bravo",
"bravo", "bravo"
]
result = set(rd1.iteritems())
check = {('a', 'alpha'), ('b', 'bravo'), ('g', 'gamma')}
assert check == result
result = set(rd1.itervalues())
check = {'alpha', 'bravo', 'gamma'}
assert check == result
def test_reset():
rd1 = RangeDictionary(10)
rl = RangedList(10, "gamma")
rd1["g"] = rl
rd1["a"] = "alpha"
rd1["b"] = [
"bravo", "bravo", "bravo", "bravo", "bravo", "bravo", "bravo", "bravo",
"bravo", "bravo"
]
rd1["a"] = "beta"
rd1.reset("a")
assert rd1["a"] == [
"alpha", "alpha", "alpha", "alpha", "alpha", "alpha", "alpha", "alpha",
"alpha", "alpha"
]
def test_ranges_all():
rd1 = RangeDictionary(10, defaults)
slice_view1 = rd1[4:7]
assert [(4, 7, {"a": "alpha", "b": "bravo"})] == \
list(slice_view1.iter_ranges())
slice_view1["a"] = "foo"
assert [(0, 4, {"a": "alpha", "b": "bravo"}),
(4, 7, {"a": "foo", "b": "bravo"}),
(7, 10, {"a": "alpha", "b": "bravo"})] \
== rd1.get_ranges()
assert [(4, 7, {"a": "foo", "b": "bravo"})] == \
list(slice_view1.iter_ranges())
rd1[5]["a"] = "bar"
assert [(4, 5, {"a": "foo", "b": "bravo"}),
(5, 6, {"a": "bar", "b": "bravo"}),
(6, 7, {"a": "foo", "b": "bravo"})] == \
list(slice_view1.iter_ranges())
def test_iter_values_keys():
rd1 = RangeDictionary(10, defaults)
aware = rd1.iter_all_values(key=("a", "b"), update_save=True)
fast = rd1.iter_all_values(key=("b", "a"), update_save=False)
assert [{'a': 'alpha', 'b': 'bravo'}, {'a': 'alpha', 'b': 'bravo'},
{'a': 'alpha', 'b': 'bravo'}, {'a': 'alpha', 'b': 'bravo'},
{'a': 'alpha', 'b': 'bravo'}, {'a': 'alpha', 'b': 'bravo'},
{'a': 'alpha', 'b': 'bravo'}, {'a': 'alpha', 'b': 'bravo'},
{'a': 'alpha', 'b': 'bravo'}, {'a': 'alpha', 'b': 'bravo'}] \
== list(fast)
rd1[4]["a"] = "Foo"
rd1[6]["b"] = "Bar"
assert [{'a': 'alpha', 'b': 'bravo'}, {'a': 'alpha', 'b': 'bravo'},
{'a': 'alpha', 'b': 'bravo'}, {'a': 'alpha', 'b': 'bravo'},
{'a': 'Foo', 'b': 'bravo'}, {'a': 'alpha', 'b': 'bravo'},
{'a': 'alpha', 'b': 'Bar'}, {'a': 'alpha', 'b': 'bravo'},
{'a': 'alpha', 'b': 'bravo'}, {'a': 'alpha', 'b': 'bravo'}] \
== list(aware)
def test_iter_values():
rd1 = RangeDictionary(10, defaults)
slice_view1 = rd1[4:7]
aware = slice_view1.iter_all_values("a", update_save=False)
fast = slice_view1.iter_all_values("a", update_save=True)
assert ["alpha", "alpha", "alpha"] == list(fast)
rd1["a"] = "Foo"
assert rd1["a"].get_single_value_all() == "Foo"
assert ["Foo", "Foo", "Foo"] == list(aware)
def test_iter_values():
rd1 = RangeDictionary(10, defaults)
ranged_view1 = rd1[2, 3, 8]
aware = ranged_view1.iter_all_values("a", update_save=False)
fast = ranged_view1.iter_all_values("a", update_save=True)
assert ["alpha", "alpha", "alpha"] == list(fast)
rd1["a"] = "Foo"
assert rd1["a"][0] == "Foo"
assert ["Foo", "Foo", "Foo"] == list(aware)
def test_iter_values_keys():
rd1 = RangeDictionary(10, defaults)
single1 = rd1[4]
aware = single1.iter_all_values(key=("a", "b"), update_save=False)
fast = single1.iter_all_values(key=("b", "a"), update_save=True)
assert [{'a': 'alpha', 'b': 'bravo'}] == list(fast)
rd1["a"] = "Foo"
assert rd1["a"].get_single_value_all() == "Foo"
assert [{'a': 'Foo', 'b': 'bravo'}] == list(aware)
def test_iter_by_slice():
rd1 = RangeDictionary(10)
rl = RangedList(10, "gamma")
rd1["g"] = rl
rd1["a"] = "alpha"
rd1["b"] = [
"bravo0", "bravo1", "bravo2", "bravo3", "bravo4", "bravo5", "bravo6",
"bravo7", "bravo8+", "bravo9"
]
iterator = rd1.iter_values_by_slice(2, 4)
assert {"a": "alpha", "b": "bravo2", "g": "gamma"} == next(iterator)
assert {"a": "alpha", "b": "bravo3", "g": "gamma"} == next(iterator)
with pytest.raises(StopIteration):
next(iterator)
iterator = rd1.iter_values_by_slice(2, 4, update_save=True)
assert {"a": "alpha", "b": "bravo2", "g": "gamma"} == next(iterator)
rd1["b"][3] = "new3"
assert {"a": "alpha", "b": "new3", "g": "gamma"} == next(iterator)
with pytest.raises(StopIteration):
next(iterator)
rd1["b"][3] = "bravo3"
iterator = rd1.iter_values_by_slice(2, 4, key="b")
assert "bravo2" == next(iterator)
assert "bravo3" == next(iterator)
with pytest.raises(StopIteration):
next(iterator)
iterator = rd1.iter_values_by_slice(2, 4, key="b", update_save=True)
assert "bravo2" == next(iterator)
rd1["b"][3] = "new3"
assert "new3" == next(iterator)
with pytest.raises(StopIteration):
assert "OVERFLOW" == next(iterator)
rd1["b"][3] = "bravo3"
iterator = rd1.iter_values_by_slice(2, 4, key=["b", "a"])
assert {"a": "alpha", "b": "bravo2"} == next(iterator)
assert {"a": "alpha", "b": "bravo3"} == next(iterator)
with pytest.raises(StopIteration):
next(iterator)
iterator = rd1.iter_values_by_slice(2, 4, key=["b", "a"], update_save=True)
assert {"a": "alpha", "b": "bravo2"} == next(iterator)
rd1["b"][3] = "new3"
assert {"a": "alpha", "b": "new3"} == next(iterator)
with pytest.raises(StopIteration):
next(iterator)
rd1["b"][3] = "bravo3"
def test_contains():
rd1 = RangeDictionary(10)
rl = RangedList(10, "gamma")
rd1["g"] = rl
rd1["a"] = "alpha"
rd1["b"] = [
"bravo", "bravo", "bravo", "bravo", "bravo", "bravo", "bravo", "bravo",
"bravo", "bravo"
]
assert "a" in rd1
assert "alpha" not in rd1
assert 1 in rd1
assert 14 not in rd1
with pytest.raises(KeyError):
assert (rl in rd1)
def test_set():
rd1 = RangeDictionary(10, defaults)
single1 = rd1.view_factory([4])
assert single1.get_value("a") == "alpha"
single1["a"] = "foo"
assert single1.get_value("a") == "foo"
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program. If not, see <http://www.gnu.org/licenses/>.
from spinn_utilities.ranged import RangeDictionary
defaults = {"a": "alpha", "b": "bravo"}
rd = RangeDictionary(10, defaults)
def test_full():
assert [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] == list(rd.ids())
def test_single():
view = rd[2]
assert [2] == list(view.ids())
def test_simple_slice():
view = rd[2:6]
assert [2, 3, 4, 5] == list(view.ids())
def test_set_list():
rd1 = RangeDictionary(10, defaults)
rl = RangedList(10, "gamma")
rd1["g"] = rl
new_dict = {"a": "alpha", "b": "bravo", "g": "gamma"}
assert new_dict == rd1.get_value()
def test_set_range():
rd1 = RangeDictionary(10, defaults)
rd1["a"] = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
assert rd1["a"] == [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
def test_ranges_by_key2():
rd1 = RangeDictionary(10, defaults)
assert [(0, 10, "alpha")] == rd1.get_ranges(key="a")
rd1[4]["a"] = "foo"
assert [(0, 4, "alpha"), (4, 5, "foo"), (5, 10, "alpha")] == \
rd1.get_ranges(key="a")
def test_set_range_direct():
rd1 = RangeDictionary(10, defaults)
slice_view1 = rd1[4:7]
assert "alpha" == slice_view1.get_value("a")
slice_view1["a"] = "Foo"
assert "Foo" == slice_view1.get_value("a")
def test_bad_set():
rd1 = RangeDictionary(10)
with pytest.raises(KeyError):
rd1[2] = "This should not work"
with pytest.raises(KeyError):
rd1[rd] = "This should not work"
def test_ranges_by_key():
rd1 = RangeDictionary(10, defaults)
assert [(0, 10, "alpha")] == rd1.get_ranges(key="a")
def test_set_range_direct():
rd1 = RangeDictionary(10, defaults)
assert "alpha" == rd1["a"].get_single_value_all()
rd1["a"] = "Foo"
assert "Foo" == rd1["a"].get_single_value_all()
