def test_display(): device = ili9341(serial, gpio=Mock()) serial.reset_mock() recordings = [] def data(data): recordings.append({'data': data}) def command(*cmd): recordings.append({'command': list(cmd)}) serial.command.side_effect = command serial.data.side_effect = data # Use the same drawing primitives as the demo with canvas(device) as draw: primitives(device, draw) assert serial.data.called assert serial.command.called assert recordings == [{ 'command': [0x2a] }, { 'data': [0x00, 0x00, 0x01, 0x3f] }, { 'command': [0x2b] }, { 'data': [0x00, 0x00, 0x00, 0xef] }, { 'command': [0x2c] }, { 'data': bytearray(get_reference_data('demo_ili9341')) }]
def test_display(): device = st7789(serial, gpio=Mock(), framebuffer=full_frame()) serial.reset_mock() recordings = [] def data(data): recordings.extend(data) def command(*cmd): recordings.extend(['command', list(cmd)[0], 'data', *list(cmd)[1:]]) serial.command.side_effect = command serial.data.side_effect = data # Use the same drawing primitives as the demo with canvas(device) as draw: primitives(device, draw) assert serial.data.called assert serial.command.called # To regenerate test data, uncomment the following (remember not to commit though) # ================================================================================ # from baseline_data import save_reference_data # save_reference_data("demo_st7789", recordings) assert recordings == get_reference_data('demo_st7789')
def test_monochrome_display(): """ SSD1322 OLED screen can draw and display a monochrome image. """ device = ssd1322(serial, mode="1", framebuffer=full_frame()) serial.reset_mock() recordings = [] def data(data): recordings.append({'data': data}) def command(*cmd): recordings.append({'command': list(cmd)}) serial.command.side_effect = command serial.data.side_effect = data # Use the same drawing primitives as the demo with canvas(device) as draw: primitives(device, draw) assert serial.data.called assert serial.command.called # To regenerate test data, uncomment the following (remember not to commit though) # ================================================================================ # from baseline_data import save_reference_data # save_reference_data("demo_ssd1322_monochrome", recordings) assert recordings == get_reference_data('demo_ssd1322_monochrome')
def test_display(): """ UC1701X LCD screen can draw and display an image. """ device = uc1701x(serial, gpio=Mock()) serial.reset_mock() recordings = [] def data(data): recordings.append({'data': data}) def command(*cmd): recordings.append({'command': list(cmd)}) serial.command = Mock(side_effect=command, unsafe=True) serial.data = Mock(side_effect=data, unsafe=True) # Use the same drawing primitives as the demo with canvas(device) as draw: primitives(device, draw) serial.data.assert_called() serial.command.assert_called() # To regenerate test data, uncomment the following (remember not to commit though) # ================================================================================ # from baseline_data import save_reference_data # save_reference_data("demo_uc1701x", recordings) assert recordings == get_reference_data('demo_uc1701x')
def test_16bit_rgb_packing(bit, expected_16_bit_color): """ Checks that 8 bit red component is packed into first 5 bits Checks that 8 bit green component is packed into next 6 bits Checks that 8 bit blue component is packed into remaining 5 bits """ device = ssd1351(serial) serial.reset_mock() rgb_color = (2 ** bit,) * 3 expected = expected_16_bit_color * device.width * device.height recordings = [] def data(data): recordings.append({'data': data}) def command(*cmd): recordings.append({'command': list(cmd)}) serial.command.side_effect = command serial.data.side_effect = data with canvas(device) as draw: draw.rectangle(device.bounding_box, outline=rgb_color, fill=rgb_color) assert serial.data.called assert serial.command.called assert recordings == [ {'command': [21]}, {'data': [0, 127]}, {'command': [117]}, {'data': [0, 127]}, {'command': [92]}, {'data': expected} ]
def test_display(): """ SH1106 OLED screen can draw and display an image. """ device = sh1106(serial) serial.reset_mock() recordings = [] def data(data): recordings.append({'data': data}) def command(*cmd): recordings.append({'command': list(cmd)}) serial.command = Mock(side_effect=command, unsafe=True) serial.data = Mock(side_effect=data, unsafe=True) # Use the same drawing primitives as the demo with canvas(device) as draw: primitives(device, draw) serial.data.assert_called() serial.command.assert_called() assert recordings == get_json_data('demo_sh1106')
def test_alpha_blending(): device = unicornhathd(serial) serial.reset_mock() with canvas(device) as draw: draw.rectangle(device.bounding_box, outline=(255, 128, 64, 32)) serial.data.assert_called_once_with( [0x72] + get_json_data('demo_unicornhathd_alphablend'))
def test_display(): device = unicornhathd(serial) serial.reset_mock() with canvas(device) as draw: draw.rectangle(device.bounding_box, outline="white") serial.data.assert_called_once_with([0x72] + get_json_data('demo_unicornhathd'))
def test_greyscale_display(): """ SSD1322 OLED screen can draw and display a greyscale image. """ device = ssd1322(serial, mode="RGB") serial.reset_mock() recordings = [] def data(data): recordings.append({'data': data}) def command(*cmd): recordings.append({'command': list(cmd)}) serial.command.side_effect = command serial.data.side_effect = data # Use the same drawing primitives as the demo with canvas(device) as draw: baseline_data.primitives(device, draw) assert serial.data.called assert serial.command.called assert recordings == [ {'command': [21]}, {'data': [28, 91]}, {'command': [117]}, {'data': [0, 63]}, {'command': [92]}, {'data': baseline_data.demo_ssd1322_greyscale} ]
def test_contrast(): device = unicornhathd(serial) with canvas(device) as draw: draw.rectangle(device.bounding_box, outline="white", fill="white") serial.reset_mock() device.contrast(0x6B) serial.data.assert_called_once_with([0x72] + [0x6B] * 256 * 3)
def test_contrast(): device = unicornhathd(serial) with canvas(device) as draw: draw.rectangle(device.bounding_box, outline="white", fill="white") serial.reset_mock() device.contrast(0x6B) serial.data.assert_called_once_with([0x72] + [0x6B] * 256 * 3)
def test_display(): device = st7735(serial, gpio=Mock()) serial.reset_mock() recordings = [] def data(data): recordings.append({'data': data}) def command(*cmd): recordings.append({'command': list(cmd)}) serial.command.side_effect = command serial.data.side_effect = data # Use the same drawing primitives as the demo with canvas(device) as draw: primitives(device, draw) assert serial.data.called assert serial.command.called assert recordings == [{ 'command': [42] }, { 'data': [0, 0, 0, 159] }, { 'command': [43] }, { 'data': [0, 0, 0, 127] }, { 'command': [44] }, { 'data': get_reference_data('demo_st7735') }]
def test_display(): device = st7567(serial, gpio=Mock()) serial.reset_mock() recordings = [] def data(data): recordings.append({'data': data}) def command(*cmd): recordings.append({'command': list(cmd)}) serial.command.side_effect = command serial.data.side_effect = data # Use the same drawing primitives as the demo with canvas(device) as draw: primitives(device, draw) assert serial.data.called assert serial.command.called # To regenerate test data, uncomment the following (remember not to commit though) # ================================================================================ # from baseline_data import save_reference_data # save_reference_data("demo_st7567", recordings) assert recordings == get_reference_data('demo_st7567')
def test_display(): """ UC1701X LCD screen can draw and display an image. """ device = uc1701x(serial, gpio=Mock()) serial.reset_mock() recordings = [] def data(data): recordings.append({'data': data}) def command(*cmd): recordings.append({'command': list(cmd)}) serial.command = Mock(side_effect=command, unsafe=True) serial.data = Mock(side_effect=data, unsafe=True) # Use the same drawing primitives as the demo with canvas(device) as draw: primitives(device, draw) serial.data.assert_called() serial.command.assert_called() assert recordings == get_reference_data('demo_uc1701x')
def test_display(): """ SH1106 OLED screen can draw and display an image. """ device = sh1106(serial) serial.reset_mock() recordings = [] def data(data): recordings.append({'data': data}) def command(*cmd): recordings.append({'command': list(cmd)}) serial.command = Mock(side_effect=command, unsafe=True) serial.data = Mock(side_effect=data, unsafe=True) # Use the same drawing primitives as the demo with canvas(device) as draw: primitives(device, draw) serial.data.assert_called() serial.command.assert_called() assert recordings == get_json_data('demo_sh1106')
def test_display(): """ SSD1351 OLED screen can draw and display a color image. """ device = ssd1351(serial) serial.reset_mock() recordings = [] def data(data): recordings.append({'data': data}) def command(*cmd): recordings.append({'command': list(cmd)}) serial.command.side_effect = command serial.data.side_effect = data # Use the same drawing primitives as the demo with canvas(device) as draw: primitives(device, draw) assert serial.data.called assert serial.command.called assert recordings == [ {'command': [21]}, {'data': [0, 127]}, {'command': [117]}, {'data': [0, 127]}, {'command': [92]}, {'data': get_json_data('demo_ssd1351')} ]
def test_greyscale_display(): """ SSD1322_NHD OLED screen can draw and display a greyscale image. """ device = ssd1322_nhd(serial, mode="RGB") serial.reset_mock() recordings = [] def data(data): recordings.append({'data': data}) def command(*cmd): recordings.append({'command': list(cmd)}) serial.command.side_effect = command serial.data.side_effect = data # Use the same drawing primitives as the demo with canvas(device) as draw: primitives(device, draw) assert serial.data.called assert serial.command.called assert recordings == [ {'command': [21]}, {'data': [28, 91]}, {'command': [117]}, {'data': [0, 63]}, {'command': [92]}, {'data': get_json_data('demo_ssd1322_nhd_greyscale')} ]
def test_contrast(): device = apa102(serial, cascaded=6) with canvas(device) as draw: draw.rectangle(device.bounding_box, outline="red") serial.reset_mock() device.contrast(0x6B) serial.data.assert_called_with( padding(6) + [0xE6, 0, 0, 0xFF] * 6 + padding(6))
def test_hide(): """ SSD1351 OLED screen content can be hidden. """ device = ssd1351(serial) serial.reset_mock() device.hide() serial.command.assert_called_once_with(174)
def test_hide(): """ SSD1309 OLED screen content can be hidden. """ device = ssd1309(serial) serial.reset_mock() device.hide() serial.command.assert_called_once_with(174)
def test_hide(): """ SSD1331 OLED screen content can be hidden. """ device = ssd1331(serial, framebuffer=full_frame()) serial.reset_mock() device.hide() serial.command.assert_called_once_with(174)
def test_show(): """ SSD1331 OLED screen content can be displayed. """ device = ssd1331(serial, framebuffer=full_frame()) serial.reset_mock() device.show() serial.command.assert_called_once_with(175)
def test_show(): """ SSD1309 OLED screen content can be displayed. """ device = ssd1309(serial) serial.reset_mock() device.show() serial.command.assert_called_once_with(175)
def test_show(): """ SSD1351 OLED screen content can be displayed. """ device = ssd1351(serial) serial.reset_mock() device.show() serial.command.assert_called_once_with(175)
def test_display(): device = apa102(serial, width=4, height=1) serial.reset_mock() with canvas(device) as draw: draw.rectangle(device.bounding_box, outline=(0x11, 0x22, 0x33, 0x44)) serial.data.assert_called_with( padding(4) + [0xE4, 0x33, 0x22, 0x11] * 4 + padding(4))
def test_display(): device = pcd8544(serial) serial.reset_mock() # Use the same drawing primitives as the demo with canvas(device) as draw: primitives(device, draw) # Initial command to reset the display serial.command.assert_called_once_with(32, 128, 64) # Next 1024 bytes are data representing the drawn image serial.data.assert_called_once_with(get_reference_data('demo_pcd8544'))
def test_display(): device = pcd8544(serial, gpio=Mock()) serial.reset_mock() # Use the same drawing primitives as the demo with canvas(device) as draw: primitives(device, draw) # Initial command to reset the display serial.command.assert_called_once_with(32, 128, 64) # Next 1024 bytes are data representing the drawn image serial.data.assert_called_once_with(get_reference_data('demo_pcd8544'))
def test_monochrome_display(): """ SSD1327 OLED screen can draw and display a monochrome image. """ device = ssd1327(serial, mode="1") serial.reset_mock() # Use the same drawing primitives as the demo with canvas(device) as draw: primitives(device, draw) # Initial command to reset the display serial.command.assert_called_once_with(21, 0, 63, 117, 0, 127) # Next 4096 bytes are data representing the drawn image serial.data.assert_called_once_with(get_json_data('demo_ssd1327_monochrome'))
def test_display(): """ SSD1331 OLED screen can draw and display an image. """ device = ssd1331(serial) serial.reset_mock() # Use the same drawing primitives as the demo with canvas(device) as draw: primitives(device, draw) # Initial command to reset the display serial.command.assert_called_once_with(21, 0, 95, 117, 0, 63) # Next 12288 bytes are data representing the drawn image serial.data.assert_called_once_with(get_json_data('demo_ssd1331'))
def test_16bit_rgb_packing(bit, expected_16_bit_color): """ Checks that 8 bit red component is packed into first 5 bits Checks that 8 bit green component is packed into next 6 bits Checks that 8 bit blue component is packed into remaining 5 bits """ device = ssd1331(serial) serial.reset_mock() rgb_color = (2 ** bit,) * 3 expected = expected_16_bit_color * device.width * device.height with canvas(device) as draw: draw.rectangle(device.bounding_box, outline=rgb_color, fill=rgb_color) serial.data.assert_called_once_with(expected)
def test_16bit_rgb_packing(bit, expected_16_bit_color): """ Checks that 8 bit red component is packed into first 5 bits Checks that 8 bit green component is packed into next 6 bits Checks that 8 bit blue component is packed into remaining 5 bits """ device = ssd1331(serial) serial.reset_mock() rgb_color = (2**bit, ) * 3 expected = expected_16_bit_color * device.width * device.height with canvas(device) as draw: draw.rectangle(device.bounding_box, outline=rgb_color, fill=rgb_color) serial.data.assert_called_once_with(expected)
def test_greyscale_display(): """ SSD1362 OLED screen can draw and display a greyscale image. """ device = ssd1362(serial, mode="RGB") serial.reset_mock() # Use the same drawing primitives as the demo with canvas(device) as draw: primitives(device, draw) # Initial command to reset the display serial.command.assert_called_once_with(21, 0, 127, 117, 0, 63) # Next 4096 bytes are data representing the drawn image serial.data.assert_called_once_with(get_json_data('demo_ssd1362_greyscale'))
def test_display(): """ SSD1309 OLED screen can draw and display an image. """ device = ssd1309(serial) serial.reset_mock() # Use the same drawing primitives as the demo with canvas(device) as draw: primitives(device, draw) # Initial command to reset the display serial.command.assert_called_once_with(33, 0, 127, 34, 0, 7) # Next 1024 bytes are data representing the drawn image serial.data.assert_called_once_with(get_json_data('demo_ssd1309'))
def test_monochrome_display(): """ SSD1325 OLED screen can draw and display a monochrome image. """ device = ssd1325(serial, mode="1") serial.reset_mock() # Use the same drawing primitives as the demo with canvas(device) as draw: baseline_data.primitives(device, draw) # Initial command to reset the display serial.command.assert_called_once_with(21, 0, 127, 117, 0, 63) # Next 4096 bytes are data representing the drawn image serial.data.assert_called_once_with(baseline_data.demo_ssd1325_monochrome)
def test_display(): """ SSD1306 OLED screen can draw and display an image. """ device = ssd1306(serial) serial.reset_mock() # Use the same drawing primitives as the demo with canvas(device) as draw: baseline_data.primitives(device, draw) # Initial command to reset the display serial.command.assert_called_once_with(33, 0, 127, 34, 0, 7) # Next 1024 bytes are data representing the drawn image serial.data.assert_called_once_with(baseline_data.demo_ssd1306)
def test_block_realignment_plus180(): device = max7219(serial, cascaded=2, block_orientation=180) serial.reset_mock() with canvas(device) as draw: draw.rectangle((0, 0, 15, 3), outline="white") serial.data.assert_has_calls([ call([1, 0xF0, 1, 0x90]), call([2, 0x90, 2, 0x90]), call([3, 0x90, 3, 0x90]), call([4, 0x90, 4, 0x90]), call([5, 0x90, 5, 0x90]), call([6, 0x90, 6, 0x90]), call([7, 0x90, 7, 0x90]), call([8, 0x90, 8, 0xF0]) ])
def test_normal_alignment(): device = max7219(serial, cascaded=2, block_orientation=0) serial.reset_mock() with canvas(device) as draw: draw.rectangle((0, 0, 15, 3), outline="white") serial.data.assert_has_calls([ call([1, 0x09, 1, 0x0F]), call([2, 0x09, 2, 0x09]), call([3, 0x09, 3, 0x09]), call([4, 0x09, 4, 0x09]), call([5, 0x09, 5, 0x09]), call([6, 0x09, 6, 0x09]), call([7, 0x09, 7, 0x09]), call([8, 0x0F, 8, 0x09]) ])
def test_block_realignment_plus180(): device = max7219(serial, cascaded=2, block_orientation=180) serial.reset_mock() with canvas(device) as draw: draw.rectangle((0, 0, 15, 3), outline="white") serial.data.assert_has_calls([ call([1, 0xF0, 1, 0x90]), call([2, 0x90, 2, 0x90]), call([3, 0x90, 3, 0x90]), call([4, 0x90, 4, 0x90]), call([5, 0x90, 5, 0x90]), call([6, 0x90, 6, 0x90]), call([7, 0x90, 7, 0x90]), call([8, 0x90, 8, 0xF0]) ])
def test_display_16x8(): device = max7219(serial, cascaded=2) serial.reset_mock() with canvas(device) as draw: draw.rectangle(device.bounding_box, outline="white") serial.data.assert_has_calls([ call([1, 0x81, 1, 0xFF]), call([2, 0x81, 2, 0x81]), call([3, 0x81, 3, 0x81]), call([4, 0x81, 4, 0x81]), call([5, 0x81, 5, 0x81]), call([6, 0x81, 6, 0x81]), call([7, 0x81, 7, 0x81]), call([8, 0xFF, 8, 0x81]) ])
def test_display_16x16(): device = max7219(serial, width=16, height=16) serial.reset_mock() with canvas(device) as draw: draw.rectangle(device.bounding_box, outline="white") serial.data.assert_has_calls([ call([1, 0x80, 1, 0xFF, 1, 0x01, 1, 0xFF]), call([2, 0x80, 2, 0x80, 2, 0x01, 2, 0x01]), call([3, 0x80, 3, 0x80, 3, 0x01, 3, 0x01]), call([4, 0x80, 4, 0x80, 4, 0x01, 4, 0x01]), call([5, 0x80, 5, 0x80, 5, 0x01, 5, 0x01]), call([6, 0x80, 6, 0x80, 6, 0x01, 6, 0x01]), call([7, 0x80, 7, 0x80, 7, 0x01, 7, 0x01]), call([8, 0xFF, 8, 0x80, 8, 0xFF, 8, 0x01]) ])
def test_reversed_max7219(): device = max7219(serial, cascaded=4, blocks_arranged_in_reverse_order=True) serial.reset_mock() with canvas(device) as draw: draw.rectangle((0, 0, 15, 3), outline="white") serial.data.assert_has_calls([ call([1, 15, 1, 9, 1, 0, 1, 0]), call([2, 9, 2, 9, 2, 0, 2, 0]), call([3, 9, 3, 9, 3, 0, 3, 0]), call([4, 9, 4, 9, 4, 0, 4, 0]), call([5, 9, 5, 9, 5, 0, 5, 0]), call([6, 9, 6, 9, 6, 0, 6, 0]), call([7, 9, 7, 9, 7, 0, 7, 0]), call([8, 9, 8, 15, 8, 0, 8, 0]) ])
def test_normal_alignment(): device = max7219(serial, cascaded=2, block_orientation=0) serial.reset_mock() with canvas(device) as draw: draw.rectangle((0, 0, 15, 3), outline="white") serial.data.assert_has_calls([ call([1, 0x09, 1, 0x0F]), call([2, 0x09, 2, 0x09]), call([3, 0x09, 3, 0x09]), call([4, 0x09, 4, 0x09]), call([5, 0x09, 5, 0x09]), call([6, 0x09, 6, 0x09]), call([7, 0x09, 7, 0x09]), call([8, 0x0F, 8, 0x09]) ])
def test_display_16x16(): device = max7219(serial, width=16, height=16) serial.reset_mock() with canvas(device) as draw: draw.rectangle(device.bounding_box, outline="white") serial.data.assert_has_calls([ call([1, 0x80, 1, 0xFF, 1, 0x01, 1, 0xFF]), call([2, 0x80, 2, 0x80, 2, 0x01, 2, 0x01]), call([3, 0x80, 3, 0x80, 3, 0x01, 3, 0x01]), call([4, 0x80, 4, 0x80, 4, 0x01, 4, 0x01]), call([5, 0x80, 5, 0x80, 5, 0x01, 5, 0x01]), call([6, 0x80, 6, 0x80, 6, 0x01, 6, 0x01]), call([7, 0x80, 7, 0x80, 7, 0x01, 7, 0x01]), call([8, 0xFF, 8, 0x80, 8, 0xFF, 8, 0x01]) ])
def test_display_16x8(): device = max7219(serial, cascaded=2) serial.reset_mock() with canvas(device) as draw: draw.rectangle(device.bounding_box, outline="white") serial.data.assert_has_calls([ call([1, 0x81, 1, 0xFF]), call([2, 0x81, 2, 0x81]), call([3, 0x81, 3, 0x81]), call([4, 0x81, 4, 0x81]), call([5, 0x81, 5, 0x81]), call([6, 0x81, 6, 0x81]), call([7, 0x81, 7, 0x81]), call([8, 0xFF, 8, 0x81]) ])
def test_display(): device = st7567(serial) serial.reset_mock() recordings = [] def data(data): recordings.append({'data': data}) def command(*cmd): recordings.append({'command': list(cmd)}) serial.command.side_effect = command serial.data.side_effect = data # Use the same drawing primitives as the demo with canvas(device) as draw: primitives(device, draw) assert serial.data.called assert serial.command.called assert recordings == get_reference_data('demo_st7567')
def test_hide(): device = pcd8544(serial) serial.reset_mock() device.hide() serial.command.assert_called_once_with(8)
def test_show(): device = pcd8544(serial) serial.reset_mock() device.show() serial.command.assert_called_once_with(12)
def test_hide(): device = max7219(serial, cascaded=5) serial.reset_mock() device.hide() serial.data.assert_called_once_with([12, 0] * 5)
def test_show(): device = max7219(serial, cascaded=3) serial.reset_mock() device.show() serial.data.assert_called_once_with([12, 1] * 3)
def test_contrast(): device = max7219(serial, cascaded=6) serial.reset_mock() device.contrast(0x6B) serial.data.assert_called_once_with([10, 6] * 6)
def test_alpha_blending(): device = unicornhathd(serial) serial.reset_mock() with canvas(device) as draw: draw.rectangle(device.bounding_box, outline=(255, 128, 64, 32)) serial.data.assert_called_once_with([0x72] + get_json_data('demo_unicornhathd_alphablend'))
def test_hide(): device = unicornhathd(serial) serial.reset_mock() device.hide() serial.data.assert_called_once_with([0x72] + [0] * 256 * 3)
def test_contrast(): device = st7567(serial) serial.reset_mock() with pytest.raises(AssertionError): device.contrast(300)
def test_display(): device = unicornhathd(serial) serial.reset_mock() with canvas(device) as draw: draw.rectangle(device.bounding_box, outline="white") serial.data.assert_called_once_with([0x72] + get_json_data('demo_unicornhathd'))