Merge pull request #75 from boydm/boyd

Add missing tests

Author: boydm

test/scenic/math/matrix_test.exs

@@ -384,6 +384,11 @@ defmodule Scenic.Math.MatrixTest do
     assert Matrix.rotate(mx_trans, 1.3) == Matrix.mul(mx_trans, mx_rot)
   end
 
+  test "rotate does nothing with nil" do
+    mx_trans = Matrix.build_translation({123, 456})
+    assert Matrix.rotate(mx_trans, nil) == mx_trans
+  end
+
   test "translate translates a matrix" do
     mx_trans = Matrix.build_translation({123, 456})
     mx_rot = Matrix.build_rotation(1.3)

test/scenic/primitive/quad_test.exs

@@ -81,4 +81,32 @@ defmodule Scenic.Primitive.QuadTest do
     assert Quad.contains_point?(@convex, {400, 520}) == false
     assert Quad.contains_point?(@convex, {100, 520}) == false
   end
+
+  # ============================================================================
+  # expand
+
+  # only works if it is square...
+  defp quad_square_area({{x0, y0}, {x1, _}, {_, y2}, _}) do
+    w = abs(x1 - x0) * 1.0
+    h = abs(y2 - y0) * 1.0
+    w * h
+  end
+
+  test "expand clockwise works" do
+    quad = {{10, 10}, {20, 10}, {20, 20}, {10, 20}}
+    expanded = Quad.expand(quad, 2)
+    shrunk = Quad.expand(quad, -2)
+
+    assert quad_square_area(expanded) > quad_square_area(quad)
+    assert quad_square_area(shrunk) < quad_square_area(quad)
+  end
+
+  test "expand counter-clockwise works" do
+    quad = {{10, 20}, {20, 20}, {20, 10}, {10, 10}}
+    expanded = Quad.expand(quad, 2)
+    shrunk = Quad.expand(quad, -2)
+
+    assert quad_square_area(expanded) > quad_square_area(quad)
+    assert quad_square_area(shrunk) < quad_square_area(quad)
+  end
 end

test/scenic/primitive/sector_test.exs

@@ -54,13 +54,21 @@ defmodule Scenic.Primitive.SectorTest do
 
   # ============================================================================
   # point containment
-  test "contains_point? always returns false" do
+  test "contains_point? works (clockwise)" do
     assert Sector.contains_point?(@data, {20, 32}) == true
     assert Sector.contains_point?(@data, {-20, 32}) == false
     assert Sector.contains_point?(@data, {30, 60}) == true
     assert Sector.contains_point?(@data, {130, 280}) == false
   end
 
+  test "contains_point? works (counter-clockwise)" do
+    data = {100, 1.4, 0.0}
+    assert Sector.contains_point?(data, {20, 32}) == true
+    assert Sector.contains_point?(data, {-20, 32}) == false
+    assert Sector.contains_point?(data, {30, 60}) == true
+    assert Sector.contains_point?(data, {130, 280}) == false
+  end
+
   test "contains_point? straight up and down" do
     # make it big enough to catch the straight down case
     data = {100, 0.0, 2}

test/scenic/primitive/style/paint/color_test.exs

@@ -1,9 +1,13 @@
 defmodule Scenic.Primitive.Style.Paint.ColorTest do
-  @moduledoc false
   use ExUnit.Case, async: true
 
   import Scenic.Primitive.Style.Paint.Color
 
+  test "to_rgba with numbers" do
+    assert to_rgba({1, 2, 3}) == {1, 2, 3, 0xFF}
+    assert to_rgba({1, 2, 3, 4}) == {1, 2, 3, 4}
+  end
+
   test "to_rgba/1" do
     assert to_rgba({:transparent, nil}) == to_rgba(:transparent)
     assert to_rgba({:clear, nil}) == to_rgba(:transparent)

test/scenic/primitive/style/paint/image_test.exs

@@ -0,0 +1,17 @@
+defmodule Scenic.Primitive.Style.Paint.ImageTest do
+  use ExUnit.Case, async: true
+
+  alias Scenic.Primitive.Style.Paint.Image
+
+  test "normalize works with just a hash_key to the image" do
+    assert Image.normalize("hash_string") == {"hash_string", 0, 0, 0, 0, 0, 0xFF}
+  end
+
+  test "normalize works with just a hash_key and alpha" do
+    assert Image.normalize({"hash_string", 128}) == {"hash_string", 0, 0, 0, 0, 0, 128}
+  end
+
+  test "normalize works with everything set" do
+    assert Image.normalize({"hash_string", 1, 2, 3, 4, 5, 6}) == {"hash_string", 1, 2, 3, 4, 5, 6}
+  end
+end

test/scenic/primitive/transform_test.exs

@@ -29,6 +29,19 @@ defmodule Scenic.Primitive.TransformTest do
     matrix: @mx
   }
 
+  # ============================================================================
+  # verify!
+
+  test "verify! works" do
+    assert Transform.verify!(:pin, {1, 1})
+  end
+
+  test "verify! rejects invalid transform types" do
+    assert_raise Scenic.Primitive.Transform.FormatError, fn ->
+      assert Transform.verify!(:invalid, {1, 1})
+    end
+  end
+
   # ============================================================================
   # calculate the local matrix