reflexion 0.1.12 → 0.1.13

data/test/test_shape.rb

@@ -0,0 +1,71 @@
+# -*- coding: utf-8 -*-
+
+
+require_relative 'helper'
+
+
+class TestShape < Test::Unit::TestCase
+
+  def shape (*args, &block)
+    Reflex::RectShape.new *args, &block
+  end
+
+  def test_density ()
+    s = shape
+    assert_equal 0, s.density
+    s.density = 1
+    assert_equal 1, s.density
+    s.density 2
+    assert_equal 2, s.density
+  end
+
+  def test_friction ()
+    s = shape
+    assert_equal 0, s.friction
+    s.friction = 1
+    assert_equal 1, s.friction
+    s.friction 2
+    assert_equal 2, s.friction
+  end
+
+  def test_restitution ()
+    s = shape
+    assert_equal 0, s.restitution
+    s.restitution = 1
+    assert_equal 1, s.restitution
+    s.restitution 2
+    assert_equal 2, s.restitution
+  end
+
+  def test_sensor ()
+    s = shape
+    assert_equal false, s.sensor?
+    s.sensor = true
+    assert_equal true, s.sensor?
+    s.sensor false
+    assert_equal false, s.sensor?
+  end
+
+  def test_category ()
+    s = shape
+    assert_equal 0b1,    s.category_bits
+    s.category_bits  =  0b1010
+    assert_equal 0b1010, s.category_bits
+    s.category_bits |=  0b100
+    assert_equal 0b1110, s.category_bits
+    s.category_bits &= ~0b10
+    assert_equal 0b1100, s.category_bits
+  end
+
+  def test_collision ()
+    s = shape
+    assert_equal 0xffff, s.collision_mask
+    s.collision_mask  =  0b1010
+    assert_equal 0b1010, s.collision_mask
+    s.collision_mask |=  0b100
+    assert_equal 0b1110, s.collision_mask
+    s.collision_mask &= ~0b10
+    assert_equal 0b1100, s.collision_mask
+  end
+
+end# TestShape

data/test/test_style.rb

@@ -10,8 +10,21 @@ class TestStyle < Test::Unit::TestCase
     Reflex::Style.new *args, &block
   end
 
+  def color (*args)
+    Reflex::Color.new *args
+  end
+
+  def setup ()
+    {
+      rgb100: color(1, 0, 0),
+      rgb010: color(0, 1, 0)
+    }.each do |name, col|
+      Rays::Color.set_palette_color name, col
+    end
+  end
+
   def test_initialize ()
-    assert_equal '',  style.name
+    assert_equal nil, style.name
     assert_equal 'A', style(name: :A).name
     assert_equal 'A', style{self.name = :A}.name
   end
@@ -23,16 +36,30 @@ class TestStyle < Test::Unit::TestCase
 
   def test_flow ()
     s = style
+    assert_equal [:none, :none], s.flow
 
+    s.flow =      :right
+    assert_equal [:right, :none], s.flow
+    s.flow =     [:right, :down]
     assert_equal [:right, :down], s.flow
-    s.flow = :up
-    assert_equal [:up, :none],   s.flow
-    s.flow = [:left, :down]
-    assert_equal [:left, :down], s.flow
-    s.flow = :none
-    assert_equal [:none, :none], s.flow
+    s.flow =      :left
+    assert_equal [:left,  :none], s.flow
+    s.flow =      :none
+    assert_equal [:none,  :none], s.flow
+
+    s.flow =      :right
+    assert_equal [:right, :none], s.flow
+    s.flow =      nil
+    assert_equal [:none,  :none], s.flow
+
     assert_raise(ArgumentError) {s.flow = []}
-    assert_raise(ArgumentError) {s.flow = [:down, :right, :none]}
+    assert_raise(ArgumentError) {s.flow = [:none,  :down]}
+    assert_raise(ArgumentError) {s.flow = [:right, :down, :none]}
+  end
+
+  def test_position ()
+    s = style
+    assert_equal [0, 0, 0, 0], s.position.map(&:value)
   end
 
   def test_margin_padding ()
@@ -63,9 +90,48 @@ class TestStyle < Test::Unit::TestCase
 =end
   end
 
-  def test_fill_stroke ()
-    assert_equal [0, 0, 0, 1], style.fill.to_a
-    assert_equal [0, 0, 0, 1], style.stroke.to_a
+  def test_foreground ()
+    s, white, transp = style, color(1, 1, 1, 1), color(0, 0, 0, 0)
+
+    assert_equal white,  s.foreground_fill
+    assert_equal transp, s.foreground_stroke
+
+    assert_equal [white,          transp], s.foreground
+    s.foreground = :rgb100
+    assert_equal [color(1, 0, 0), transp], s.foreground
+    s.foreground = nil
+    assert_equal [white,          transp], s.foreground
+
+    s.foreground  :rgb100
+    assert_equal [color(1, 0, 0), transp],         s.foreground
+    s.foreground  :rgb010,        nil
+    assert_equal [color(0, 1, 0), transp],         s.foreground
+    s.foreground  nil,            :rgb100
+    assert_equal [white,          color(1, 0, 0)], s.foreground
+    s.foreground  :rgb100,        :rgb010
+    assert_equal [color(1, 0, 0), color(0, 1, 0)], s.foreground
+  end
+
+  def test_background ()
+    s, transp = style, color(0, 0, 0, 0)
+
+    assert_equal transp, s.background_fill
+    assert_equal transp, s.background_stroke
+
+    assert_equal [transp,         transp], s.background
+    s.background = :rgb100
+    assert_equal [color(1, 0, 0), transp], s.background
+    s.background = nil
+    assert_equal [transp,         transp], s.background
+
+    s.background  :rgb100
+    assert_equal [color(1, 0, 0), transp],         s.background
+    s.background  :rgb010,        nil
+    assert_equal [color(0, 1, 0), transp],         s.background
+    s.background  nil,            :rgb100
+    assert_equal [transp,         color(1, 0, 0)], s.background
+    s.background  :rgb100,        :rgb010
+    assert_equal [color(1, 0, 0), color(0, 1, 0)], s.background
   end
 
   def test_image ()

data/test/test_style_length.rb

@@ -11,23 +11,52 @@ class TestStyleLength < Test::Unit::TestCase
   end
 
   def test_initialize ()
+    assert_equal nil, len.type
     assert_equal 0,   len.value
-    assert_equal nil, len.unit
-    assert_equal 100, len(100).value
-    assert_equal :px, len(100).unit
-    assert_equal 100, len(100, :px).value
-    assert_equal :px, len(100, :px).unit
-    assert_equal :%,  len(100, :%).unit
-    assert_equal 100, len('100px').value
-    assert_equal :px, len('100px').unit
-    assert_equal :%,  len('100%').unit
+
+    assert_equal nil, len(nil).type
+    assert_equal 0,   len(nil).value
+
+    assert_equal :px,   len(100).type
+    assert_equal 100,   len(100).value
+
+    assert_equal :px,   len('100px').type
+    assert_equal 100,   len('100px').value
+
+    assert_equal :%,    len('100%').type
+    assert_equal 100,   len('100%').value
+
+    assert_equal :fill, len('fill').type
+    assert_equal 1,     len('fill').value
+    assert_equal :fill, len('0.5 fill').type
+    assert_equal 0.5,   len('0.5 fill').value
+    assert_equal 0.5,   len('0.5fill').value
+    assert_equal :fill, len(:fill).type
+
+    assert_equal :fit,  len('fit').type
+    assert_equal 1,     len('fit').value
+    assert_equal :fit,  len(:fit).type
+
+    assert_raise(ArgumentError) {len ''}
+    assert_raise(ArgumentError) {len :px}
+    assert_raise(ArgumentError) {len :%}
+    assert_raise(ArgumentError) {len 'fill0.5'}
+    assert_raise(ArgumentError) {len 'fill 0.5'}
+    assert_raise(ArgumentError) {len '0.5fit'}
+    assert_raise(ArgumentError) {len '0.5 fit'}
+    assert_raise(ArgumentError) {len 'fit0.5'}
+    assert_raise(ArgumentError) {len 'fit 0.5'}
   end
 
   def test_to_s ()
-    assert_equal '100px',  len(100,   :px).to_s
-    assert_equal '100%',   len(100,   :%).to_s
-    assert_equal '100.5%', len(100.5, :%).to_s
-    assert_equal '',       len.to_s
+    assert_equal '',        len.to_s
+    assert_equal '',        len(nil).to_s
+    assert_equal '100px',   len('100px').to_s
+    assert_equal '100%',    len('100%').to_s
+    assert_equal '100.5%',  len('100.5%').to_s
+    assert_equal 'fill',    len('fill').to_s
+    assert_equal 'fit',     len('fit').to_s
+    assert_equal '0.5fill', len('0.5 fill').to_s
   end
 
   def test_inspect ()

data/test/test_view.rb

@@ -7,15 +7,17 @@ require_relative 'helper'
 class TestView < Test::Unit::TestCase
 
   def view (*args, &block)
-    v = Reflex::View.new *args, &block
-    v.on_attach Reflex::Event.new
-    v
+    Reflex::View.new *args, &block
   end
 
   def style (*args, &block)
     Reflex::Style.new *args, &block
   end
 
+  def shape (*args, &block)
+    Reflex::RectShape.new *args, &block
+  end
+
   def selector (*args, &block)
     Reflex::Selector.new *args, &block
   end
@@ -23,11 +25,6 @@ class TestView < Test::Unit::TestCase
   def point  (*args) Rays::Point.new *args end
   def bounds (*args) Rays::Bounds.new *args end
 
-  def test_initialize ()
-    assert_equal nil, view.name
-    assert_equal 'Test', view(:name => 'Test').name
-  end
-
   def test_hidden ()
     v = view
     assert_equal false, v.hidden?
@@ -85,29 +82,108 @@ class TestView < Test::Unit::TestCase
     v = view
     s = v.style
     assert_equal 0,   s.margin_left.value
-    assert_equal nil, s.margin_left.unit
+    assert_equal nil, s.margin_left.type
     assert_equal '',  s.margin_left.to_s
 
     s.margin_left = '100px'
     assert_equal 100,     s.margin_left.value
-    assert_equal :px,     s.margin_left.unit
+    assert_equal :px,     s.margin_left.type
     assert_equal '100px', s.margin_left.to_s
   end
 
   def test_add_remove_style ()
-    v = view
-    s = style(name: :N)
+    v, s = view, style(name: :N)
+    assert_equal 0,     v.styles.to_a.size
+
     v.add_style s
+    assert_equal 1,     v.styles.to_a.size
     assert_includes     v.find_styles(selector name: :N), s
+
     v.remove_style s
+    assert_equal 0,     v.styles.to_a.size
     assert_not_includes v.find_styles(selector name: :N), s
   end
 
+  def test_shape ()
+    s = shape
+    assert_equal 0, s.density
+    s.density =  1
+    assert_equal 1, s.density
+
+    v = view
+    assert_not_equal s, v.shape
+
+    v.shape = s
+    assert_equal s, v.shape
+    assert_equal 1, v.shape.density
+    s.density =  2
+    assert_equal 2, s.density
+    assert_equal 2, v.shape.density
+
+    v.shape =    nil
+    assert_equal nil, v.shape
+    assert_equal 2, s.density
+    assert_equal 0, v.density
+    assert_raise(Rucy::NativeError) {v.density = 3}
+  end
+
+  def test_content_bounds_with_shapes ()
+    v = view
+    assert_equal Reflex::Bounds.invalid, v.content_bounds
+
+    v.shape.resize_to 10, 20
+    assert_equal [10, 20],               v.content_bounds.size.to_a
+
+    v.shape = shape size: [30, 40]
+    assert_equal [30, 40],               v.content_bounds.size.to_a
+
+    v.shape = nil
+    assert_equal Reflex::Bounds.invalid, v.content_bounds
+
+    v.add_shape shape
+    assert_equal Reflex::Bounds.invalid, v.content_bounds
+
+    v.add_shape shape size: [50, 60]
+    assert_equal [50, 60],               v.content_bounds.size.to_a
+
+    v.add_shape shape size: [100, 10]
+    assert_equal [100, 60],              v.content_bounds.size.to_a
+
+    v.add_shape shape frame: [-10, -20, 200, 210]
+    assert_equal [-10, -20, 200, 210],   v.content_bounds.to_a
+  end
+
+  def test_add_remove_shape ()
+    s = shape name: :S
+    s.density =  1
+    assert_equal 1, s.density
+
+    v = view
+    assert_equal 0,     v.shapes.to_a.size
+
+    v.add_shape s
+    assert_equal 1,     v.shapes.to_a.size
+    assert_includes     v.find_shapes(selector name: :S), s
+    assert_equal 1,     v.find_shapes(selector name: :S).first.density
+
+    v.remove_shape s
+    assert_equal 0,     v.shapes.to_a.size
+    assert_not_includes v.find_shapes(selector name: :S), s
+
+    v.add_shape s
+    assert_equal 1,     v.shapes.to_a.size
+    v.clear_shapes
+    assert_equal 0,     v.shapes.to_a.size
+  end
+
   def test_name ()
     v = view
     assert_equal nil, v.name
-    v.name = 'Test'
-    assert_equal 'Test', v.name
+    v.name =     'A'
+    assert_equal 'A', v.name
+    v.name =     :B
+    assert_equal 'B', v.name
+    assert_equal 'C', view(:name => 'C').name
   end
 
   def test_frame ()
@@ -146,4 +222,52 @@ class TestView < Test::Unit::TestCase
     assert_equal parent, child.parent
   end
 
+  def test_density ()
+    v = view
+    assert_equal 0, v.density
+    v.density =  1
+    assert_equal 1, v.density
+    v.density    2
+    assert_equal 2, v.density
+  end
+
+  def test_friction ()
+    v = view
+    assert_equal 0, v.friction
+    v.friction = 1
+    assert_equal 1, v.friction
+    v.friction   2
+    assert_equal 2, v.friction
+  end
+
+  def test_restitution ()
+    v = view
+    assert_equal    0, v.restitution
+    v.restitution = 1
+    assert_equal    1, v.restitution
+    v.restitution   2
+    assert_equal    2, v.restitution
+  end
+
+  def test_sensor ()
+    v = view
+    assert_equal false, v.sensor?
+    v.sensor =   true
+    assert_equal true,  v.sensor?
+    v.sensor     false
+    assert_equal false, v.sensor?
+  end
+
+  def test_category ()
+    p, v = view, view
+    p.add v
+    assert_equal [:all], v.category
+  end
+
+  def test_collision ()
+    p, v = view, view
+    p.add v
+    #assert_equal [:all], v.collision
+  end
+
 end# TestView