Skip to content

One keyboard and mouse for a Mac and a Windows PC over the local network, in either direction.

11.3 KB
Raw Blame
import unittest
import os
import sys
from types import SimpleNamespace
from unittest import mock

sys.path.append(os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__)))))

try:
    os.environ.setdefault("QT_QPA_PLATFORM", "offscreen")
    from PySide6.QtCore import QPoint, QRect
    from PySide6.QtWidgets import QApplication
    import edge_glow
    from core import effects
except ImportError:  # PySide6 is only in the Windows build venv
    edge_glow = None


@unittest.skipIf(edge_glow is None, "PySide6 is not installed")
class BeamMathsTests(unittest.TestCase):
    def test_comet_travels_faster_as_pressure_builds(self):
        self.assertEqual(edge_glow.traverse_seconds(0.0), edge_glow.SLOW_TRAVERSE_S)
        self.assertAlmostEqual(edge_glow.traverse_seconds(1.0), edge_glow.FAST_TRAVERSE_S)
        self.assertLess(edge_glow.traverse_seconds(0.7), edge_glow.traverse_seconds(0.2))

    def test_edge_is_brightest_at_the_comet_and_dim_away_from_it(self):
        self.assertEqual(edge_glow.comet_alpha(0.5, 0.5, 0.0), 1.0)
        self.assertEqual(edge_glow.comet_alpha(0.0, 0.5, 0.0), edge_glow.BEAM_BASE)

    def test_breakthrough_lights_the_whole_edge(self):
        self.assertEqual(edge_glow.comet_alpha(0.0, 0.5, 1.0), 1.0)


@unittest.skipIf(edge_glow is None, "PySide6 is not installed")
class SelectedSizeTests(unittest.TestCase):
    def test_glow_window_geometry_uses_the_selected_display_scaled_size(self):
        _app = QApplication.instance() or QApplication([])
        screen = SimpleNamespace(geometry=lambda: QRect(0, 0, 1920, 1080))
        glow = edge_glow.EdgeGlow()
        self.addCleanup(glow.deleteLater)
        glow.configure("glow", "signal", size="large")
        glow._edge, glow._part = "left", None
        with mock.patch.object(edge_glow.QApplication, "screens", return_value=[screen]), \
                mock.patch.object(edge_glow.QCursor, "pos", return_value=QPoint(0, 500)):
            glow._place()
        self.assertEqual(glow.geometry().width(), round(effects.edge_depth(1920, 1080, "large")))


@unittest.skipIf(edge_glow is None, "PySide6 is not installed")
class GlowStateTests(unittest.TestCase):
    def test_a_breakthrough_flashes_then_fades_out(self):
        state = edge_glow.GlowState()
        state.push(0.6, False)
        state.push(1.0, True)
        self.assertEqual((state.pressure, state.flash, state.finish), (0.0, 1.0, 1.0))
        self.assertTrue(state.step(0.1, stale=True))
        self.assertFalse(state.step(5.0, stale=True))

    def test_pressure_holds_while_the_push_keeps_arriving(self):
        state = edge_glow.GlowState()
        state.push(0.5, False)
        state.step(0.2, stale=False)
        self.assertEqual(state.pressure, 0.5)


@unittest.skipIf(edge_glow is None, "PySide6 is not installed")
class PreviewScriptTests(unittest.TestCase):
    def test_the_push_builds_goes_through_and_rests(self):
        self.assertEqual(edge_glow.preview_frame(0.0), (0.0, "push"))
        level, phase = edge_glow.preview_frame(edge_glow.PUSH_S * 0.9)
        self.assertEqual(phase, "push")
        self.assertGreater(level, 0.8)
        self.assertEqual(edge_glow.preview_frame(edge_glow.PUSH_S + 0.1), (0.0, "after"))
        self.assertEqual(edge_glow.preview_frame(edge_glow.PUSH_S + edge_glow.AFTER_S + 0.1), (0.0, "rest"))

    def test_it_loops(self):
        loop = edge_glow.PUSH_S + edge_glow.AFTER_S + edge_glow.REST_S
        self.assertEqual(edge_glow.preview_frame(loop + 0.5), edge_glow.preview_frame(0.5))



@unittest.skipIf(edge_glow is None, "PySide6 is not installed")
class DarkColoursTest(unittest.TestCase):
    def test_a_dark_pack_is_lifted_on_a_dark_appearance_only(self):
        from unittest import mock

        from core import effects

        # Indigo ink, the darkest pack, though Ink is offered nowhere for now.
        def first(dark):
            with mock.patch.object(edge_glow.app_config, "palette_colours", return_value=effects.pack("indigo_ink")[1]):
                stops = edge_glow._colours("indigo_ink", True, 100, dark).stops()
            return stops[0][1].lightnessF()
        self.assertLess(first(False), 0.2)
        self.assertGreater(first(True), 0.4)


@unittest.skipIf(edge_glow is None, "PySide6 is not installed")
class PreviewLoopHoverTests(unittest.TestCase):
    """Glow and Beam's tiles hold a still; the one the pointer is over plays, from that still."""

    def setUp(self):
        import os

        os.environ.setdefault("QT_QPA_PLATFORM", "offscreen")
        from PySide6.QtWidgets import QApplication, QWidget

        self.app = QApplication.instance() or QApplication([])
        self.parent = QWidget()
        self.loop = edge_glow.PreviewLoop(self.parent)
        self.tiles = [edge_glow.GlowPreview(style) for style in ("glow", "beam")]
        for tile in self.tiles:
            tile.isVisible = lambda: True
            tile.visibleRegion = lambda: type("Region", (), {"isEmpty": lambda self: False})()
            self.loop.add(tile)
        self.loop.run(True)

    def tearDown(self):
        self.loop.run(False)

    def test_every_tile_holds_a_still_until_one_is_hovered(self):
        self.assertFalse(self.loop._timer.isActive())
        self.loop._tick()
        self.assertEqual([tile.state.pressure for tile in self.tiles], [edge_glow.PreviewLoop.HOLD] * 2)
        self.assertFalse(any(self.loop.playing(tile) for tile in self.tiles))

    def test_a_pointer_passing_over_starts_nothing(self):
        self.loop.hover(self.tiles[1])
        self.loop._tick()
        self.assertFalse(self.loop.playing(self.tiles[1]))

    def test_the_hovered_tile_plays_on_from_its_still_and_settles_back(self):
        self.loop.hover(self.tiles[1])
        self.assertTrue(self.loop._timer.isActive())
        self.loop._hovered_at -= edge_glow.PreviewLoop.INTENT_S
        self.loop._tick()
        self.assertTrue(self.loop.playing(self.tiles[1]))
        self.assertAlmostEqual(self.tiles[1].state.pressure, edge_glow.PreviewLoop.HOLD, places=2)
        self.loop.hover(None)
        self.assertFalse(self.loop.playing(self.tiles[1]))
        self.assertEqual(self.tiles[1].state.pressure, edge_glow.PreviewLoop.HOLD)


if __name__ == "__main__":
    unittest.main()


@unittest.skipIf(edge_glow is None, "PySide6 is not installed")
class CornerGlowTests(unittest.TestCase):
    """Glow and Beam in a corner light the corner's two walls, and every window stays above the
    taskbar."""

    def setUp(self):
        import os

        os.environ.setdefault("QT_QPA_PLATFORM", "offscreen")
        from PySide6.QtWidgets import QApplication

        self.app = QApplication.instance() or QApplication([])

    def render(self, corner, style="glow", centre=0.5):
        from PySide6.QtCore import QRect
        from PySide6.QtGui import QImage, QPainter, Qt

        size = edge_glow.CORNER_ARM_PX
        image = QImage(size, size, QImage.Format.Format_ARGB32_Premultiplied)
        image.fill(Qt.GlobalColor.transparent)
        state = edge_glow.GlowState()
        state.push(0.9, False)
        state.centre = centre
        painter = QPainter(image)
        edge_glow.paint_corner(painter, QRect(0, 0, size, size), corner, style, "signal", state)
        painter.end()
        return image

    def test_a_corner_lights_both_its_walls_brightest_where_they_meet(self):
        last = edge_glow.CORNER_ARM_PX - 1
        for corner, (cx, cy) in (("top_left", (0, 0)), ("top_right", (last, 0)),
                                 ("bottom_left", (0, last)), ("bottom_right", (last, last))):
            image = self.render(corner)
            alpha = lambda x, y: image.pixelColor(x, y).alpha()
            far_x = last if cx == 0 else 0
            far_y = last if cy == 0 else 0
            step_x = 1 if cx == 0 else -1
            step_y = 1 if cy == 0 else -1
            with self.subTest(corner=corner):
                self.assertGreater(alpha(cx, cy), 150)
                # A third of the way along each wall is lit, less than the corner itself.
                self.assertGreater(alpha(cx + step_x * 60, cy), 40)
                self.assertGreater(alpha(cx, cy + step_y * 60), 40)
                self.assertLess(alpha(cx + step_x * 60, cy), alpha(cx, cy))
                # Nothing at the far ends of the walls, nor out in the middle of the square.
                self.assertLess(alpha(far_x, cy), 8)
                self.assertLess(alpha(cx, far_y), 8)
                self.assertEqual(alpha(edge_glow.CORNER_ARM_PX // 2, edge_glow.CORNER_ARM_PX // 2), 0)

    def test_the_beams_comet_runs_in_along_one_wall_and_out_along_the_other(self):
        last = edge_glow.CORNER_ARM_PX - 1
        # bottom_right: the bottom wall from its left end to the corner, then up the right wall.
        early, late = self.render("bottom_right", "beam", 0.15), self.render("bottom_right", "beam", 0.85)
        on_bottom = lambda image: image.pixelColor(60, last).alpha()
        on_right = lambda image: image.pixelColor(last, 60).alpha()
        self.assertGreater(on_bottom(early), on_bottom(late))
        self.assertGreater(on_right(late), on_right(early))

    def test_a_corner_push_places_the_light_at_that_corner_of_the_display(self):
        from unittest import mock

        from PySide6.QtCore import QPoint

        glow = edge_glow.EdgeGlow()
        screen = self.app.primaryScreen().geometry()
        with mock.patch.object(edge_glow.QCursor, "pos", return_value=QPoint(screen.right() - 2, screen.bottom() - 2)):
            glow.set_pressure("bottom", 0.5, False, "bottom_right")
        size = min(edge_glow.CORNER_ARM_PX, screen.width(), screen.height())
        self.assertEqual((glow.geometry().right(), glow.geometry().bottom()), (screen.right(), screen.bottom()))
        self.assertEqual((glow.width(), glow.height()), (size, size))
        glow.hide()

    def test_every_frame_puts_the_window_back_above_the_taskbar(self):
        from unittest import mock

        glow = edge_glow.EdgeGlow()
        with mock.patch.object(edge_glow, "keep_on_top") as raised:
            glow.set_pressure("left", 0.5, False)
            glow._tick()
        self.assertEqual(raised.call_count, 2)
        glow.hide()


@unittest.skipIf(edge_glow is None, "PySide6 is not installed")
class ThirdEndsTests(unittest.TestCase):
    def setUp(self):
        import os

        os.environ.setdefault("QT_QPA_PLATFORM", "offscreen")
        from PySide6.QtWidgets import QApplication

        self.app = QApplication.instance() or QApplication([])

    def test_a_third_of_the_edge_fades_in_and_out_at_its_ends(self):
        from PySide6.QtCore import QRect
        from PySide6.QtGui import QImage, QPainter, Qt

        for style in ("glow", "beam"):
            for taper in (False, True):
                image = QImage(44, 400, QImage.Format.Format_ARGB32_Premultiplied)
                image.fill(Qt.GlobalColor.transparent)
                state = edge_glow.GlowState()
                state.push(0.9, False)
                state.flash = 1.0
                painter = QPainter(image)
                edge_glow.paint(painter, QRect(0, 0, 44, 400), "right", style, "signal", state, taper=taper)
                painter.end()
                end, middle = image.pixelColor(43, 1).alpha(), image.pixelColor(43, 200).alpha()
                with self.subTest(style=style, taper=taper):
                    self.assertGreater(middle, 100)
                    if taper:
                        self.assertLess(end, 12)
                    else:
                        self.assertGreater(end, 100)