| """The webOS: window manager, apps, filesystem wiring, and the memory map. |
| |
| Each test either reads a desktop that nothing mutates (built once per class) or |
| builds its own, because the window manager is stateful and a shared desktop would |
| make the tests order-dependent. ``d=2000`` throughout: it is the codec floor, and |
| the desktop renders a full 80x30 shader frame per call. |
| """ |
|
|
| import unittest |
|
|
| from hdc.gfx import SHADERS |
| from hdc.os import APPS, COLS, ROWS, Desktop, MemoryMap, boot, tour |
|
|
|
|
| class ReadOnlyDesktop(unittest.TestCase): |
| """A started desktop shared by the tests that never mutate it.""" |
|
|
| @classmethod |
| def setUpClass(cls): |
| cls.desktop = Desktop(d=2000).start() |
|
|
| def test_start_opens_the_tiled_session(self): |
| desktop = Desktop(d=2000).start() |
| self.assertEqual([w.app for w in desktop.windows], |
| ["terminal", "monitor", "files"]) |
| self.assertEqual(desktop.windows[desktop.focus].app, "terminal") |
|
|
| def test_start_is_idempotent(self): |
| desktop = Desktop(d=2000) |
| desktop.start() |
| before = len(desktop.windows) |
| desktop.start() |
| self.assertEqual(len(desktop.windows), before) |
|
|
| def test_launching_an_open_app_raises_it_instead_of_duplicating(self): |
| desktop = Desktop(d=2000).start() |
| desktop.launch("files") |
| desktop.launch("files") |
| self.assertEqual(sum(1 for w in desktop.windows if w.app == "files"), 1) |
| self.assertEqual(desktop.windows[desktop.focus].app, "files") |
|
|
| def test_close_removes_the_focused_window(self): |
| |
| |
| desktop = Desktop(d=2000).start() |
| before = len(desktop.windows) |
| focused = desktop.focused() |
| self.assertTrue(desktop.close()) |
| self.assertEqual(len(desktop.windows), before - 1) |
| self.assertNotIn(focused, desktop.windows) |
|
|
| def test_frame_has_the_grid_shape_and_a_menu_bar(self): |
| frame = self.desktop.frame() |
| self.assertEqual(len(frame), ROWS) |
| for row in frame: |
| self.assertLessEqual(len(row), COLS) |
| text = "\n".join(frame) |
| self.assertIn("webOS", frame[0]) |
| for key in ("terminal", "monitor", "shaders"): |
| self.assertIn(key, frame[0]) |
| |
| self.assertIn("[Terminal]", frame[-1]) |
| self.assertGreater(self.desktop.last_frame_ms, 0.0) |
|
|
| def test_memory_counts_the_filesystem_cells(self): |
| """The filesystem writes into the machine's storage, not its own. |
| |
| This is the bug the coordinator fixed: two stores made every free-cell |
| figure a lie, so the counts here are pinned. |
| """ |
| desktop = self.desktop |
| buckets = desktop.memory.buckets() |
| self.assertIn("fs", buckets) |
| self.assertEqual(buckets["fs"], len(desktop.fs.nodes)) |
| self.assertEqual(desktop.memory.stat()["cells"], len(desktop.kernel.storage)) |
|
|
| def test_memory_report_and_state_shape(self): |
| report = self.desktop.memory.report() |
| self.assertIn("cells", report) |
| state = self.desktop.state() |
| for key in ("frame", "windows", "memory", "fs", "status", "apps"): |
| self.assertIn(key, state) |
| self.assertEqual(len(state["frame"]), ROWS) |
| self.assertIn("webOS", self.desktop.report()) |
|
|
|
|
| class TestMemoryAllocator(unittest.TestCase): |
| def setUp(self): |
| self.desktop = Desktop(d=2000) |
| self.map = self.desktop.memory |
|
|
| def test_allocate_and_free(self): |
| before = self.map.stat()["cells"] |
| names = self.map.allocate("scratch", 4) |
| self.assertEqual(len(names), 4) |
| self.assertEqual(self.map.stat()["cells"], before + 4) |
| self.assertEqual(self.map.buckets().get("mem"), 4) |
| self.assertEqual(self.map.free("scratch"), 4) |
| self.assertEqual(self.map.stat()["cells"], before) |
|
|
| def test_free_unknown_tag_is_zero(self): |
| self.assertEqual(self.map.free("never-allocated"), 0) |
|
|
| def test_allocate_zero_is_empty(self): |
| self.assertEqual(self.map.allocate("nothing", 0), []) |
|
|
|
|
| class TestTerminalApp(unittest.TestCase): |
| def setUp(self): |
| self.desktop = Desktop(d=2000).start() |
| self.terminal = self.desktop.windows[0] |
| self.desktop.focus = 0 |
|
|
| def test_typing_then_enter_runs_the_machine(self): |
| self.desktop.text("stat") |
| self.assertEqual(self.terminal.state["typing"], "stat") |
| result = self.desktop.key("Enter") |
| self.assertEqual(result["status"], "kernel: stat") |
| buffer = "\n".join(self.terminal.state["buffer"]) |
| self.assertIn("cells=", buffer) |
| self.assertEqual(self.terminal.state["typing"], "") |
|
|
| def test_backspace_edits_the_typing_buffer(self): |
| self.desktop.text("stad") |
| self.desktop.key("Backspace") |
| self.assertEqual(self.terminal.state["typing"], "sta") |
|
|
| def test_empty_enter_does_not_run_anything(self): |
| result = self.desktop.key("Enter") |
| self.assertEqual(result["action"], "key") |
| self.assertEqual(self.terminal.state["typing"], "") |
|
|
|
|
| class TestFilesApp(unittest.TestCase): |
| def setUp(self): |
| self.desktop = Desktop(d=2000).start() |
| self.desktop.key("F2") |
| self.window = self.desktop.focused() |
| |
| self.desktop.frame() |
| self.assertEqual(self.window.app, "files") |
|
|
| def test_enter_opens_a_directory_and_u_goes_back_up(self): |
| self.assertEqual(self.window.state["cwd"], "/home/user") |
| self.desktop.key("Enter") |
| self.assertEqual(self.window.state["cwd"], "/home/user/img") |
| self.desktop.key("u") |
| self.assertEqual(self.window.state["cwd"], "/home/user") |
|
|
| def test_enter_on_a_file_opens_the_editor(self): |
| self.desktop.key("ArrowDown") |
| self.desktop.key("ArrowDown") |
| self.desktop.key("Enter") |
| editor = self.desktop.focused() |
| self.assertEqual(editor.app, "editor") |
| self.assertTrue(editor.state["path"].endswith("README.txt")) |
|
|
| def test_cursor_stays_inside_the_listing(self): |
| for _ in range(20): |
| self.desktop.key("ArrowDown") |
| entries = self.window.state["entries"] |
| self.assertLessEqual(self.window.state["cursor"], len(entries) - 1) |
|
|
|
|
| class TestEditorApp(unittest.TestCase): |
| def test_appending_reaches_the_filesystem(self): |
| desktop = Desktop(d=2000).start() |
| path = "/home/user/README.txt" |
| window = desktop.open_file(path) |
| self.assertEqual(window.app, "editor") |
| desktop.text("hello line") |
| result = desktop.key("Enter") |
| self.assertEqual(result["status"], "appended to " + path) |
| self.assertIn("hello line", desktop.fs.read(path)) |
| self.assertEqual(window.state["typing"], "") |
|
|
| def test_editor_without_a_file_says_so(self): |
| desktop = Desktop(d=2000).start() |
| window = desktop.launch("editor") |
| desktop.frame() |
| app = window.state["app"] |
| self.assertIn("no file open", "\n".join(app.render(desktop, window))) |
|
|
|
|
| class TestShaderApp(unittest.TestCase): |
| def setUp(self): |
| self.desktop = Desktop(d=2000).start() |
| self.desktop.key("F5") |
| self.window = self.desktop.focused() |
| self.desktop.frame() |
|
|
| def test_space_cycles_the_shader(self): |
| first = self.window.state["shader"] |
| self.assertIn(first, SHADERS) |
| self.desktop.key(" ") |
| second = self.window.state["shader"] |
| self.assertIn(second, SHADERS) |
| self.assertNotEqual(first, second) |
|
|
| def test_e_toggles_the_edge_pass(self): |
| self.assertFalse(self.window.state.get("edges")) |
| self.desktop.key("e") |
| self.assertEqual(self.window.state["edges"], "proxy") |
| self.desktop.key("e") |
| self.assertFalse(self.window.state.get("edges")) |
|
|
| def test_the_window_holds_a_rendered_surface(self): |
| surface = self.window.state["frame"] |
| self.assertEqual(len(surface.rows()), self.window.inner_h - 2) |
| self.assertEqual(len(surface.rows()[0]) <= self.window.inner_w, True) |
|
|
|
|
| class TestKeyboardRouting(unittest.TestCase): |
| def test_function_keys_launch_every_app(self): |
| desktop = Desktop(d=2000) |
| for key, app in Desktop.FUNCTION_KEYS.items(): |
| result = desktop.key(key) |
| self.assertEqual(result["action"], "launch") |
| self.assertIsNotNone(desktop.find(app), msg=app) |
| self.assertEqual(len(desktop.windows), len(APPS)) |
|
|
| def test_tab_cycles_focus(self): |
| desktop = Desktop(d=2000).start() |
| desktop.focus = 0 |
| desktop.key("Tab") |
| self.assertEqual(desktop.focus, 1) |
| desktop.key("Ctrl+Tab") |
| self.assertEqual(desktop.focus, 0) |
|
|
| def test_ctrl_w_closes_and_ctrl_right_moves(self): |
| desktop = Desktop(d=2000).start() |
| before = len(desktop.windows) |
| desktop.key("Ctrl+W") |
| self.assertEqual(len(desktop.windows), before - 1) |
|
|
| desktop = Desktop(d=2000).start() |
| window = desktop.focused() |
| start_x = window.x |
| result = desktop.key("Ctrl+Right") |
| self.assertEqual(result["action"], "move") |
| self.assertEqual(window.x, start_x + 3) |
|
|
| def test_key_with_no_window_is_not_an_exception(self): |
| desktop = Desktop(d=2000) |
| self.assertEqual(desktop.key("q")["action"], "none") |
| self.assertEqual(desktop.text("x")["action"], "none") |
|
|
| def test_unknown_app_raises(self): |
| with self.assertRaises(KeyError): |
| Desktop(d=2000).launch("spreadsheet") |
|
|
|
|
| class TestClickFocus(unittest.TestCase): |
| def test_click_focuses_the_window_under_the_cell(self): |
| desktop = Desktop(d=2000) |
| terminal = desktop.launch("terminal", 1, 1) |
| monitor = desktop.launch("monitor", 50, 1) |
| self.assertEqual(desktop.focused(), monitor) |
|
|
| desktop.click(2, 2) |
| self.assertEqual(desktop.focused(), terminal) |
|
|
| desktop.click(60, 2) |
| self.assertEqual(desktop.focused(), monitor) |
|
|
| def test_click_on_empty_desktop_keeps_focus(self): |
| desktop = Desktop(d=2000).start() |
| focused = desktop.focused() |
| self.assertEqual(desktop.click(0, ROWS - 1), "") |
| self.assertEqual(desktop.focused(), focused) |
|
|
|
|
| class TestSession(unittest.TestCase): |
| def test_boot_returns_a_started_desktop(self): |
| desktop = boot(2000) |
| self.assertEqual(len(desktop.windows), 3) |
| self.assertEqual(desktop.windows[0].app, "terminal") |
|
|
| def test_tour_prints_a_frame_and_the_report(self): |
| text = tour(2000) |
| self.assertIn("=== frame after tour ===", text) |
| self.assertIn("webOS:", text) |
| self.assertIn("memory:", text) |
|
|
|
|
| class TestMemoryMapStandalone(unittest.TestCase): |
| def test_buckets_group_by_prefix(self): |
| desktop = Desktop(d=2000) |
| map_ = MemoryMap(desktop.kernel.storage) |
| desktop.kernel.storage.write("code/0", 0) |
| buckets = map_.buckets() |
| self.assertIn("code", buckets) |
| self.assertIn("fs", buckets) |
| self.assertEqual(buckets["code"], 1) |
|
|
|
|
| if __name__ == "__main__": |
| unittest.main() |
|
|
