fix test for 2027

Author: auscompgeek

subprojects/robotpy-wpilib/tests/test_addressable_led_buffer.py

@@ -4,7 +4,8 @@
 
 import pytest
 
-from wpilib import AddressableLEDBuffer, Color, Color8Bit
+from wpilib import AddressableLEDBuffer
+from wpiutil import Color, Color8Bit
 
 AddressableLEDBufferView = AddressableLEDBuffer.View
 
@@ -45,19 +46,19 @@ def test_hsv_convert(self, h, s, v, r, g, b):
     def test_get_color(self):
         """Test getting colors from buffer"""
         buffer = AddressableLEDBuffer(4)
-        denim_color_8bit = Color8Bit(Color.kDenim)
-        first_blue_color_8bit = Color8Bit(Color.kFirstBlue)
-        first_red_color_8bit = Color8Bit(Color.kFirstRed)
+        denim_color_8bit = Color8Bit(Color.DENIM)
+        first_blue_color_8bit = Color8Bit(Color.FIRST_BLUE)
+        first_red_color_8bit = Color8Bit(Color.FIRST_RED)
 
-        buffer.setLED(0, Color.kFirstBlue)
+        buffer.setLED(0, Color.FIRST_BLUE)
         buffer.setLED(1, denim_color_8bit)
-        buffer.setLED(2, Color.kFirstRed)
-        buffer.setLED(3, Color.kFirstBlue)
+        buffer.setLED(2, Color.FIRST_RED)
+        buffer.setLED(3, Color.FIRST_BLUE)
 
-        assert buffer.getLED(0) == Color.kFirstBlue
-        assert buffer.getLED(1) == Color.kDenim
-        assert buffer.getLED(2) == Color.kFirstRed
-        assert buffer.getLED(3) == Color.kFirstBlue
+        assert buffer.getLED(0) == Color.FIRST_BLUE
+        assert buffer.getLED(1) == Color.DENIM
+        assert buffer.getLED(2) == Color.FIRST_RED
+        assert buffer.getLED(3) == Color.FIRST_BLUE
         assert buffer.getLED8Bit(0) == first_blue_color_8bit
         assert buffer.getLED8Bit(1) == denim_color_8bit
         assert buffer.getLED8Bit(2) == first_red_color_8bit
@@ -111,7 +112,7 @@ def test_single_led(self):
         """Test setting a single LED through a view"""
         buffer = AddressableLEDBuffer(10)
         view = buffer[5:6]
-        color = Color.kAqua
+        color = Color.AQUA
         view.setLED(0, color)
         assert buffer.getLED(5) == color
         assert view.getLED(0) == color
@@ -120,11 +121,11 @@ def test_segment(self):
         """Test segment view"""
         buffer = AddressableLEDBuffer(10)
         view = buffer[2:9]
-        view.setLED(0, Color.kAqua)
-        assert buffer.getLED(2) == Color.kAqua
+        view.setLED(0, Color.AQUA)
+        assert buffer.getLED(2) == Color.AQUA
 
-        view.setLED(6, Color.kAzure)
-        assert buffer.getLED(8) == Color.kAzure
+        view.setLED(6, Color.AZURE)
+        assert buffer.getLED(8) == Color.AZURE
 
     @pytest.mark.skip("reversed views are not implemented")
     def test_manual_reversed(self):
@@ -133,31 +134,31 @@ def test_manual_reversed(self):
         view = buffer[8:1:-1]
 
         # LED 0 in the view should write to LED 8 on the real buffer
-        view.setLED(0, Color.kAqua)
-        assert buffer.getLED(8) == Color.kAqua
+        view.setLED(0, Color.AQUA)
+        assert buffer.getLED(8) == Color.AQUA
 
         # LED 6 in the view should write to LED 2 on the real buffer
-        view.setLED(6, Color.kAzure)
-        assert buffer.getLED(2) == Color.kAzure
+        view.setLED(6, Color.AZURE)
+        assert buffer.getLED(2) == Color.AZURE
 
     @pytest.mark.skip("reversed views are not implemented")
     def test_full_manual_reversed(self):
         """Test full manual reversed view"""
         buffer = AddressableLEDBuffer(10)
         view = buffer[9::-1]
-        view.setLED(0, Color.kWhite)
-        assert buffer.getLED(9) == Color.kWhite
+        view.setLED(0, Color.WHITE)
+        assert buffer.getLED(9) == Color.WHITE
 
-        buffer.setLED(8, Color.kRed)
-        assert view.getLED(1) == Color.kRed
+        buffer.setLED(8, Color.RED)
+        assert view.getLED(1) == Color.RED
 
     @pytest.mark.skip("reversed views are not implemented")
     def test_reversed(self):
         """Test reversed view"""
         buffer = AddressableLEDBuffer(10)
         view = buffer[:].reversed()
-        view.setLED(0, Color.kWhite)
-        assert buffer.getLED(9) == Color.kWhite
+        view.setLED(0, Color.WHITE)
+        assert buffer.getLED(9) == Color.WHITE
 
-        view.setLED(9, Color.kRed)
-        assert buffer.getLED(0) == Color.kRed
+        view.setLED(9, Color.RED)
+        assert buffer.getLED(0) == Color.RED

subprojects/robotpy-wpilib/tests/test_led_pattern.py

@@ -7,7 +7,8 @@
 import pytest
 import wpimath.units as units
 
-from wpilib import AddressableLEDBuffer, Color, Color8Bit, LEDPattern, RobotController
+from wpilib import AddressableLEDBuffer, LEDPattern, RobotController
+from wpiutil import Color, Color8Bit
 
 
 def lerp_rgb(a: Color, b: Color, t: float) -> Color8Bit:
@@ -29,34 +30,34 @@ def restore_time_source():
 
 def test_apply_to_buffer_direct():
     buffer = AddressableLEDBuffer(4)
-    LEDPattern.solid(Color.kYellow).applyTo(buffer)
+    LEDPattern.solid(Color.YELLOW).applyTo(buffer)
 
     for i in range(len(buffer)):
-        assert buffer.getLED8Bit(i) == Color8Bit(Color.kYellow)
+        assert buffer.getLED8Bit(i) == Color8Bit(Color.YELLOW)
 
 
 def test_apply_to_view_direct():
     buffer = AddressableLEDBuffer(6)
     view = buffer[2:5]
-    LEDPattern.solid(Color.kAqua).applyTo(view)
+    LEDPattern.solid(Color.AQUA).applyTo(view)
 
-    assert buffer.getLED8Bit(1) == Color8Bit(Color.kBlack)
-    assert buffer.getLED8Bit(2) == Color8Bit(Color.kAqua)
-    assert buffer.getLED8Bit(3) == Color8Bit(Color.kAqua)
-    assert buffer.getLED8Bit(4) == Color8Bit(Color.kAqua)
-    assert buffer.getLED8Bit(5) == Color8Bit(Color.kBlack)
+    assert buffer.getLED8Bit(1) == Color8Bit(Color.BLACK)
+    assert buffer.getLED8Bit(2) == Color8Bit(Color.AQUA)
+    assert buffer.getLED8Bit(3) == Color8Bit(Color.AQUA)
+    assert buffer.getLED8Bit(4) == Color8Bit(Color.AQUA)
+    assert buffer.getLED8Bit(5) == Color8Bit(Color.BLACK)
 
 
 def test_solid_color():
     buffer = AddressableLEDBuffer(99)
-    LEDPattern.solid(Color.kYellow).applyTo(buffer)
+    LEDPattern.solid(Color.YELLOW).applyTo(buffer)
 
     for i in range(len(buffer)):
-        assert buffer.getLED8Bit(i) == Color8Bit(Color.kYellow)
+        assert buffer.getLED8Bit(i) == Color8Bit(Color.YELLOW)
 
 
 def test_gradient_0_sets_to_black():
-    pattern = LEDPattern.gradient(LEDPattern.GradientType.kContinuous, [])
+    pattern = LEDPattern.gradient(LEDPattern.GradientType.CONTINUOUS, [])
     buffer = AddressableLEDBuffer(99)
 
     for i in range(len(buffer)):
@@ -65,42 +66,42 @@ def test_gradient_0_sets_to_black():
     pattern.applyTo(buffer)
 
     for i in range(len(buffer)):
-        assert buffer.getLED8Bit(i) == Color8Bit(Color.kBlack)
+        assert buffer.getLED8Bit(i) == Color8Bit(Color.BLACK)
 
 
 def test_gradient_1_sets_to_solid():
-    pattern = LEDPattern.gradient(LEDPattern.GradientType.kContinuous, [Color.kYellow])
+    pattern = LEDPattern.gradient(LEDPattern.GradientType.CONTINUOUS, [Color.YELLOW])
     buffer = AddressableLEDBuffer(99)
     pattern.applyTo(buffer)
 
     for i in range(len(buffer)):
-        assert buffer.getLED8Bit(i) == Color8Bit(Color.kYellow)
+        assert buffer.getLED8Bit(i) == Color8Bit(Color.YELLOW)
 
 
 def test_continuous_gradient_2_colors():
     pattern = LEDPattern.gradient(
-        LEDPattern.GradientType.kContinuous, [Color.kYellow, Color.kPurple]
+        LEDPattern.GradientType.CONTINUOUS, [Color.YELLOW, Color.PURPLE]
     )
     buffer = AddressableLEDBuffer(99)
     pattern.applyTo(buffer)
 
-    assert buffer.getLED8Bit(0) == Color8Bit(Color.kYellow)
-    assert buffer.getLED8Bit(25) == lerp_rgb(Color.kYellow, Color.kPurple, 25 / 49.0)
-    assert buffer.getLED8Bit(49) == Color8Bit(Color.kPurple)
-    assert buffer.getLED8Bit(73) == lerp_rgb(Color.kYellow, Color.kPurple, 25 / 49.0)
-    assert buffer.getLED8Bit(98) == Color8Bit(Color.kYellow)
+    assert buffer.getLED8Bit(0) == Color8Bit(Color.YELLOW)
+    assert buffer.getLED8Bit(25) == lerp_rgb(Color.YELLOW, Color.PURPLE, 25 / 49.0)
+    assert buffer.getLED8Bit(49) == Color8Bit(Color.PURPLE)
+    assert buffer.getLED8Bit(73) == lerp_rgb(Color.YELLOW, Color.PURPLE, 25 / 49.0)
+    assert buffer.getLED8Bit(98) == Color8Bit(Color.YELLOW)
 
 
 def test_discontinuous_gradient_2_colors():
     pattern = LEDPattern.gradient(
-        LEDPattern.GradientType.kDiscontinuous, [Color.kYellow, Color.kPurple]
+        LEDPattern.GradientType.DISCONTINUOUS, [Color.YELLOW, Color.PURPLE]
     )
     buffer = AddressableLEDBuffer(99)
     pattern.applyTo(buffer)
 
-    assert buffer.getLED8Bit(0) == Color8Bit(Color.kYellow)
-    assert buffer.getLED8Bit(49) == lerp_rgb(Color.kYellow, Color.kPurple, 0.5)
-    assert buffer.getLED8Bit(98) == Color8Bit(Color.kPurple)
+    assert buffer.getLED8Bit(0) == Color8Bit(Color.YELLOW)
+    assert buffer.getLED8Bit(49) == lerp_rgb(Color.YELLOW, Color.PURPLE, 0.5)
+    assert buffer.getLED8Bit(98) == Color8Bit(Color.PURPLE)
 
 
 def test_step_0_sets_to_black():
@@ -112,27 +113,27 @@ def test_step_0_sets_to_black():
     pattern.applyTo(buffer)
 
     for i in range(len(buffer)):
-        assert buffer.getLED8Bit(i) == Color8Bit(Color.kBlack)
+        assert buffer.getLED8Bit(i) == Color8Bit(Color.BLACK)
 
 
 def test_step_1_sets_to_solid():
-    pattern = LEDPattern.steps([(0.0, Color.kYellow)])
+    pattern = LEDPattern.steps([(0.0, Color.YELLOW)])
     buffer = AddressableLEDBuffer(99)
     pattern.applyTo(buffer)
 
     for i in range(len(buffer)):
-        assert buffer.getLED8Bit(i) == Color8Bit(Color.kYellow)
+        assert buffer.getLED8Bit(i) == Color8Bit(Color.YELLOW)
 
 
 def test_step_half_sets_to_half_off_half_color():
-    pattern = LEDPattern.steps([(0.5, Color.kYellow)])
+    pattern = LEDPattern.steps([(0.5, Color.YELLOW)])
     buffer = AddressableLEDBuffer(99)
     pattern.applyTo(buffer)
 
     for i in range(49):
-        assert buffer.getLED8Bit(i) == Color8Bit(Color.kBlack)
+        assert buffer.getLED8Bit(i) == Color8Bit(Color.BLACK)
     for i in range(49, len(buffer)):
-        assert buffer.getLED8Bit(i) == Color8Bit(Color.kYellow)
+        assert buffer.getLED8Bit(i) == Color8Bit(Color.YELLOW)
 
 
 def make_grayscale_pattern():
@@ -200,35 +201,35 @@ def test_rainbow_odd_size():
 
 def test_reverse_solid():
     buffer = AddressableLEDBuffer(90)
-    pattern = LEDPattern.solid(Color.kRosyBrown).reversed()
+    pattern = LEDPattern.solid(Color.ROSY_BROWN).reversed()
     pattern.applyTo(buffer)
 
     for led in range(len(buffer)):
-        assert buffer.getLED8Bit(led) == Color8Bit(Color.kRosyBrown)
+        assert buffer.getLED8Bit(led) == Color8Bit(Color.ROSY_BROWN)
 
 
 def test_reverse_steps():
     buffer = AddressableLEDBuffer(100)
-    pattern = LEDPattern.steps([(0.0, Color.kWhite), (0.5, Color.kYellow)]).reversed()
+    pattern = LEDPattern.steps([(0.0, Color.WHITE), (0.5, Color.YELLOW)]).reversed()
     pattern.applyTo(buffer)
 
     for led in range(len(buffer)):
-        expected = Color8Bit(Color.kYellow if led < 50 else Color.kWhite)
+        expected = Color8Bit(Color.YELLOW if led < 50 else Color.WHITE)
         assert buffer.getLED8Bit(led) == expected
 
 
 def white_yellow_purple(reader, writer):
-    colors = [Color.kWhite, Color.kYellow, Color.kPurple]
+    colors = [Color.WHITE, Color.YELLOW, Color.PURPLE]
     for led in range(reader.size()):
         writer(led, colors[led % 3])
 
 
 @pytest.mark.parametrize(
     "offset,expected",
     [
-        (1, [Color.kPurple, Color.kWhite, Color.kYellow]),
-        (-1, [Color.kYellow, Color.kPurple, Color.kWhite]),
-        (0, [Color.kWhite, Color.kYellow, Color.kPurple]),
+        (1, [Color.PURPLE, Color.WHITE, Color.YELLOW]),
+        (-1, [Color.YELLOW, Color.PURPLE, Color.WHITE]),
+        (0, [Color.WHITE, Color.YELLOW, Color.PURPLE]),
     ],
 )
 def test_offset_pattern(offset, expected):
@@ -242,56 +243,56 @@ def test_offset_pattern(offset, expected):
 
 @pytest.mark.skip(reason="Python bindings do not expose a way to mock wpi::util::Now()")
 def test_blink_symmetric():
-    pattern = LEDPattern.solid(Color.kWhite).blink(units.seconds(2))
+    pattern = LEDPattern.solid(Color.WHITE).blink(units.seconds(2))
     buffer = AddressableLEDBuffer(1)
 
     for t in range(8):
         RobotController.setTimeSource(lambda tick=t: tick * 1_000_000)
         pattern.applyTo(buffer)
-        expected = Color8Bit(Color.kWhite if t % 4 < 2 else Color.kBlack)
+        expected = Color8Bit(Color.WHITE if t % 4 < 2 else Color.BLACK)
         assert buffer.getLED8Bit(0) == expected
 
 
 def test_blink_in_sync():
     state = {"on": False}
-    pattern = LEDPattern.solid(Color.kWhite).synchronizedBlink(lambda: state["on"])
+    pattern = LEDPattern.solid(Color.WHITE).synchronizedBlink(lambda: state["on"])
     buffer = AddressableLEDBuffer(1)
 
     pattern.applyTo(buffer)
-    assert buffer.getLED8Bit(0) == Color8Bit(Color.kBlack)
+    assert buffer.getLED8Bit(0) == Color8Bit(Color.BLACK)
 
     state["on"] = True
     pattern.applyTo(buffer)
-    assert buffer.getLED8Bit(0) == Color8Bit(Color.kWhite)
+    assert buffer.getLED8Bit(0) == Color8Bit(Color.WHITE)
 
     state["on"] = False
     pattern.applyTo(buffer)
-    assert buffer.getLED8Bit(0) == Color8Bit(Color.kBlack)
+    assert buffer.getLED8Bit(0) == Color8Bit(Color.BLACK)
 
 
 @pytest.mark.skip(reason="Python bindings do not expose a way to mock wpi::util::Now()")
 def test_breathe():
-    pattern = LEDPattern.solid(Color.kWhite).breathe(units.microseconds(4))
+    pattern = LEDPattern.solid(Color.WHITE).breathe(units.microseconds(4))
     buffer = AddressableLEDBuffer(1)
 
     RobotController.setTimeSource(lambda: 0)
     pattern.applyTo(buffer)
-    assert buffer.getLED8Bit(0) == Color8Bit(Color.kWhite)
+    assert buffer.getLED8Bit(0) == Color8Bit(Color.WHITE)
 
     RobotController.setTimeSource(lambda: 1)
     pattern.applyTo(buffer)
     assert buffer.getLED8Bit(0) == Color8Bit(Color(0.5, 0.5, 0.5))
 
     RobotController.setTimeSource(lambda: 2)
     pattern.applyTo(buffer)
-    assert buffer.getLED8Bit(0) == Color8Bit(Color.kBlack)
+    assert buffer.getLED8Bit(0) == Color8Bit(Color.BLACK)
 
 
 def test_overlay_solid_on_solid():
-    overlay = LEDPattern.solid(Color.kYellow).overlayOn(LEDPattern.solid(Color.kWhite))
+    overlay = LEDPattern.solid(Color.YELLOW).overlayOn(LEDPattern.solid(Color.WHITE))
     buffer = AddressableLEDBuffer(1)
     overlay.applyTo(buffer)
-    assert buffer.getLED8Bit(0) == Color8Bit(Color.kYellow)
+    assert buffer.getLED8Bit(0) == Color8Bit(Color.YELLOW)
 
 
 def test_progress_mask_layer():
@@ -303,26 +304,26 @@ def test_progress_mask_layer():
     pattern.applyTo(buffer)
 
     for i in range(3):
-        assert buffer.getLED8Bit(i) == Color8Bit(Color.kWhite)
+        assert buffer.getLED8Bit(i) == Color8Bit(Color.WHITE)
     for i in range(3, 10):
-        assert buffer.getLED8Bit(i) == Color8Bit(Color.kBlack)
+        assert buffer.getLED8Bit(i) == Color8Bit(Color.BLACK)
 
 
 def test_blend():
-    pattern = LEDPattern.solid(Color.kBlue).blend(LEDPattern.solid(Color.kRed))
+    pattern = LEDPattern.solid(Color.BLUE).blend(LEDPattern.solid(Color.RED))
     buffer = AddressableLEDBuffer(1)
     pattern.applyTo(buffer)
     assert buffer.getLED8Bit(0) == Color8Bit(Color(127, 0, 127))
 
 
 def test_binary_mask():
     base = LEDPattern.solid(Color(123, 123, 123))
-    mask = LEDPattern.steps([(0.0, Color.kWhite), (0.5, Color.kBlack)])
+    mask = LEDPattern.steps([(0.0, Color.WHITE), (0.5, Color.BLACK)])
     pattern = base.mask(mask)
     buffer = AddressableLEDBuffer(4)
     pattern.applyTo(buffer)
 
     for i in range(2):
         assert buffer.getLED8Bit(i) == Color8Bit(Color(123, 123, 123))
     for i in range(2, 4):
-        assert buffer.getLED8Bit(i) == Color8Bit(Color.kBlack)
+        assert buffer.getLED8Bit(i) == Color8Bit(Color.BLACK)