reflexion 0.1.6 → 0.1.7

data/test/test_view.rb

@@ -6,69 +6,143 @@ require_relative 'helper'
 
 class TestView < Test::Unit::TestCase
 
-  def view (*args)
-    Reflex::View.new *args
+  V = Reflex::View
+
+  def view (*args, &block)
+    V.new *args, &block
+  end
+
+  def style (*args, &block)
+    Reflex::Style.new *args, &block
+  end
+
+  def selector (*args, &block)
+    Reflex::Selector.new *args, &block
   end
 
+  def point  (*args) Reflex::Point.new *args end
+  def bounds (*args) Reflex::Bounds.new *args end
+
   def test_initialize ()
-    assert_equal '', view.name
+    assert_equal nil, view.name
     assert_equal 'Test', view(:name => 'Test').name
   end
 
   def test_hidden ()
     v = view
-    assert_equal false, v.hidden
+    assert_equal false, v.hidden?
     v.hide
-    assert_equal true, v.hidden
+    assert_equal true, v.hidden?
     v.show
-    assert_equal false, v.hidden
+    assert_equal false, v.hidden?
   end
 
   def test_hidden_count ()
     v = view
     v.show
-    assert_equal false, v.hidden
+    assert_equal false, v.hidden?
     v.hide
-    assert_equal false, v.hidden
+    assert_equal false, v.hidden?
     v.hide
-    assert_equal true, v.hidden
+    assert_equal true, v.hidden?
   end
 
   def test_add_child ()
     assert_raise(ArgumentError) {view.add_child}
-    assert_raise(ArgumentError) {view.add_child nil}
-    assert_raise(ArgumentError) {view.add_child 1}
-    assert_nothing_raised {view.add_child view}
+    assert_raise(TypeError) {view.add_child nil}
+    assert_raise(TypeError) {view.add_child 1}
+    v = view
+    assert_raise(ArgumentError) {v.add_child v}
+    assert_nothing_raised {v.add_child view}
   end
 
   def test_remove_child ()
     assert_raise(ArgumentError) {view.remove_child}
-    assert_raise(ArgumentError) {view.remove_child nil}
-    assert_raise(ArgumentError) {view.remove_child 1}
-    assert_raise(Rucy::NativeError) {view.remove_child view}
+    assert_raise(TypeError) {view.remove_child nil}
+    assert_raise(TypeError) {view.remove_child 1}
+    assert_nothing_raised {view.remove_child view}
     v = view
+    assert_raise(ArgumentError) {v.remove_child v}
     v.add_child child = view
     assert_nothing_raised {v.remove_child child}
   end
 
-  def test_find_child ()
+  def test_find_children ()
     v = view
     v.add_child child = view(:name => :Test)
-    assert_equal child, v.find_child(:Test)
+    assert_equal [child], v.find_children(:Test)
   end
 
-  def test_parent ()
-    parent, child = view, view
-    parent.add_child child
-    assert_nil parent.parent
-    assert_equal parent, child.parent
+  def test_children ()
+    me = self
+    v = view
+    v.add view{set name: '1'}
+    v.add view{set name: '2'; add me.view{set name: '2/1'}}
+    assert_equal %w[1 2], v.children.map(&:name)
+  end
+
+  def test_style ()
+    v = view
+    s = v.style
+    assert_equal 0,   s.margin.left.value
+    assert_equal nil, s.margin.left.unit
+    assert ((s.margin.left.to_s rescue $!.message)) =~ /InvalidStateError/
+    s.margin.left = '100px'
+    assert_equal 100,     s.margin.left.value
+    assert_equal :px,     s.margin.left.unit
+    assert_equal '100px', s.margin.left.to_s
+  end
+
+  def test_add_remove_style ()
+    v = view
+    s = style(name: :N)
+    v.add_style s
+    assert_includes     v.find_styles(selector name: :N), s
+    v.remove_style s
+    assert_not_includes v.find_styles(selector name: :N), s
   end
 
   def test_name ()
     v = view
-    assert_equal '', v.name
+    assert_equal nil, v.name
     v.name = 'Test'
     assert_equal 'Test', v.name
   end
 
+  def test_frame ()
+    v = view
+    b = v.frame.dup
+    assert_equal b, v.frame
+
+    v.frame =  1;                 assert_equal [0, 0,    1, 1],     v.frame.to_a
+    v.frame =  1.5;               assert_equal [0, 0,    1.5, 1.5], v.frame.to_a
+    v.frame = [1];                assert_equal [0, 0,    1, 1],     v.frame.to_a
+    v.frame = [1, 2];             assert_equal [0, 0,    1, 2],     v.frame.to_a
+    v.frame = [1, 2, 3];          assert_equal [0, 0,    1, 2],     v.frame.to_a
+    v.frame = [1, 2, 3];          assert_equal [0, 0, 0, 1, 2, 3],  v.frame.to_a(3)
+    v.frame = [1, 2, 3, 4];       assert_equal [1, 2,    3, 4],     v.frame.to_a
+    v.frame = [1, 2, 3, 4];       assert_equal [1, 2, 0, 3, 4, 0],  v.frame.to_a(3)
+    v.frame = [1, 2, 3, 4, 5, 6]; assert_equal [1, 2,    4, 5],     v.frame.to_a
+    v.frame = [1, 2, 3, 4, 5, 6]; assert_equal [1, 2, 3, 4, 5, 6],  v.frame.to_a(3)
+
+    v.frame =  point(1);                        assert_equal [0, 0,    1, 1],    v.frame.to_a
+    v.frame = [point(1)];                       assert_equal [0, 0,    1, 1],    v.frame.to_a
+    v.frame =  point(1, 2);                     assert_equal [0, 0,    1, 2],    v.frame.to_a
+    v.frame = [point(1, 2)];                    assert_equal [0, 0,    1, 2],    v.frame.to_a
+    v.frame = [point(1, 2),    point(3, 4)];    assert_equal [1, 2,    3, 4],    v.frame.to_a
+    v.frame = [point(1, 2),    point(3, 4)];    assert_equal [1, 2, 0, 3, 4, 0], v.frame.to_a(3)
+    v.frame = [point(1, 2, 3), point(4, 5, 6)]; assert_equal [1, 2,    4, 5],    v.frame.to_a
+    v.frame = [point(1, 2, 3), point(4, 5, 6)]; assert_equal [1, 2, 3, 4, 5, 6], v.frame.to_a(3)
+
+    v.frame =  bounds(1, 2, 3, 4, 5, 6);  assert_equal [1, 2, 3, 4, 5, 6], v.frame.to_a(3)
+    v.frame = [bounds(1, 2, 3, 4, 5, 6)]; assert_equal [1, 2, 3, 4, 5, 6], v.frame.to_a(3)
+  end
+
+  def test_parent ()
+    parent, child = view, view
+    parent.add_child child
+    assert_nil parent.parent
+    assert_equal parent, child.parent
+  end
+
 end# TestView

data/test/test_window.rb

@@ -6,65 +6,73 @@ require_relative 'helper'
 
 class TestWindow < Test::Unit::TestCase
 
-  def setup ()
-    @w = Reflex::Window.new
+  def win (*args, &block)
+    Reflex::Window.new *args, &block
   end
 
-  def teardown ()
-    @w.close
-  end
+  def point  (*args) Reflex::Point.new *args end
+  def bounds (*args) Reflex::Bounds.new *args end
 
-  def test_hidden ()
-    assert_equal true, @w.hidden
-    @w.show
-    assert_equal false, @w.hidden
-    @w.hide
-    assert_equal true, @w.hidden
+  def test_root ()
+    w = win
+    assert_not_nil w.root
+    assert_nil     w.root.parent
+    assert_equal 'ROOT', w.root.name
   end
 
-  def test_hidden_count ()
-    @w.hide
-    assert_equal true, @w.hidden
-    @w.show
-    assert_equal true, @w.hidden
-    @w.show
-    assert_equal false, @w.hidden
+  def test_window ()
+    w = win
+    assert_equal w, w.root.window
   end
 
-  def test_title ()
-    assert_equal '', @w.title
-    @w.title = 'test title'
-    assert_equal 'test title', @w.title
+  def test_hidden ()
+    w = win
+    assert_equal true, w.hidden
+    w.show
+    assert_equal false, w.hidden
+    w.hide
+    assert_equal true, w.hidden
+    w.hide
+    assert_equal true, w.hidden
+    w.show
+    assert_equal true, w.hidden
+    w.show
+    assert_equal false, w.hidden
   end
 
-  def test_root ()
-    assert_not_nil @w.root
-    assert_nil     @w.root.parent
-    assert_equal 'root', @w.root.name
-  end
+  def test_frame ()
+    w = win
+    b = w.frame.dup
+    assert_equal b, w.frame
 
-  def test_window ()
-    assert_equal @w, @w.root.window
-  end
+    w.frame =  1;                 assert_equal [0, 0,    1, 1],     w.frame.to_a
+    w.frame = [1];                assert_equal [0, 0,    1, 1],     w.frame.to_a
+    w.frame = [1, 2];             assert_equal [0, 0,    1, 2],     w.frame.to_a
+    w.frame = [1, 2, 3];          assert_equal [0, 0,    1, 2],     w.frame.to_a
+    w.frame = [1, 2, 3];          assert_equal [0, 0, 0, 1, 2, 0],  w.frame.to_a(3)
+    w.frame = [1, 2, 3, 4];       assert_equal [1, 2,    3, 4],     w.frame.to_a
+    w.frame = [1, 2, 3, 4];       assert_equal [1, 2, 0, 3, 4, 0],  w.frame.to_a(3)
+    w.frame = [1, 2, 3, 4, 5, 6]; assert_equal [1, 2,    4, 5],     w.frame.to_a
+    w.frame = [1, 2, 3, 4, 5, 6]; assert_equal [1, 2, 0, 4, 5, 0],  w.frame.to_a(3)
+
+    w.frame =  point(1);                        assert_equal [0, 0,    1, 1],    w.frame.to_a
+    w.frame = [point(1)];                       assert_equal [0, 0,    1, 1],    w.frame.to_a
+    w.frame =  point(1, 2);                     assert_equal [0, 0,    1, 2],    w.frame.to_a
+    w.frame = [point(1, 2)];                    assert_equal [0, 0,    1, 2],    w.frame.to_a
+    w.frame = [point(1, 2),    point(3, 4)];    assert_equal [1, 2,    3, 4],    w.frame.to_a
+    w.frame = [point(1, 2),    point(3, 4)];    assert_equal [1, 2, 0, 3, 4, 0], w.frame.to_a(3)
+    w.frame = [point(1, 2, 3), point(4, 5, 6)]; assert_equal [1, 2,    4, 5],    w.frame.to_a
+    w.frame = [point(1, 2, 3), point(4, 5, 6)]; assert_equal [1, 2, 0, 4, 5, 0], w.frame.to_a(3)
 
-  def test_move ()
-    b = @w.bounds.to_a
-    @w.move_to 100, 100
-    assert_equal [100, 100], @w.bounds.pos.to_a
-    @w.move_by 5, 5
-    assert_equal [105, 105], @w.bounds.pos.to_a
-    @w.move_by -1, -1
-    assert_equal [104, 104], @w.bounds.pos.to_a
+    w.frame =  bounds(1, 2, 3, 4, 5, 6);  assert_equal [1, 2, 0, 4, 5, 0], w.frame.to_a(3)
+    w.frame = [bounds(1, 2, 3, 4, 5, 6)]; assert_equal [1, 2, 0, 4, 5, 0], w.frame.to_a(3)
   end
 
-  def test_resize ()
-    b = @w.bounds.to_a
-    @w.resize_to 200, 200
-    assert_equal [200, 200], @w.bounds.size.to_a
-    @w.resize_by 5, 5
-    assert_equal [205, 205], @w.bounds.size.to_a
-    @w.resize_by -1, -1
-    assert_equal [204, 204], @w.bounds.size.to_a
+  def test_title ()
+    w = win
+    assert_equal '', w.title
+    w.title = 'A'
+    assert_equal 'A', w.title
   end
 
 end# TestWindow