denko 0.14.0 → 0.15.0

data/test/display/canvas_test.rb

@@ -0,0 +1,306 @@
+require_relative '../test_helper'
+
+class CanvasTest < Minitest::Test
+  WIDTH     = 32
+  HEIGHT    = 32
+  FB_LENGTH = (WIDTH * HEIGHT / 8)
+
+  def subject
+    @subject ||= Denko::Display::Canvas.new(WIDTH, HEIGHT, colors: 2)
+  end
+
+  def test_framebuffer_default_state
+    assert_equal 2, subject.framebuffers.length
+    assert_equal subject.framebuffer.object_id, subject.framebuffers.first.object_id
+    assert_equal Array.new(FB_LENGTH) { 0x00 }, subject.framebuffers[0]
+    assert_equal Array.new(FB_LENGTH) { 0x00 }, subject.framebuffers[1]
+  end
+
+  def test_transform_default_state
+    refute subject.instance_variable_get(:@swap_xy)
+    refute subject.instance_variable_get(:@invert_x)
+    refute subject.instance_variable_get(:@invert_y)
+    assert_equal 0, subject.instance_variable_get(:@rotation)
+  end
+
+  def test_drawing_default_state
+    assert_equal 1, subject.current_color
+    assert_equal 1, subject.font_scale
+  end
+
+  def setup_test_pixels
+    subject.set_pixel x: 0,   y: 0,   color: 1
+    subject.set_pixel x: 1,   y: 1,   color: 2
+    subject.set_pixel x: 14,  y: 14,  color: 1
+    subject.set_pixel x: 15,  y: 15,  color: 2
+  end
+
+  def test_clear
+    setup_test_pixels
+    empty  = Array.new(FB_LENGTH) { 0x00 }
+
+    subject.clear
+    assert_equal empty, subject.framebuffers[0]
+    assert_equal empty,  subject.framebuffers[1]
+  end
+
+  def test_fill
+    empty  = Array.new(FB_LENGTH) { 0x00 }
+    filled = Array.new(FB_LENGTH) { 0xFF }
+
+    subject.fill
+    assert_equal filled, subject.framebuffers[0]
+    assert_equal empty,  subject.framebuffers[1]
+  end
+
+  def test_set_pixel
+    setup_test_pixels
+
+    fb0 = Array.new(FB_LENGTH) { 0 }
+    fb0[0]        = 0b00000001
+    fb0[WIDTH+14] = 0b01000000
+    assert_equal fb0, subject.framebuffers[0]
+
+    fb1 = Array.new(FB_LENGTH) { 0 }
+    fb1[1]        = 0b00000010
+    fb1[WIDTH+15] = 0b10000000
+    assert_equal fb1, subject.framebuffers[1]
+
+    # Setting a pixel in FB 0 (color: 1) clears corresponding bit in FB 1 (color: 2).
+    subject.set_pixel x: 1, y: 1, color: 1
+    assert_equal 0b00000010, subject.framebuffers[0][1]
+    assert_equal 0b00000000, subject.framebuffers[1][1]
+
+    # Setting a pixel to color: 0 clears it in all FBs.
+    subject.set_pixel x: 0, y: 0, color: 0
+    assert_equal 0b00000000, subject.framebuffers[0][0]
+    assert_equal 0b00000000, subject.framebuffers[1][0]
+
+    subject.set_pixel x: 15, y: 15, color: 0
+    assert_equal 0b00000000, subject.framebuffers[0][WIDTH+15]
+    assert_equal 0b00000000, subject.framebuffers[1][WIDTH+15]
+  end
+
+  def test_current_color
+    subject.current_color = 2
+    subject.set_pixel x: 0, y: 0
+    assert_equal 0b00000000, subject.framebuffers[0][0]
+    assert_equal 0b00000001, subject.framebuffers[1][0]
+  end
+
+  def test_get_pixel
+    setup_test_pixels
+    assert_equal 1, subject.get_pixel(x: 0,   y: 0)
+    assert_equal 2, subject.get_pixel(x: 15,  y: 15)
+    assert_equal 0, subject.get_pixel(x: 20,  y: 20)
+  end
+
+  def test_line_single_pixel
+    subject.line x1: 5, y1: 5, x2: 5, y2: 5
+
+    fb0 = Array.new(FB_LENGTH) { 0 }
+    fb0[5] = 0b00100000
+
+    assert_equal fb0, subject.framebuffers[0]
+  end
+
+  LINE_HORIZONTAL_FB = [0, 0, 32, 32, 32, 32, 32, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
+
+  def test_line_horizontal
+    subject.line x1: 2, y1: 5, x2: 6, y2: 5
+    assert_equal LINE_HORIZONTAL_FB, subject.framebuffers[0]
+  end
+
+  LINE_VERTICAL_FB = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 124, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
+
+  def test_line_vertical
+    subject.line x1: 10, y1: 2, x2: 10, y2: 6
+    assert_equal LINE_VERTICAL_FB, subject.framebuffers[0]
+  end
+
+  # 45 degree diagonal lines should produce the same result regardless of which is the start point (x1,y1).
+  LINE_45_FB = [0, 0, 0, 0, 0, 32, 64, 128, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 2, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
+
+  def test_line_45
+    subject.line x1: 5, y1: 5, x2: 10, y2: 10
+    assert_equal LINE_45_FB, subject.framebuffers[0]
+  end
+
+  def test_line_45_swapped
+    subject.line x1: 10, y1: 10, x2: 5, y2: 5
+    assert_equal LINE_45_FB, subject.framebuffers[0]
+  end
+
+  # Non 45 degree diagonals are approximated slightly differently, depending on which point is x1,y1.
+  # This behavior might be useful.
+  # +ve gradients tend to "pull" down and to the left.
+  # -ve gradients tend to "pull" up and to the right.
+  LINE_DIAG_POS_FB = [0, 0, 0, 0, 0, 96, 128, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 2, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
+
+  LINE_DIAG_NEG_FB = [0, 0, 0, 0, 0, 32, 64, 128, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 6, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
+
+  def test_line_diagonal
+    # Note: run and rise not equal.
+    subject.line x1: 5, y1: 5, x2: 8, y2: 10
+    assert_equal LINE_DIAG_POS_FB, subject.framebuffers[0]
+  end
+
+  def test_line_diagonal_swapped
+    # Note: run and rise not equal.
+    subject.line x1: 8, y1: 10, x2: 5, y2: 5
+    assert_equal LINE_DIAG_NEG_FB, subject.framebuffers[0]
+  end
+
+  def test_line_knockout
+    inverted_fb = LINE_DIAG_POS_FB.map { |byte| ~byte & 0xFF }
+
+    subject.fill
+    subject.line x1: 5, y1: 5, x2: 8, y2: 10, color: 0
+    assert_equal inverted_fb, subject.framebuffers[0]
+  end
+
+  RECTANGLE_FB = [0, 0, 0, 0, 0, 224, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 224, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 127, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 127, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
+
+  def test_rectangle1
+    subject.rectangle x1: 5, y1: 5, x2: 19, y2: 14
+    assert_equal RECTANGLE_FB, subject.framebuffers[0]
+  end
+
+  def test_rectangle2
+    # w is x2-x1+1 (15) from previous, since first pixel counts
+    # h ix y2-y1+1 (10) from previous, since first pixel counts
+    subject.rectangle x: 5, y: 5, w: 15, h: 10
+    assert_equal RECTANGLE_FB, subject.framebuffers[0]
+  end
+
+  def test_rectangle3
+    # -ve values should produce the same rectangles
+    subject.rectangle x: 19, y: 14, w: -15, h: -10
+    assert_equal RECTANGLE_FB, subject.framebuffers[0]
+  end
+
+  SQUARES_FB = [0, 0, 0, 0, 0, 224, 224, 96, 96, 96, 96, 96, 96, 224, 224, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 127, 127, 96, 96, 96, 96, 96, 96, 127, 127, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
+
+  def test_layered_squares
+    subject.square x: 5, y: 5, size: 10, filled: true, color: 1
+    subject.square x: 7, y: 7, size: 6,  filled: true, color: 0
+    assert_equal SQUARES_FB, subject.framebuffers[0]
+  end
+
+  PATH_FB = [3, 4, 24, 32, 192, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 128, 64, 224, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 2, 4, 4, 8, 16, 32, 32, 64, 128, 128, 64, 48, 8, 4, 3, 0, 0, 1, 14, 112, 128, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 28, 224, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 7, 56, 64]
+
+  def path_points
+     [ [0,0], [7,10], [15, 16], [23,5], [31, 30] ]
+  end
+
+  def test_path
+    subject.path path_points, color: 2
+    assert_equal PATH_FB, subject.framebuffers[1]
+  end
+
+  def test_path_knockout
+    inverted_fb = PATH_FB.map { |byte| ~byte & 0xFF }
+
+    subject.fill
+    subject.path path_points, color: 0
+    assert_equal inverted_fb, subject.framebuffers[0]
+  end
+
+  TRIANGLE_FB = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 128, 96, 24, 6, 12, 48, 192, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 128, 96, 24, 6, 193, 240, 124, 31, 62, 248, 224, 131, 12, 48, 192, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 128, 96, 24, 6, 129, 224, 120, 31, 7, 1, 0, 0, 0, 0, 3, 15, 62, 240, 192, 3, 12, 48, 192, 0, 0, 0, 0, 0, 128, 224, 152, 134, 129, 128, 152, 158, 159, 159, 158, 158, 158, 158, 158, 158, 158, 158, 158, 158, 158, 159, 159, 159, 156, 128, 128, 131, 140, 176, 192]
+
+  def triangle_points
+    [
+      [ [1,31],  [31,31], [16,1]  ],
+      [ [7,28],  [25,28], [16,8]  ],
+      [ [11,24], [21,24], [16,13] ],
+    ]
+  end
+
+  def test_polygon
+    subject.polygon triangle_points[0]
+    subject.polygon triangle_points[1], filled: true
+    subject.polygon triangle_points[2], filled: true, color: 0
+    assert_equal TRIANGLE_FB, subject.framebuffers[0]
+  end
+
+  def test_triangle
+    t = triangle_points
+    subject.triangle x1: t[0][0][0], y1: t[0][0][1], x2: t[0][1][0], y2: t[0][1][1], x3: t[0][2][0], y3: t[0][2][1]
+    subject.triangle x1: t[1][0][0], y1: t[1][0][1], x2: t[1][1][0], y2: t[1][1][1], x3: t[1][2][0], y3: t[1][2][1], filled: true
+    subject.triangle x1: t[2][0][0], y1: t[2][0][1], x2: t[2][1][0], y2: t[2][1][1], x3: t[2][2][0], y3: t[2][2][1], filled: true, color: 0
+    assert_equal TRIANGLE_FB, subject.framebuffers[0]
+  end
+
+  ELLIPSE_CIRCLE_FB = [0, 0, 128, 192, 224, 240, 120, 60, 28, 30, 142, 142, 71, 71, 71, 71, 71, 71, 71, 142, 142, 30, 28, 60, 120, 240, 224, 192, 128, 0, 0, 0, 240, 254, 255, 15, 3, 224, 24, 4, 2, 1, 224, 24, 6, 2, 1, 1, 1, 2, 6, 24, 224, 1, 2, 4, 24, 224, 3, 15, 255, 254, 240, 0, 7, 63, 255, 248, 224, 131, 12, 16, 32, 64, 131, 140, 48, 32, 64, 64, 64, 32, 48, 140, 131, 64, 32, 16, 12, 131, 224, 248, 255, 63, 7, 0, 0, 0, 0, 1, 3, 7, 15, 30, 28, 60, 56, 56, 113, 113, 113, 113, 113, 113, 113, 56, 56, 60, 28, 30, 15, 7, 3, 1, 0, 0, 0, 0]
+
+  def test_ellipse_circle
+    subject.circle x: 15, y: 15, r: 15, filled: true
+    subject.circle x: 15, y: 15, r: 12, filled: true, color: 0
+    subject.ellipse x: 15, y: 15, a: 10, b: 9
+    subject.ellipse x: 15, y: 15, a: 5,  b: 7
+    assert_equal ELLIPSE_CIRCLE_FB, subject.framebuffers[0]
+  end
+
+  TEXT_FB = [0, 0, 1, 1, 127, 1, 1, 0, 56, 84, 84, 84, 24, 0, 72, 84, 84, 84, 32, 0, 4, 63, 68, 64, 32, 0, 0, 0, 47, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 223, 223, 31, 223, 223, 255, 255, 127, 127, 127, 255, 255, 255, 127, 127, 127, 255, 255, 127, 31, 127, 255, 255, 255, 255, 255, 31, 255, 255, 255, 255, 255, 255, 255, 240, 255, 255, 255, 248, 245, 245, 245, 252, 255, 246, 245, 245, 245, 251, 255, 255, 248, 247, 247, 251, 255, 255, 255, 250, 255, 255, 255]
+
+  def test_text
+    # Regular text
+    subject.text_cursor = 1,7
+    subject.text "Test!"
+
+    # Fill bottom half
+    subject.rectangle x1: 0, y1: 16, x2: 31, y2: 31, filled: true
+
+    # Knockout text
+    subject.text_cursor = 1,28
+    subject.text "Test!", color: 0
+    assert_equal TEXT_FB, subject.framebuffers[0]
+  end
+
+  ROTATE_FB = [0, 124, 18, 17, 18, 124, 0, 127, 73, 73, 73, 54, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 34, 34, 62, 34, 34, 20, 8, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 16, 40, 68, 68, 124, 68, 68, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 62, 72, 136, 72, 62, 0]
+
+  def test_rotate
+    4.times do
+      subject.text_cursor = 0,7
+      subject.text "A"
+      subject.rotate(90)
+    end
+    subject.text_cursor = 6,7
+    subject.text "B"
+    assert_equal ROTATE_FB, subject.framebuffers[0]
+  end
+
+  REFLECT_FB = [0, 124, 18, 17, 18, 124, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 70, 41, 25, 9, 127, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 254, 144, 144, 144, 96, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
+
+  def test_reflect
+    # Horizontally flipped, top right
+    subject.reflect(:x)
+    subject.text_cursor = 0,7
+    subject.text "R"
+    subject.reflect(:x)
+
+    # Vertically flipped, bottom left
+    subject.reflect(:y)
+    subject.text_cursor = 0,7
+    subject.text "P"
+    subject.reflect(:y)
+
+    # Restored
+    subject.text_cursor = 0,7
+    subject.text "A"
+    assert_equal REFLECT_FB, subject.framebuffers[0]
+  end
+
+  FONT_8X16_FB = [0, 0, 255, 255, 192, 192, 192, 192, 192, 192, 255, 255, 0, 0, 0, 0, 48, 48, 243, 243, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 0, 0, 63, 63, 0, 0, 0, 0, 0, 0, 63, 63, 0, 0, 0, 0, 48, 48, 63, 63, 48, 48, 0, 0, 0, 0, 0, 0, 0, 0, 12, 12, 24, 8, 8, 248, 8, 8, 24, 0, 8, 248, 136, 136, 232, 8, 16, 0, 0, 112, 136, 8, 8, 8, 56, 0, 24, 8, 8, 248, 8, 8, 24, 0, 0, 0, 32, 63, 32, 0, 0, 0, 32, 63, 32, 32, 35, 32, 24, 0, 0, 56, 32, 33, 33, 34, 28, 0, 0, 0, 32, 63, 32, 0, 0, 0]
+
+  def test_font
+    subject.text_cursor = 0,31
+    subject.font = :bmp_8x16
+    subject.text "TEST"
+
+    subject.text_cursor = 0,15
+    subject.font = :bmp_6x8
+    subject.font_scale = 2
+    subject.text "Hi!"
+  end
+end

data/test/display/hd44780_test.rb

@@ -7,18 +7,45 @@ class HD44780Test < Minitest::Test
 
   def part
     @part ||= Denko::Display::HD44780.new cols: 16, rows: 2,
-                                            board: board,
-                                            pins: { rs: 8, enable: 9,
-                                                    d4: 4, d5: 5, d6: 6, d7: 7 }
+                                          board: board,
+                                          pins: {
+                                                  rs: 8, enable: 9,
+                                                  d4: 4, d5: 5, d6: 6, d7: 7
+                                                }
   end
-  
+
   def test_pin_validation
     # Only given one pin out of d0-d3.
     assert_raises do
       Denko::Display::HD44780.new board: board, pins: { rs: 12, enable: 11,
-                                                      d4: 5, d5: 4, d6: 3, d7: 2, d3: 1 }
-    
-    end 
+                                                        d4: 5, d5: 4, d6: 3, d7: 2, d3: 1
+                                                      }
+
+    end
+  end
+
+  def test_rw
+    @part = Denko::Display::HD44780.new cols: 16, rows: 2,
+                                        board: board,
+                                        pins: {
+                                                rs: 8, enable: 9, rw: 3,
+                                                d4: 4, d5: 5, d6: 6, d7: 7
+                                              }
+
+    assert_equal board.low, @part.rw.state
+  end
+
+
+  def test_backlight
+    @part = Denko::Display::HD44780.new cols: 16, rows: 2,
+                                        board: board,
+                                        pins: {
+                                                rs: 8, enable: 9, backlight: 3,
+                                                d4: 4, d5: 5, d6: 6, d7: 7
+                                              }
+
+    assert_equal Denko::LED::Base, @part.backlight.class
+    assert_equal board.high,       @part.backlight.state
   end
 
   def test_write4

data/test/eeprom/board_test.rb

@@ -0,0 +1,45 @@
+require_relative '../test_helper'
+
+class BoardMock < Denko::Board
+  # Fake EEPROM
+  def eeprom_stub
+    @eeprom_stub ||= Array.new(eeprom_length){255}
+  end
+
+  def eeprom_read(start_address, length)
+    # Pack it up like a string coming from the board and update.
+    string = eeprom_stub[start_address, length].map{ |x| x.to_s }.join(",")
+    self.update("254:#{start_address}-#{string}\n")
+  end
+
+  def eeprom_write(start_address, bytes)
+    eeprom_stub[start_address, bytes.length] = bytes
+  end
+end
+
+class EEPROMBoardTest < Minitest::Test
+  def board
+    @board ||= BoardMock.new
+  end
+
+  def part
+    @part ||= board.eeprom
+  end
+
+  def test_pin_ee
+    assert_equal part.pin, 254
+  end
+
+  def test_individual_read_write
+    assert_equal 255, part[20]
+    part[20] = 111
+    assert_equal 111, part[20]
+  end
+
+  def test_range_read_write
+    data = [15, 23, 50, 12, 11]
+    index = 11
+    part[index] = data
+    assert_equal data, part[index..(index+data.length-1)]
+  end
+end

data/test/helpers/mruby_minitest.rb

@@ -0,0 +1,95 @@
+# Minimal implementation of Minitest for mruby.
+# Only handles #assert, #refute, and #assert_equal.
+module Minitest
+  class AssertionError < StandardError
+  end
+
+  class Test
+    @@test_count = 0
+    @@failures   = []
+    @@errors     = []
+    @@assertions = 0
+
+    def self.run_all_tests
+      @@start_time = Time.now
+
+      test_classes = []
+      ObjectSpace.each_object(Class) do |klass|
+        test_classes << klass if (klass < Minitest::Test && klass != Minitest::Test)
+      end
+
+      test_classes.each { |c| c.run_tests }
+
+      @@finish_time = Time.now
+
+      report_results
+    end
+
+    def self.run_tests
+      test_methods = instance_methods.select { |method| method.to_s.start_with?("test_") }
+
+      test_methods.each do |test_method|
+        @@test_count += 1
+        test_instance = new
+
+        begin
+          test_instance.setup if test_instance.respond_to?(:setup)
+          test_instance.send(test_method)
+          print "."
+        rescue => e
+          if e.is_a?(AssertionError)
+            @@failures << "#{self.name}##{test_method}: #{e.message}"
+            print "F"
+          else
+            @@errors << "#{self.name}##{test_method}: #{e.class} - #{e.message}"
+            print "E"
+          end
+        ensure
+          begin
+            test_instance.teardown if test_instance.respond_to?(:teardown)
+          rescue => e
+            @@errors << "#{self.name}##{test_method} (teardown): #{e.class} - #{e.message}"
+          end
+        end
+      end
+    end
+
+    def self.report_results
+      puts "\n\nFinished in #{(@@finish_time - @@start_time).round(6)}s"
+
+      puts "#{@@test_count} tests, #{@@assertions} assertions, #{@@failures.length} failures, #{@@errors.length} errors"
+
+      unless @@failures.empty?
+        puts "\nFailures:"
+        @@failures.each_with_index do |failure, i|
+          puts "#{i + 1}) #{failure}"
+        end
+      end
+
+      unless @@errors.empty?
+        puts "\nErrors:"
+        @@errors.each_with_index do |error, i|
+          puts "#{i + 1}) #{error}"
+        end
+      end
+    end
+
+    def assert(condition, message = "Assertion failed")
+      @@assertions += 1
+      raise AssertionError.new(message) unless condition
+    end
+
+    def refute(condition, message = "Refutation failed - expected falsy value")
+      @@assertions += 1
+      raise AssertionError.new(message) if condition
+    end
+
+    def assert_equal(expected, actual, message = nil)
+      @@assertions += 1
+      unless expected == actual
+        msg = message || "Expected #{expected.inspect}, got #{actual.inspect}"
+        raise AssertionError.new(msg)
+      end
+    end
+  end
+end

data/test/helpers/mruby_runner.rb

@@ -0,0 +1,13 @@
+# Stub out require_relative to avoid issues.
+def require_relative(*args)
+end
+
+# Load minimal Minitest clone for mruby.
+minitest_source = "#{File.dirname(__FILE__)}/mruby_minitest.rb"
+eval(File.read(minitest_source))
+
+# Test Display::Canvas.
+canvas_test = "#{File.dirname(__FILE__)}/../display/canvas_test.rb"
+eval(File.read(canvas_test))
+
+Minitest::Test.run_all_tests

data/test/i2c/bus_test.rb

@@ -9,74 +9,137 @@ class I2CBusTest < Minitest::Test
     @board ||= BoardMock.new
   end
 
-  def part
-    @part ||= Denko::I2C::Bus.new(board: board)
+  def bus
+    @bus ||= Denko::I2C::Bus.new(board: board)
   end
 
   def peripheral
-    @peripheral ||= I2CPeripheralBase.new(bus: part, address: 0x30)
+    @peripheral ||= I2CPeripheralBase.new(bus: bus, address: 0x30)
   end
 
   def test_initialize
-    assert_equal part.found_devices, []
-    assert_equal 0, part.i2c_index
-    refute_nil part.callbacks[:bus_controller]
+    assert_equal [],  bus.found_devices
+    assert_equal 0,   bus.i2c_index
+    refute_nil bus.callbacks[:bus_controller]
 
-    part2 = Denko::I2C::Bus.new(board: board, index: 10)
-    assert_equal 10, part2.i2c_index
-
-    part3 = Denko::I2C::Bus.new(board: board, i2c_index: 11)
-    assert_equal 11, part3.i2c_index
+    bus2 = Denko::I2C::Bus.new(board: board, index: 10)
+    assert_equal 10, bus2.i2c_index
   end
 
-  def test_search
+  def test_search_result_string
     # Reject 0s created by leading and trailing colons.
-    board.inject_read_for_i2c(0, ":48:50:")
+    board.inject_component_update(bus, ":48:50:")
+    bus.search
+    assert_equal [0x30, 0x32], bus.found_devices
+  end
 
-    mock = Minitest::Mock.new.expect :call, nil, [0]
-    board.stub(:i2c_search, mock) do
-      part.search
-    end
-    mock.verify
+  def test_search_resul_array
+    board.inject_component_update(bus, [0, 0x30, 0x32])
+    bus.search
+    assert_equal [0x30, 0x32], bus.found_devices
+  end
 
-    assert_equal part.found_devices, [0x30, 0x32]
+  def test_search_result_empty
+    board.inject_component_update(bus, ":")
+    bus.search
+    assert_equal [], bus.found_devices
   end
 
   def test_write
     mock = Minitest::Mock.new.expect :call, nil, [0, 0x30, [0x01, 0x02], 100000, false]
+
     board.stub(:i2c_write, mock) do
-      part.write 0x30, [0x01, 0x02]
+      bus.write 0x30, [0x01, 0x02]
     end
     mock.verify
   end
 
-  def test__read_string
-    board.inject_read_for_i2c(0, "48-255,0,255,0,255,0")
+  def test_read_string
+    board.inject_component_update(bus, "48-255,0,255,0,255,0")
+    mock = Minitest::Mock.new.expect :call, nil, [0, 0x32, 0x03, 6, 100000, false]
 
+    board.stub(:i2c_read, mock) do
+      bus.read 0x32, 0x03, 6
+    end
+    mock.verify
+  end
+
+  def test_read_array
+    board.inject_component_update(bus, [48,255,0,255,0,255,0])
     mock = Minitest::Mock.new.expect :call, nil, [0, 0x32, 0x03, 6, 100000, false]
+
     board.stub(:i2c_read, mock) do
-      part.read 0x32, 0x03, 6
+      bus.read 0x32, 0x03, 6
     end
     mock.verify
   end
 
-  def test__read_array
-    board.inject_read_for_i2c(0, [48,255,0,255,0,255,0])
+  def test_read_without_register
+    board.inject_component_update(bus, "48-255,127")
+    mock = Minitest::Mock.new.expect :call, nil, [0, 0x30, nil, 2, 100000, false]
 
-    mock = Minitest::Mock.new.expect :call, nil, [0, 0x32, 0x03, 6, 100000, false]
     board.stub(:i2c_read, mock) do
-      part.read 0x32, 0x03, 6
+      bus.read 0x30, nil, 2
+    end
+    mock.verify
+  end
+
+  def test_updates_peripherals_string
+    mock = Minitest::Mock.new.expect :call, nil, [[255, 127]]
+
+    peripheral.stub(:update, mock) do
+      bus.send(:update, "48-255,127")
+      bus.send(:update, "50-128,0")
     end
     mock.verify
   end
 
-  def test_updates_peripherals
+  def test_updates_peripherals_array
     mock = Minitest::Mock.new.expect :call, nil, [[255, 127]]
 
     peripheral.stub(:update, mock) do
-      part.send(:update, "48-255,127")
-      part.send(:update, "50-128,0")
+      bus.send(:update, [0x30, 255, 127])
+      bus.send(:update, [0x32, 128, 0])
+    end
+    mock.verify
+  end
+
+  def test_ignores_updates_for_non_matching_addresses
+    # mock should not receive any calls
+    mock = Minitest::Mock.new
+
+    peripheral.stub(:update, mock) do
+      bus.send(:update, "49-255,127")
     end
     mock.verify
   end
+
+  def test_handles_empty_data_gracefully
+    bus.send(:update, "48-")
+    bus.send(:update, "48")
+  end
+
+  def test_handles_malformed_string_data
+    bus.send(:update, "invalid-data")
+    bus.send(:update, "")
+    bus.send(:update, nil)
+  end
+
+  def test_same_address_fails
+    peripheral
+    assert_raises { I2CPeripheralBase.new(bus: bus, address: 0x30) }
+  end
+
+  # Should split up Subcomponents behavior and test there?
+  def test_component_management
+    count = bus.components.length
+    new_peripheral = I2CPeripheralBase.new(bus: bus, address: 0x40)
+
+    assert_equal count+1, bus.components.length
+    assert_includes bus.components, new_peripheral
+  end
+
+  def test_found_devices_not_writable
+    assert_raises { bus.found_devices = nil }
+  end
 end