One keyboard and mouse for a Mac and a Windows PC over the local network, in either direction.
import copy
import math
import unittest
from core import settings_sync, ways
from core.tests.crossing_harness import per_screen_layout
class AtlasTests(unittest.TestCase):
def test_taller_a_display_keeps_both_contacts_that_share_its_end_third(self):
held = {"machine_id": "A", "peers": [{"id": "B", "port": 24820, "side": ""}], "zones": []}
layout = {
"A": {"x": 100, "y": 0, "w": 200, "h": 120, "displays": {
"a1": {"x": 0, "y": 0, "w": 100, "h": 120},
"a0": {"x": 100, "y": 0, "w": 100, "h": 100},
}},
"B": {"x": 0, "y": 0, "w": 100, "h": 200, "displays": {
"b0": {"x": 0, "y": 0, "w": 100, "h": 100},
"b1": {"x": 0, "y": 100, "w": 100, "h": 100},
}},
}
result = ways.compile_layout(held, layout, now=10)
routes = {(zone.get("display"), zone.get("target_display"), zone["kind"])
for zone in result["settings"]["zones"] if zone.get("side") == "left"}
self.assertIn(("a1", "b1", "part"), routes)
def test_per_screen_contact_zones_keep_only_the_shared_span(self):
own, other = "own", "other"
held = {"machine_id": own, "peers": [{"id": other, "port": 24820, "side": "right"}], "zones": []}
layout = {
own: {"x": 0, "y": 0, "w": 100, "h": 100,
"displays": {"source": {"x": 0, "y": 0, "w": 100, "h": 100}}},
other: {"x": 100, "y": 0, "w": 100, "h": 125,
"displays": {"above": {"x": 0, "y": 0, "w": 100, "h": 25},
"target": {"x": 0, "y": 25, "w": 100, "h": 100}}},
}
result = ways.compile_layout(held, layout, now=10)
zone = next(zone for zone in result["settings"]["zones"] if zone.get("target_display") == "target")
self.assertEqual(zone["contact_span"], [0.25, 1.0])
self.assertEqual(zone["target_span"], [0.0, 0.75])
def test_per_screen_aba_below_compiles_on_both_machines(self):
def routes(result):
return {(zone["kind"], zone.get("display"), zone.get("side"), zone.get("corner"),
zone.get("target_display"), zone.get("target_side"), tuple(zone.get("parts", ())))
for zone in result["settings"]["zones"]}
cases = (
("equal displays", {}, "right", "left",
{("edge", "0", "right", None, "0", "left", ()),
("corner", "0", "right", "bottom_right", "1", "left", ()),
("edge", "1", "left", None, "0", "right", ()),
("corner", "1", "left", "bottom_left", "1", "right", ())},
{("edge", "0", "left", None, "0", "right", ()),
("edge", "0", "right", None, "1", "left", ()),
("corner", "1", "left", "top_left", "0", "right", ()),
("corner", "1", "right", "top_right", "1", "left", ())}),
("mixed logical display sizes", {"a_sizes": ((120, 100), (150, 100)),
"b_sizes": ((100, 100), (130, 90))}, "right", "left",
{("edge", "0", "right", None, "0", "left", ()),
("corner", "0", "right", "bottom_right", "1", "left", ()),
("edge", "1", "left", None, "0", "right", ()),
("part", "1", "bottom", None, "1", "top", ("start",))},
{("edge", "0", "left", None, "0", "right", ()),
("edge", "0", "right", None, "1", "left", ()),
("corner", "1", "left", "top_left", "0", "right", ()),
("part", "1", "top", None, "1", "bottom", ("end",))}),
("B1 offset left", {"b1_x": 80}, "right", "left",
{("edge", "0", "right", None, "0", "left", ()),
("part", "0", "bottom", None, "1", "top", ("end",)),
("edge", "1", "left", None, "0", "right", ())},
{("edge", "0", "left", None, "0", "right", ()),
("edge", "0", "right", None, "1", "left", ()),
("part", "1", "top", None, "0", "bottom", ("start",))}),
("B1 offset right", {"b1_x": 120}, "right", "left",
{("edge", "0", "right", None, "0", "left", ()),
("edge", "1", "left", None, "0", "right", ()),
("part", "1", "bottom", None, "1", "top", ("start",))},
{("edge", "0", "left", None, "0", "right", ()),
("edge", "0", "right", None, "1", "left", ()),
("part", "1", "top", None, "1", "bottom", ("end",))}),
)
for label, kwargs, side_a, side_b, zones_a, zones_b in cases:
with self.subTest(layout=label):
tiles = per_screen_layout(A, B, **kwargs)
settings_a = {"machine_id": A, "peers": [{"id": B, "port": 24820, "side": ""}], "zones": []}
settings_b = {"machine_id": B, "peers": [{"id": A, "port": 24820, "side": ""}], "zones": []}
from_a = ways.compile_layout(settings_a, tiles, now=10)
from_b = ways.compile_layout(settings_b, tiles, now=10)
self.assertTrue(from_a["accepted"])
self.assertTrue(from_b["accepted"])
self.assertEqual(from_a["settings"]["peers"][0]["side"], side_a)
self.assertEqual(from_b["settings"]["peers"][0]["side"], side_b)
self.assertEqual(routes(from_a), zones_a)
self.assertEqual(routes(from_b), zones_b)
def test_shifted_b1_keeps_the_machine_tile_scale_and_moves_only_its_display(self):
for offset in (80, 120):
with self.subTest(b1_offset=offset):
tile = per_screen_layout(A, B, b1_x=offset)[B]
frames = {frame["display"]: frame for frame in ways._display_frames(tile)}
self.assertEqual((tile["x"], tile["w"]), (100, 100))
self.assertEqual((frames["0"]["x"], frames["0"]["w"]), (100, 100))
self.assertEqual((frames["1"]["x"], frames["1"]["w"]), (offset, 100))
def test_per_screen_zones_include_both_aba_edges_and_b1_corner_routes(self):
tiles = per_screen_layout(A, B)
settings_a = {"machine_id": A, "peers": [{"id": B, "port": 24820, "side": ""}], "zones": []}
settings_b = {"machine_id": B, "peers": [{"id": A, "port": 24820, "side": ""}], "zones": []}
from_a = ways.compile_layout(settings_a, tiles, now=10)["settings"]["zones"]
from_b = ways.compile_layout(settings_b, tiles, now=10)["settings"]["zones"]
a_edges = {(zone.get("display"), zone.get("side"), zone.get("target_display"), zone.get("target_side"))
for zone in from_a if zone["kind"] == "edge"}
b_edges = {(zone.get("display"), zone.get("side"), zone.get("target_display"), zone.get("target_side"))
for zone in from_b if zone["kind"] == "edge"}
self.assertEqual(a_edges, {("0", "right", "0", "left"), ("1", "left", "0", "right")})
self.assertEqual(b_edges, {("0", "left", "0", "right"), ("0", "right", "1", "left")})
self.assertEqual({(zone.get("display"), zone.get("corner"), zone.get("target_display"), zone.get("target_side"))
for zone in from_a if zone["kind"] == "corner"},
{("0", "bottom_right", "1", "left"), ("1", "bottom_left", "1", "right")})
self.assertEqual({(zone.get("display"), zone.get("corner"), zone.get("target_display"), zone.get("target_side"))
for zone in from_b if zone["kind"] == "corner"},
{("1", "top_left", "0", "right"), ("1", "top_right", "1", "left")})
def test_layout_compile_edge_part_gap_and_corner(self):
settings = self.settings(A)
layout = self.picture(settings, A, self.tile(160, 0, 160, 100))
result = ways.compile_layout(settings, layout, now=10)
self.assertEqual(result["tiles"][A]["state"], "edge")
self.assertEqual(settings["peers"][0]["side"], "")
self.assertEqual(settings["zones"], [])
self.assertEqual(result["settings"]["peers"][0]["side"], "right")
self.assertEqual(ways.ways(result["settings"], A)["methods"], ["edge"])
settings = self.settings(A)
result = ways.compile_layout(settings, self.picture(settings, A, self.tile(160, 67, 160, 33)), now=10)
self.assertEqual(result["tiles"][A]["state"], "part")
self.assertEqual(ways.ways(result["settings"], A)["parts"], ["start", "middle", "end"])
self.assertEqual(result["settings"]["zones"], [{"peer": A, "kind": "part", "parts": ["end"],
"side": "right", "contact_span": [0.67, 1.0],
"target_span": [0.0, 1.0]}])
settings = self.settings(A)
result = ways.compile_layout(settings, self.picture(settings, A, self.tile(160, 20, 160, 10)), now=10)
self.assertEqual(result["tiles"][A]["state"], "gap")
self.assertEqual(ways.has_way(result["settings"], A), False)
settings = self.settings(A)
result = ways.compile_layout(settings, self.picture(settings, A, self.tile(160, 100, 100, 100)), now=10)
self.assertEqual(result["tiles"][A]["state"], "corner")
self.assertEqual(ways.ways(result["settings"], A)["methods"], ["edge"])
corner = next(zone for zone in result["settings"]["zones"] if zone["peer"] == A and zone["kind"] == "corner")
self.assertEqual(corner["edge"], ways.corner_edge(corner["corner"], "right"))
def test_two_peers_share_thirds_and_can_touch_elsewhere(self):
settings = self.settings(A, B)
layout = self.picture(settings, A, self.tile(160, 0, 160, 33), B, self.tile(160, 67, 160, 33))
result = ways.compile_layout(settings, layout, now=10)
self.assertEqual(ways.ways(result["settings"], A)["parts"], ["start", "middle", "end"])
self.assertEqual(ways.ways(result["settings"], B)["parts"], ["start", "middle", "end"])
self.assertEqual(result["settings"]["zones"], [
{"peer": A, "kind": "part", "parts": ["start"], "side": "right",
"contact_span": [0.0, 0.33], "target_span": [0.0, 1.0]},
{"peer": B, "kind": "part", "parts": ["end"], "side": "right",
"contact_span": [0.67, 1.0], "target_span": [0.0, 1.0]},
])
self.assertEqual(result["tiles"][A]["state"], "part")
self.assertEqual(result["tiles"][B]["state"], "part")
settings = self.settings(A)
settings = self.settings(A, B)
result = ways.compile_layout(settings, self.picture(settings, A, self.tile(320, 0, 160, 100), B, self.tile(480, 0, 160, 100)), now=10)
self.assertEqual(result["tiles"][B]["state"], "set-elsewhere")
settings = self.settings(A)
result = ways.compile_layout(settings, self.picture(settings, A, self.tile(160, 33, 160, 34)), now=10)
self.assertEqual(result["tiles"][A]["thirds"], ["middle"])
settings = self.settings(A)
result = ways.compile_layout(settings, self.picture(settings, A, self.tile(160, 15, 160, 36)), now=10)
self.assertEqual(result["tiles"][A]["thirds"], ["start", "middle"])
def test_fourth_contact_on_one_side_is_refused(self):
settings = self.settings(A, B, C, D)
layout = self.picture(settings,
D, self.tile(160, 51, 160, 17), A, self.tile(160, 0, 160, 17),
B, self.tile(160, 17, 160, 17), C, self.tile(160, 34, 160, 17))
result = ways.compile_layout(settings, layout, moved=A, now=10)
self.assertFalse(result["accepted"])
self.assertEqual(set(result["snap"]), {A})
self.assertEqual(result["tiles"][A]["state"], "overlap")
self.assertEqual(result["snap"][A], ways.snap_position(layout[A], settings["machine_id"],
{k: v for k, v in layout.items() if k != A}))
def test_unplaced_picture_peer_derives_no_side_and_keeps_its_ways(self):
settings = self.settings(A)
settings["peers"][0]["side"] = "left"
settings["zones"] = [{"peer": A, "kind": "edge"}, {"peer": A, "kind": "notch"}]
result = ways.compile_layout(settings, self.picture(settings, A, self.tile(400, 0, 160, 100)), now=10)
self.assertTrue(result["accepted"])
compiled = result["settings"]
self.assertEqual(compiled["peers"][0]["side"], "")
self.assertEqual(ways.ways(compiled, A)["methods"], ["edge", "notch"])
self.assertEqual(compiled["zones"], [])
def test_place_beside_centres_the_tile_for_a_whole_edge_and_keeps_its_fields(self):
layout = {"T": self.tile(0, 0, 160, 100), A: {**self.tile(700, 300, 160, 100), "name": "A"}}
self.assertEqual(ways.place_beside(layout, "T", A, "right"), {**self.tile(160, 0, 160, 100), "name": "A"})
self.assertEqual(ways.place_beside(layout, "T", A, "top"), {**self.tile(0, -100, 160, 100), "name": "A"})
layout[B] = self.tile(160, 0, 160, 100)
moved = ways.place_beside(layout, "T", A, "right")
self.assertFalse(ways._overlaps(moved, layout[B]))
self.assertEqual(moved["name"], "A")
def test_overlap_refused_with_nearest_free_snap(self):
near = ways.snap_position(self.tile(162, -50, 160, 100), "T",
{"T": self.tile(0, 0, 160, 100)}, radius=12)
self.assertEqual(near, self.tile(160, -50, 160, 100))
occupied = {"T": self.tile(0, 0, 160, 100), A: self.tile(160, 0, 160, 100)}
target = self.tile(160, 0, 160, 100)
snapped = ways.snap_position(target, "T", occupied, radius=12)
self.assertFalse(ways._overlaps(snapped, occupied["T"]))
self.assertFalse(ways._overlaps(snapped, occupied[A]))
settings = self.settings(A, B)
layout = self.picture(settings, A, self.tile(300, 0, 160, 100), B, self.tile(300, 0, 160, 100))
result = ways.compile_layout(settings, layout, moved=B, now=10)
self.assertFalse(result["accepted"])
self.assertEqual(set(result["snap"]), {B})
self.assertEqual(result["snap"][B], ways.snap_position(layout[B], settings["machine_id"],
{k: v for k, v in layout.items() if k != B}))
self.assertFalse(ways._overlaps(result["snap"][B], layout[settings["machine_id"]]))
self.assertFalse(ways._overlaps(result["snap"][B], layout[A]))
self.assertEqual(result["tiles"][B]["state"], "overlap")
def test_snap_near_each_side_centre_uses_the_centred_position(self):
own = self.tile(0, 0, 160, 100)
layout = {"T": own}
positions = {"left": (-80, 30), "right": (160, 30),
"top": (40, -40), "bottom": (40, 100)}
for side, (x, y) in positions.items():
with self.subTest(side=side):
dropped = self.tile(x+3, y-3, 80, 40)
self.assertEqual(ways.snap_position(dropped, "T", layout, radius=4),
self.tile(x, y, 80, 40))
def test_snap_supports_both_flush_alignments_on_each_side(self):
own = self.tile(0, 0, 160, 100)
layout = {"T": own}
positions = ((160, 0), (160, 60), (-80, 0), (-80, 60),
(0, -40), (80, -40), (0, 100), (80, 100))
for x, y in positions:
with self.subTest(position=(x, y)):
dropped = self.tile(x+3, y+3, 80, 40)
self.assertEqual(ways.snap_position(dropped, "T", layout, radius=6),
self.tile(x, y, 80, 40))
def test_snap_keeps_existing_third_marks(self):
own = self.tile(0, 0, 160, 100)
layout = {"T": own}
expected = self.tile(160, 13, 80, 40)
dropped = self.tile(162, 14, 80, 40)
self.assertEqual(ways.snap_position(dropped, "T", layout), expected)
def test_snap_prefers_centred_candidate_when_a_third_mark_is_equally_near(self):
own = self.tile(0, 0, 160, 120)
layout = {"T": own}
dropped = self.tile(160, 30, 160, 80)
self.assertEqual(ways.snap_position(dropped, "T", layout), self.tile(160, 20, 160, 80))
def test_centred_snap_radius_is_larger_than_other_candidates(self):
own = self.tile(0, 0, 160, 100)
layout = {"T": own}
dropped = self.tile(160, 38, 80, 40)
self.assertTrue(ways.within_snap_radius(dropped, self.tile(160, 30, 80, 40), "T", layout, 6))
self.assertFalse(ways.within_snap_radius(dropped, self.tile(160, 13, 80, 40), "T", layout, 6))
def test_snap_uses_nearest_free_candidate_when_centre_is_occupied(self):
own = self.tile(0, 0, 160, 100)
centred = self.tile(160, 40, 80, 20)
layout = {"T": own, A: centred}
dropped = dict(centred)
snapped = ways.snap_position(dropped, "T", layout, radius=12)
self.assertNotEqual(snapped, centred)
self.assertFalse(ways._overlaps(snapped, own))
self.assertFalse(ways._overlaps(snapped, layout[A]))
self.assertEqual(snapped, ways.snap_position(dropped, "T", layout, radius=math.inf))
def test_overlap_marks_only_the_involved_tiles_and_keeps_other_contacts(self):
settings = self.settings(A, B, C)
layout = self.picture(settings, A, self.tile(160, 0, 160, 100),
B, self.tile(400, 0, 160, 100), C, self.tile(400, 0, 160, 100))
result = ways.compile_layout(settings, layout, capable={A, B, C}, now=10)
self.assertTrue(result["accepted"])
self.assertEqual(result["tiles"][A]["state"], "edge")
for peer, other in ((B, C), (C, B)):
self.assertEqual(result["tiles"][peer]["state"], "overlap")
self.assertEqual(result["tiles"][peer]["overlap_with"], other)
self.assertEqual(result["tiles"][peer]["sentence_keys"], ["overlap"])
def test_overlapping_tiles_keep_intent_but_generate_no_zones(self):
settings = self.settings(A, B)
for peer in (A, B):
next(entry for entry in settings["peers"] if entry["id"] == peer)["side"] = "left"
settings["zones"] = [{"peer": A, "kind": "edge"}, {"peer": B, "kind": "edge", "off": True}]
layout = self.picture(settings, A, self.tile(-160, 0, 160, 100), B, self.tile(-160, 50, 160, 100))
result = ways.compile_layout(settings, layout, now=10)
self.assertEqual(result["tiles"][A]["state"], "overlap")
self.assertEqual(result["tiles"][B]["state"], "overlap")
self.assertEqual(ways.ways(result["settings"], A)["methods"], ["edge"])
self.assertEqual(ways.ways(result["settings"], B)["methods"], [])
self.assertEqual(result["settings"]["zones"], [])
def test_rc7_shape_keeps_pc_crossing_and_names_the_overlapping_pair(self):
own, pc, laptop, fedora = "own", "pc", "laptop", "fedora"
settings = {"machine_id": own, "peers": [
{"id": pc, "port": 24820, "side": "right", "name": "Studio PC"},
{"id": laptop, "port": 24820, "side": "top", "name": "Laptop"},
{"id": fedora, "port": 24820, "side": "", "name": "Test box"},
], "zones": [], "layout": {}}
settings["peers"][0]["paired_with"] = [fedora]
layout = {own: self.tile(332, 0, 160, 100), pc: self.tile(172, 17, 160, 100),
laptop: self.tile(359, -100, 160, 100), fedora: self.tile(359, -100, 160, 100)}
result = ways.compile_layout(settings, layout, capable={own, pc, laptop, fedora}, now=10)
self.assertTrue(result["accepted"])
self.assertEqual(result["tiles"][pc]["state"], "part")
self.assertTrue(ways.has_way(result["settings"], pc))
self.assertEqual(result["tiles"][laptop]["state"], "overlap")
self.assertEqual(result["tiles"][laptop]["overlap_with"], fedora)
self.assertEqual(result["layout"].keys(), {own, pc, laptop, fedora})
def test_missing_own_tile_is_placed_before_compiling_contacts(self):
settings = self.settings(A)
own = settings["machine_id"]
result = ways.compile_layout(settings, {A: self.tile(160, 0, 160, 100)}, now=10)
self.assertTrue(result["accepted"])
self.assertEqual(result["layout"][own], self.tile(0, 0, 160, 100))
self.assertEqual(result["tiles"][A]["state"], "edge")
def test_compiling_active_peers_preserves_shelved_peer_intent_without_zones(self):
settings = self.settings(A, B)
next(peer for peer in settings["peers"] if peer["id"] == B)["left_out"] = True
remembered = {"peer": B, "kind": "part", "parts": ["start"]}
settings["zones"] = [dict(remembered)]
result = ways.compile_layout(settings, self.picture(settings, A, self.tile(160, 0, 160, 100)), now=10)
self.assertTrue(result["accepted"])
self.assertFalse(any(zone["peer"] == B for zone in result["settings"]["zones"]))
self.assertEqual(ways.ways(result["settings"], B)["parts"], ["start"])
def test_derive_matches_legacy_mac_placement_examples(self):
arrangements = [
[("right", None)], [("left", None), ("right", None)],
[("right", 2), ("right", 0)], [("right", None), ("top", None)],
]
recorded = [
((179.0, 142.5, 120.0, 75.0), [(309.0, 148.5, 112.0, 63.0)]),
((240.0, 142.5, 120.0, 75.0), [(118.0, 148.5, 112.0, 63.0), (370.0, 148.5, 112.0, 63.0)]),
((207.0, 142.5, 120.0, 75.0), [(337.0, 183.0, 56.0, 31.5), (337.0, 145.5, 56.0, 31.5)]),
((179.0, 179.0, 120.0, 75.0), [(309.0, 185.0, 112.0, 63.0), (183.0, 106.0, 112.0, 63.0)]),
]
from mac_app import pages
self.assertIs(pages.diagram_layout, ways.diagram_layout)
for machines in arrangements:
with self.subTest(machines=machines):
index = arrangements.index(machines)
self.assertEqual(ways.diagram_layout(600, 360, machines), recorded[index])
self.assertEqual(pages.diagram_layout(600, 360, machines), recorded[index])
def test_saved_peer_tiles_are_authoritative_when_deriving_layout(self):
settings = self.settings(A, B)
settings["peers"][0]["paired_with"] = [C]
settings["peers"][0]["side"] = "right"
settings["layout"] = {settings["machine_id"]: self.tile(0, 0, 160, 100),
A: self.tile(172, 0, 160, 100),
B: self.tile(-172, 40, 160, 100),
C: {**self.tile(400, 0, 160, 100), "name": "Test box"}}
layout = ways.derive_layout(settings)
self.assertEqual(layout[A], settings["layout"][A])
self.assertEqual(layout[B], settings["layout"][B])
self.assertEqual(layout[C], settings["layout"][C])
def test_missing_peer_avoids_saved_tiles_and_keeps_saved_metadata(self):
settings = self.settings(A, B)
own = settings["machine_id"]
saved = {**self.tile(0, 100, 160, 100), "name": "Saved Mac",
"displays": {"main": {"x": 0, "y": 0, "w": 160, "h": 100}},
"display_offsets": {"main": {"x": 10, "y": 0}}}
settings["peers"][0]["side"] = "bottom"
settings["layout"] = {own: self.tile(0, 0, 160, 100), A: saved}
layout = ways.derive_layout(settings, gap=0)
self.assertEqual(layout[A], {**self.tile(0, 100, 160, 100), "displays": saved["displays"],
"display_offsets": saved["display_offsets"], "name": "Saved Mac"})
self.assertFalse(ways._overlaps(layout[B], layout[own]))
self.assertFalse(ways._overlaps(layout[B], layout[A]))
self.assertIsNotNone(ways._rect_contact(layout[own], layout[B]))
def test_a_shelved_peers_kept_tile_never_blocks_an_active_peers_side(self):
settings = self.settings(A, B)
own = settings["machine_id"]
settings["peers"][0].update(side="right", left_out=True)
settings["peers"][1]["side"] = "right"
settings["layout"] = {own: self.tile(0, 0, 160, 100), A: self.tile(160, 0, 160, 100)}
layout = ways.derive_layout(settings, gap=0)
self.assertEqual(layout[B], self.tile(160, 0, 160, 100))
self.assertEqual(layout[A], self.tile(160, 0, 160, 100))
def test_rc13_right_peer_fills_free_snap_beside_saved_left_peer(self):
settings = self.settings(A, B)
own = settings["machine_id"]
settings["peers"][0]["side"] = "left"
settings["peers"][1]["side"] = "right"
settings["layout"] = {own: self.tile(-500, 149, 160, 100),
A: self.tile(-660, 149, 160, 100)}
layout = ways.derive_layout(settings, gap=0)
self.assertEqual(layout[B], self.tile(-340, 149, 160, 100))
self.assertEqual(layout[A], settings["layout"][A])
def test_layout_keeps_only_named_third_parties_listed_by_active_desktops(self):
settings = self.settings(A, B)
settings["peers"][0]["paired_with"] = [C, D]
settings["layout"].update({
A: self.tile(160, 0, 160, 100),
B: self.tile(320, 0, 160, 100),
C: {**self.tile(480, 0, 160, 100), "name": "Test box"},
D: self.tile(640, 0, 160, 100),
})
layout = ways.derive_layout(settings)
self.assertEqual(set(layout), {settings["machine_id"], A, B, C})
self.assertEqual(layout[C]["name"], "Test box")
def test_rc7_ghost_tiles_are_pruned_and_not_derived_or_fabricated(self):
own, pc, laptop, phone, box, old_pc = "M", "PC", "LAPTOP", "PHONE", "BOX", "OLDPC"
settings = {"machine_id": own, "peers": [
{"id": pc, "port": 24820, "left_out": True, "paired_with": [phone, box]},
{"id": laptop, "port": 24820, "paired_with": [old_pc]},
], "zones": [], "layout": {
own: self.tile(0, 0, 160, 100), pc: {**self.tile(172, 0, 160, 100), "vouched_by": laptop},
laptop: self.tile(344, 0, 160, 100),
phone: {**self.tile(516, 0, 160, 100), "vouched_by": pc},
box: {**self.tile(688, 0, 160, 100), "vouched_by": pc},
old_pc: {**self.tile(860, 0, 160, 100), "vouched_by": laptop},
}, "layout_set_at": 5, "layout_by": "before"}
self.assertTrue(ways.prune_layout(settings, now=10))
self.assertTrue({phone, box, old_pc}.isdisjoint(settings["layout"]))
self.assertNotIn("vouched_by", settings["layout"][pc])
self.assertFalse({phone, box, old_pc} & set(ways.derive_layout(settings)))
incoming = {own: self.tile(0, 0, 160, 100), pc: self.tile(172, 0, 160, 100)}
retained = ways.retain_held_peer_tiles(settings, incoming, settings["layout"])
self.assertTrue({phone, box, old_pc}.isdisjoint(retained))
received = {**incoming, **{ghost: self.tile(900, 0, 160, 100) for ghost in (phone, box, old_pc)}}
retained = ways.retain_held_peer_tiles(settings, incoming, settings["layout"], received)
self.assertEqual(set(retained), {own, pc, laptop})
def test_named_third_party_tile_requires_a_live_non_shelved_peer(self):
own, pc, box = "M", "PC", "BOX"
settings = {"machine_id": own, "peers": [
{"id": pc, "port": 24820, "paired_with": [box]},
], "zones": [], "layout": {
own: self.tile(0, 0, 160, 100), pc: self.tile(172, 0, 160, 100),
box: {**self.tile(344, 0, 160, 100), "name": "Test box"},
}}
self.assertIn(box, ways.derive_layout(settings))
settings["peers"][0]["paired_with"] = []
self.assertNotIn(box, ways.derive_layout(settings))
settings["peers"][0]["paired_with"] = [box]
settings["peers"][0]["in_use"] = False
self.assertNotIn(box, ways.derive_layout(settings))
settings["peers"][0]["in_use"] = True
settings["peers"][0]["dormant"] = True
self.assertNotIn(box, ways.derive_layout(settings))
settings["peers"][0]["dormant"] = False
settings["peers"][0]["left_out"] = True
self.assertNotIn(box, ways.derive_layout(settings))
def test_pruning_strips_vouch_metadata_without_restamping(self):
settings = self.settings(A)
own = settings["machine_id"]
settings["layout"][own]["vouched_by"] = A
settings["layout_set_at"] = 5
self.assertTrue(ways.prune_layout(settings, now=10))
self.assertNotIn("vouched_by", settings["layout"][own])
self.assertEqual(settings["layout_set_at"], 5)
self.assertNotIn("layout_by", settings)
def test_compile_layout_drops_an_unvouched_stale_tile_before_contact_checks(self):
settings = self.settings(A)
layout = self.picture(settings, A, self.tile(160, 0, 160, 100),
D, self.tile(160, 0, 160, 100))
result = ways.compile_layout(settings, layout, now=10)
self.assertTrue(result["accepted"])
self.assertNotIn(D, result["tiles"])
self.assertNotIn(D, result["settings"]["layout"])
def test_pruning_stamps_the_cleaned_shared_picture(self):
settings = self.settings(A)
own = settings["machine_id"]
settings["peers"][0]["paired_with"] = [C]
settings["layout"] = {own: self.tile(0, 0, 160, 100),
A: self.tile(160, 0, 160, 100),
C: {**self.tile(320, 0, 160, 100), "name": "Test box"},
D: self.tile(480, 0, 160, 100)}
settings["layout_set_at"] = 5
self.assertTrue(ways.prune_layout(settings, now=10))
self.assertEqual(set(settings["layout"]), {own, A, C})
self.assertGreater(settings["layout_set_at"], 5)
self.assertEqual(settings["layout_by"], own)
def test_named_third_party_tile_survives_while_its_direct_peer_lists_it(self):
own, pc, laptop, box = "BQUFBQUFBQUFBQUFBQUFBQ", "BgYGBgYGBgYGBgYGBgYGBg", \
"CAgICAgICAgICAgICAgICA", "BwcHBwcHBwcHBwcHBwcHBw"
settings = {"machine_id": own, "peers": [
{"id": pc, "port": 24820, "paired_with": [box]},
], "layout_set_at": 5, "layout": {
own: self.tile(0, 0, 160, 100), pc: self.tile(172, 0, 160, 100),
box: {**self.tile(344, 0, 160, 100), "name": "Test box"},
laptop: {**self.tile(516, 0, 160, 100), "name": "Laptop"},
}}
ways.prune_layout(settings, now=10)
self.assertEqual(set(settings["layout"]), {own, pc, box})
def test_named_third_party_is_dropped_when_its_peer_no_longer_lists_it(self):
own, mac, laptop, fedora = "BgYGBgYGBgYGBgYGBgYGBg", "BQUFBQUFBQUFBQUFBQUFBQ", \
"CAgICAgICAgICAgICAgICA", "BwcHBwcHBwcHBwcHBwcHBw"
settings = {"machine_id": own, "peers": [
{"id": mac, "port": 24820, "paired_with": [laptop]},
{"id": fedora, "port": 24820, "paired_with": [mac]},
], "layout": {ident: self.tile(index * 172, 0, 160, 100)
for index, ident in enumerate((own, mac, fedora, laptop))}}
settings["layout"][laptop]["name"] = "Laptop"
ways.prune_layout(settings, now=10)
self.assertIn(laptop, settings["layout"])
settings["peers"][0]["paired_with"] = []
ways.prune_layout(settings, now=11)
self.assertNotIn(laptop, settings["layout"])
def test_received_layout_restores_missing_locally_held_peer_tiles(self):
own, pc, fedora = "BQUFBQUFBQUFBQUFBQUFBQ", "BgYGBgYGBgYGBgYGBgYGBg", "BwcHBwcHBwcHBwcHBwcHBw"
settings = {"machine_id": own, "peers": [
{"id": pc, "port": 24820, "side": "right", "paired_with": [fedora]},
], "zones": [], "layout": {
own: self.tile(0, 0, 160, 100), pc: self.tile(172, 0, 160, 100),
fedora: {**self.tile(344, 0, 160, 100), "name": "Test box"},
}}
incoming = {own: self.tile(0, 0, 160, 100), pc: self.tile(172, 0, 160, 100)}
merged = ways.retain_held_peer_tiles(settings, incoming, settings["layout"])
self.assertEqual(merged[fedora], settings["layout"][fedora])
def test_received_layout_places_a_missing_held_peer_by_its_default_side(self):
own, peer = self.ident(50), self.ident(1)
settings = {"machine_id": own, "peers": [
{"id": peer, "port": 24820, "side": "right", "paired_with": []},
], "zones": [], "layout": {own: self.tile(0, 0, 160, 100)}}
merged = ways.retain_held_peer_tiles(settings, {own: self.tile(0, 0, 160, 100)}, settings["layout"])
# Flush, so it touches and keeps crossing; a 12 gap left it with no contact and no side.
self.assertEqual(merged[peer], self.tile(160, 0, 160, 100))
def test_received_layout_keeps_a_present_shelved_peer_tile_exactly(self):
own, peer, shelf = self.ident(50), self.ident(1), self.ident(2)
received = {shelf: {**self.tile(160, 0, 160, 100), "name": "Shelf"}}
settings = {"machine_id": own, "peers": [
{"id": peer, "port": 24820, "side": "right", "paired_with": []},
{"id": shelf, "port": 24820, "side": "right", "left_out": True, "paired_with": []},
], "zones": [], "layout": {
own: self.tile(0, 0, 160, 100), peer: self.tile(172, 0, 160, 100),
shelf: self.tile(344, 0, 160, 100),
}}
merged = ways.retain_held_peer_tiles(
settings, {own: self.tile(0, 0, 160, 100), peer: self.tile(160, 0, 160, 100)},
settings["layout"], received)
self.assertEqual(merged[shelf], received[shelf])
def test_rc7_shared_picture_keeps_only_named_thirds_in_the_current_paired_list(self):
own, peer, third = "M", "PC", "BOX"
settings = {"machine_id": own, "peers": [
{"id": peer, "port": 24820, "side": "left", "paired_with": [third]},
], "zones": [], "layout": {own: self.tile(0, 0, 100, 100)}}
layout = {own: self.tile(0, 0, 100, 100), peer: self.tile(112, 0, 100, 100),
third: {**self.tile(224, 0, 100, 100), "name": "Test box"}}
result = ways.compile_layout(settings, layout, capable={own, peer, third}, now=10)
self.assertTrue(result["accepted"])
self.assertIn(third, result["layout"])
self.assertNotIn("vouched_by", result["layout"][third])
result["settings"]["peers"][0]["paired_with"] = []
ways.prune_layout(result["settings"], now=11)
self.assertNotIn(third, result["settings"]["layout"])
def test_arrangement_inverse_repositions_peer_from_new_side(self):
settings = self.settings(A)
layout = self.picture(settings, A, self.tile(160, 0, 160, 33))
settings = ways.compile_layout(settings, layout, now=10)["settings"]
settings["layout"][settings["machine_id"]]["x"] = 500
changed = ways.arrangement(settings, A, "left", 20, self.ident(8), "this PC")
self.assertTrue(changed[0])
updated = settings["layout"]
self.assertEqual(updated[A]["x"], 660)
self.assertIsNotNone(ways._rect_contact(updated[settings["machine_id"]], updated[A]))
def test_inverse_repositions_all_peers_on_old_and_new_sides_without_overlap(self):
settings = self.settings(A, B, C)
settings["peers"][0]["side"] = "right"
settings["peers"][1]["side"] = "right"
settings["peers"][2]["side"] = "top"
layout = self.picture(settings, A, self.tile(172, 0, 160, 100), B, self.tile(172, 112, 160, 100),
C, self.tile(0, -112, 160, 100))
settings["layout"] = layout
settings["peers"][0]["side"] = "left"
updated = ways.inverse_layout(settings, layout, peer=A)
for one, tile in updated.items():
for two, other in updated.items():
if one < two:
self.assertFalse(ways._overlaps(tile, other), (one, two, tile, other))
self.assertEqual(updated[B], layout[B])
self.assertEqual(updated[C], layout[C])
def test_set_elsewhere_only_when_a_peer_lacks_layout_capability(self):
settings = self.settings(A, B)
layout = self.picture(settings, A, self.tile(320, 0, 160, 100), B, self.tile(480, 0, 160, 100))
result = ways.compile_layout(settings, layout, capable={A, B}, now=10)
self.assertEqual(result["tiles"][A]["state"], "between")
self.assertEqual(result["tiles"][B]["state"], "between")
self.assertEqual(result["tiles"][A]["sentence_keys"], ["between"])
self.assertEqual(ways.ATLAS_SENTENCES["between"], "Crosses between {first} and {second}.")
self.assertEqual(ways.ATLAS_SENTENCES["set_elsewhere"], "Set on {first} or {second}.")
def test_single_tile_model_has_no_second_contact_sentence(self):
self.assertNotIn("second_contact", ways.ATLAS_SENTENCES)
def test_compiled_layout_stamp_round_trips_as_base64_by(self):
settings = self.settings(A)
layout = self.picture(settings, A, self.tile(160, 0, 160, 100))
result = ways.compile_layout(settings, layout, moved=A, now=10)
self.assertEqual(result["settings"]["layout_by"], result["settings"]["machine_id"])
state = {"set_at": result["settings"]["layout_set_at"],
"by": result["settings"]["layout_by"], "tiles": result["settings"]["layout"]}
data = settings_sync.message_data(False, 5, by=self.ident(2), layout_state=state)
self.assertEqual(settings_sync.read_layout_state(data, now=10), state)
def test_layout_settings_sync_newest_clock_relay_and_capability(self):
state = {"set_at": 10, "by": self.ident(1), "tiles": {A: self.tile(1, 2, 160, 100)}}
data = settings_sync.message_data(False, 5, by=self.ident(2), layout_state=state)
self.assertEqual(settings_sync.read_layout_state(data, now=10)["set_at"], 10)
self.assertIsNone(settings_sync.read_layout_state(data, now=10 - settings_sync.DAY - 1))
self.assertTrue(settings_sync.layout_arrived(state, 9, self.ident(2)))
self.assertFalse(settings_sync.layout_arrived(state, 10, self.ident(2)))
same_time_later_author = dict(state, by=self.ident(3))
self.assertTrue(settings_sync.layout_arrived(same_time_later_author, 10, self.ident(2)))
self.assertEqual(settings_sync.layout_recipients({A: {"settings", "layout"}, B: {"settings"}}), [A])
self.assertNotIn("layout", settings_sync.for_capabilities(data, {"settings"}))
self.assertIn("layout", settings_sync.for_capabilities(data, {"settings", "layout"}))
def test_layout_state_carries_validated_display_rectangles(self):
displays = {"panel-left": {"x": -1280, "y": 0, "w": 1280, "h": 800},
"panel-right": {"x": 0, "y": 0, "w": 1920, "h": 1080}}
tiles = {A: dict(self.tile(0, 0, 160, 100), displays=displays)}
state = {"set_at": 10, "by": self.ident(1), "tiles": tiles}
data = settings_sync.message_data(False, 5, by=self.ident(2), layout_state=state)
self.assertEqual(settings_sync.read_layout_state(data, now=10)["tiles"][A]["displays"], displays)
malformed_tiles = {A: dict(self.tile(0, 0, 160, 100),
displays={"panel-left": {"x": -1280, "y": 0, "w": 0, "h": 800}})}
malformed = dict(state, tiles=malformed_tiles)
self.assertIsNone(settings_sync.read_layout_state(
settings_sync.message_data(False, 5, by=self.ident(2), layout_state=malformed), now=10))
newer = settings_sync.for_capabilities(data, {"settings", "layout", "displays"})
older = settings_sync.for_capabilities(data, {"settings", "layout"})
self.assertIn("displays", newer["layout"]["tiles"][A])
self.assertNotIn("displays", older["layout"]["tiles"][A])
def test_layout_state_carries_the_machine_name_for_third_party_tiles(self):
settings = self.settings(A)
tiles = self.picture(settings, A, {**self.tile(160, 0, 160, 100), "name": "Test box"})
data = settings_sync.message_data(False, 5, by=self.ident(2),
layout_state={"set_at": 5, "by": self.ident(2), "tiles": tiles})
parsed = settings_sync.read_layout_state(data, now=10)
self.assertEqual(parsed["tiles"][A]["name"], "Test box")
def test_blank_optional_tile_name_is_dropped_without_rejecting_other_tiles(self):
tiles = {A: {**self.tile(0, 0, 160, 100), "name": " "},
B: self.tile(160, 0, 160, 100)}
data = settings_sync.message_data(False, 5, by=self.ident(2),
layout_state={"set_at": 5, "by": self.ident(2), "tiles": tiles})
parsed = settings_sync.read_layout_state(data, now=10)
self.assertEqual(set(parsed["tiles"]), {A, B})
self.assertNotIn("name", parsed["tiles"][A])
def test_a_peer_between_two_displays_compiles_two_local_edges(self):
settings = self.settings(A)
layout = {
settings["machine_id"]: {
"x": 0, "y": 0, "w": 300, "h": 100,
"displays": {
"panel-left": {"x": 0, "y": 0, "w": 100, "h": 100},
"panel-right": {"x": 200, "y": 0, "w": 100, "h": 100},
},
},
A: self.tile(100, 0, 100, 100),
}
result = ways.compile_layout(settings, layout, now=10)
zones = [zone for zone in result["settings"]["zones"] if zone["peer"] == A and zone["kind"] == "edge"]
self.assertEqual([(zone["display"], zone["side"]) for zone in zones],
[("panel-left", "right"), ("panel-right", "left")])
self.assertEqual(result["settings"]["peers"][0]["side"], "right")
def test_rc6_saved_display_layout_keeps_the_mac_and_pc_edge_and_the_laptop_edge(self):
own, pc, laptop, fedora = "BQUFBQUFBQUFBQUFBQUFBQ", "BgYGBgYGBgYGBgYGBgYGBg", \
"CAgICAgICAgICAgICAgICA", "BwcHBwcHBwcHBwcHBwcHBw"
settings = {"machine_id": own, "peers": [
{"id": pc, "port": 24820, "side": "left", "name": "Studio PC"},
{"id": laptop, "port": 24820, "side": "bottom", "name": "Laptop"},
], "zones": [
{"peer": pc, "kind": "edge", "display": "0", "side": "left", "target_side": "right", "off": True},
{"peer": pc, "kind": "part", "parts": ["middle", "end"], "display": "0", "side": "left", "target_side": "right"},
{"peer": laptop, "kind": "edge", "display": "0", "side": "bottom", "target_side": "top", "off": True},
{"peer": laptop, "kind": "part", "parts": ["middle", "end"], "display": "0", "side": "bottom", "target_side": "top"},
]}
settings["peers"][0]["paired_with"] = [fedora]
layout = {
own: {"x": 332, "y": 0, "w": 160, "h": 100,
"displays": {"0": {"x": 0, "y": 0, "w": 1728, "h": 1117}}},
pc: self.tile(172, 17, 160, 100),
laptop: self.tile(359, 100, 160, 100),
fedora: {**self.tile(359, -100, 160, 100), "name": "Test box"},
}
result = ways.compile_layout(settings, layout, capable={own, pc, laptop, fedora}, now=10)
self.assertTrue(result["accepted"])
self.assertIn(result["tiles"][pc]["state"], ("edge", "part"))
self.assertIn(result["tiles"][laptop]["state"], ("edge", "part"))
self.assertTrue(ways.has_way(result["settings"], pc))
self.assertTrue(ways.has_way(result["settings"], laptop))
self.assertEqual(result["layout"][fedora]["name"], "Test box")
def test_shared_picture_accepts_named_third_party_in_current_paired_list(self):
own, peer, third = "BQUFBQUFBQUFBQUFBQUFBQ", "BgYGBgYGBgYGBgYGBgYGBg", "BwcHBwcHBwcHBwcHBwcHBw"
settings = {"machine_id": own, "peers": [{"id": peer, "port": 24820, "side": "left",
"paired_with": [third]}], "zones": []}
layout = {
own: self.tile(0, 0, 100, 100),
peer: self.tile(112, 0, 100, 100),
third: {**self.tile(224, 0, 100, 100), "name": "Test box"},
}
result = ways.compile_layout(settings, layout, capable={own, peer, third}, now=10)
self.assertTrue(result["accepted"])
self.assertIn(third, result["layout"])
self.assertNotIn("vouched_by", result["layout"][third])
saved = result["settings"]
saved["layout"] = result["layout"]
self.assertIn(third, ways.derive_layout(saved))
saved["peers"] = []
ways.prune_layout(saved, now=11)
self.assertNotIn(third, saved["layout"])
def test_new_layout_peers_are_placed_touching_the_local_machine(self):
settings = self.settings(A)
settings["peers"][0]["side"] = ""
layout = ways.derive_layout(settings)
self.assertIsNotNone(ways._rect_contact(layout[settings["machine_id"]], layout[A]))
def test_reporting_a_display_change_updates_the_shared_layout_stamp_once(self):
settings = self.settings(A)
settings["layout"] = {settings["machine_id"]: self.tile(0, 0, 160, 100),
A: self.tile(172, 0, 160, 100)}
displays = {"0": ways.return_edge.Rect(-100, 0, 100, 100),
"1": ways.return_edge.Rect(0, 0, 200, 100)}
self.assertTrue(ways.refresh_displays(settings, displays, now=10))
self.assertEqual(settings["layout"][settings["machine_id"]]["displays"],
{key: {"x": rect.x, "y": rect.y, "w": rect.width, "h": rect.height}
for key, rect in displays.items()})
stamp = settings["layout_set_at"]
self.assertFalse(ways.refresh_displays(settings, displays, now=11))
self.assertEqual(settings["layout_set_at"], stamp)
def test_split_display_offsets_move_one_panel_without_changing_its_reported_geometry(self):
tile = {
"x": 10, "y": 20, "w": 300, "h": 100,
"displays": {
"left": {"x": 0, "y": 0, "w": 100, "h": 100},
"right": {"x": 100, "y": 0, "w": 200, "h": 100},
},
"display_offsets": {"right": {"x": 25, "y": -10}},
}
frames = {frame["display"]: frame for frame in ways._display_frames(tile)}
self.assertEqual((frames["left"]["x"], frames["left"]["y"]), (10, 20))
self.assertEqual((frames["right"]["x"], frames["right"]["y"]), (135, 10))
self.assertEqual(tile["displays"]["right"], {"x": 100, "y": 0, "w": 200, "h": 100})
def test_display_offsets_must_name_reported_displays_and_use_integer_offsets(self):
valid = {"x": 0, "y": 0, "w": 300, "h": 100,
"displays": {"left": {"x": 0, "y": 0, "w": 100, "h": 100}},
"display_offsets": {"left": {"x": 1, "y": -2}}}
self.assertTrue(ways._valid_tile_displays(valid))
for offsets in ({"missing": {"x": 0, "y": 0}}, {"left": {"x": 0, "y": 0.5}}, []):
self.assertFalse(ways._valid_tile_displays(dict(valid, display_offsets=offsets)))
def test_design_sync_remains_optional_without_a_capability_gate(self):
design = {"set_at": 10, "by": self.ident(1), "values": {"effect_length": "long"}}
data = settings_sync.message_data(False, 5, design_state=design)
filtered = settings_sync.for_capabilities(data, {"settings"})
self.assertEqual(filtered["design_sync"], design)
def test_layout_receiver_compiles_its_own_zones(self):
settings = self.settings(A)
tiles = self.picture(settings, A, self.tile(160, 0, 160, 100))
received = {"set_at": 10, "by": self.ident(2), "tiles": tiles}
data = settings_sync.message_data(False, 5, by=self.ident(2), layout_state=received)
parsed = settings_sync.read_layout_state(data, now=10)
self.assertEqual(parsed["tiles"], tiles)
result = ways.compile_layout(settings, parsed["tiles"], now=10)
self.assertTrue(result["accepted"])
self.assertEqual(ways.ways(result["settings"], A)["methods"], ["edge"])
def test_layout_receiver_preserves_split_display_offsets(self):
settings = self.settings(A)
tiles = self.picture(settings, A, self.tile(160, 0, 300, 100))
tiles[A]["displays"] = {"left": {"x": 0, "y": 0, "w": 100, "h": 100},
"right": {"x": 100, "y": 0, "w": 200, "h": 100}}
tiles[A]["display_offsets"] = {"right": {"x": 24, "y": -8}}
data = settings_sync.message_data(False, 5, layout_state={"set_at": 10, "by": self.ident(2), "tiles": tiles})
parsed = settings_sync.read_layout_state(data, now=10)
self.assertEqual(parsed["tiles"][A]["display_offsets"], tiles[A]["display_offsets"])
old_peer = settings_sync.for_capabilities(data, {"settings", "layout"})
self.assertNotIn("display_offsets", old_peer["layout"]["tiles"][A])
malformed = copy.deepcopy(data)
malformed["layout"]["tiles"][A]["display_offsets"]["ghost"] = {"x": 0, "y": 0}
self.assertIsNone(settings_sync.read_layout_state(malformed, now=10))
@staticmethod
def tile(x, y, w, h):
return {"x": x, "y": y, "w": w, "h": h}
@staticmethod
def ident(n):
import base64
return base64.urlsafe_b64encode(bytes([n]) * 16).decode().rstrip("=")
def settings(self, *peers):
own = self.ident(50)
entries = [{"id": peer, "side": "", "side_set_at": 0, "side_by": "", "port": 24820,
"name": peer, "in_use": True} for peer in peers]
return {"machine_id": own, "peers": entries, "zones": [], "layout": {own: self.tile(0, 0, 160, 100)}}
def picture(self, settings, *items):
layout = dict(settings["layout"])
layout.update({items[i]: items[i + 1] for i in range(0, len(items), 2)})
return layout
A = settings_id = "AQEBAQEBAQEBAQEBAQEBAQ"
B = "AgICAgICAgICAgICAgICAg"
C = "AwMDAwMDAwMDAwMDAwMDAw"
D = "BAQEBAQEBAQEBAQEBAQEBA"
if __name__ == "__main__":
unittest.main()
class CrossingStretchTests(unittest.TestCase):
own = {"x": 0, "y": 0, "w": 160, "h": 90}
def test_whole_edge_and_no_thirds_light_the_whole_contact(self):
contact = ("right", 0, 90)
self.assertEqual(ways.crossing_stretches(contact, self.own, []), [contact])
self.assertEqual(ways.crossing_stretches(contact, self.own, ["start", "middle", "end"]), [contact])
def test_only_the_picked_thirds_light(self):
self.assertEqual(ways.crossing_stretches(("right", 0, 90), self.own, ["start"]), [("right", 0, 30)])
self.assertEqual(ways.crossing_stretches(("bottom", 0, 160), self.own, ["start", "end"]),
[("bottom", 0, 160 / 3), ("bottom", 320 / 3, 160)])
def test_a_third_outside_the_contact_lights_nothing(self):
self.assertEqual(ways.crossing_stretches(("right", 0, 30), self.own, ["end"]), [])
def test_a_corner_is_untouched(self):
contact = ("corner", "top_right", None)
self.assertEqual(ways.crossing_stretches(contact, self.own, ["start"]), [contact])