ray 0.0.1 → 0.1.0.pre1

data/test/image_test.rb

@@ -0,0 +1,82 @@
+require File.expand_path(File.dirname(__FILE__)) + '/helpers.rb'
+
+context Ray::Image do
+  setup { Ray::Image }
+
+  context "created with a hash" do
+    setup { topic.new(:w => 50, :h => 70) }
+
+    asserts(:w).equals(50)
+    asserts(:h).equals(70)
+  end
+
+  denies("creating from a file") {
+    topic.new(path_of("aqua.bmp"))
+  }.raises(RuntimeError)
+
+  asserts("creating from a non-existing file") {
+    topic.new(path_of("doesnt_exist.bmp"))
+  }.raises(RuntimeError)
+
+  denies("creating from an IO object") {
+    open(path_of("aqua.bmp")) { |io| topic.new(io) }
+  }.raises(RuntimeError)
+
+  asserts("creating from an invalid IO object") {
+    open(path_of("VeraMono.ttf")) { |io| topic.new(io) }
+  }.raises(RuntimeError)
+
+  denies "two different images are equal, despite their content" do
+    a = topic.new(:w => 10, :h => 10).fill(Ray::Color.red).update
+    b = topic.new(:w => 10, :h => 10).fill(Ray::Color.red).update
+
+    a == b
+  end
+
+  asserts "two images representing the same one are equal" do
+    Ray.screen == Ray.screen
+  end
+end
+
+context "an image" do
+  setup { Ray::Image.new(:w => 10, :h => 10).fill(Ray::Color.green).update }
+
+  asserts(:size).equals Ray::Vector2[10, 10]
+
+  asserts("#dup returns a copy of the receiver") { topic.dup != topic }
+
+  asserts("a pixel outside the image") { topic[10, 10] }.nil
+  asserts("a pixel inside the image is a Ray::Color") { topic[5, 5].is_a? Ray::Color }
+
+  asserts("setting a pixel outside the image") {
+    topic.lock { topic[10, 10] = Ray::Color.red }
+  }.raises(ArgumentError)
+
+  denies("setting a pixel outside the image") {
+    topic { topic[5, 5] = Ray::Color.red }
+  }.raises(RuntimeError)
+
+  asserts("setting a pixel in a non-locked image") {
+    topic[5, 5] = Ray::Color.red
+  }.raises(RuntimeError)
+
+  context "after having changed a pixel" do
+    hookup { topic.lock { topic[3, 2] = Ray::Color.green } }
+    asserts("the changed pixel") { topic[3, 2] }.equals(Ray::Color.green)
+  end
+
+  asserts(:clip).equals(Ray::Rect.new(0, 0, 10, 10))
+
+  context "after having changed the clipping rect" do
+    hookup { topic.clip([5, 5, 3, 3]) }
+    asserts(:clip).equals(Ray::Rect.new(5, 5, 3, 3))
+  end
+
+  asserts("clip inside a block and otside the block") {
+    res = []
+    topic.clip([5, 5, 3, 3]) { res << topic.clip }
+    res << topic.clip
+  }.equals([Ray::Rect.new(5, 5, 3, 3), Ray::Rect.new(0, 0, 10, 10)])
+end
+
+run_tests if __FILE__ == $0

data/test/ray_test.rb

@@ -0,0 +1,25 @@
+require File.expand_path(File.dirname(__FILE__)) + '/helpers.rb'
+
+context "a newly created window" do
+  setup { Ray.create_window(:w => 100, :h => 150) }
+
+  asserts "has the size given at creation" do
+    topic.w == 100 && topic.h == 150
+  end
+
+  asserts("equal to Ray.screen") { topic == Ray.screen }
+
+  asserts "can change pixels when locked" do
+    topic.lock do
+      topic[10, 15] = Ray::Color.green
+    end
+
+    topic[10, 15] == Ray::Color.green
+  end
+
+  asserts("changing pixel when not locked") {
+    topic[10, 15] = Ray::Color.blue
+  }.raises(RuntimeError)
+end
+
+run_tests if __FILE__ == $0

data/test/rect_test.rb

@@ -0,0 +1,121 @@
+require File.expand_path(File.dirname(__FILE__)) + '/helpers.rb'
+
+context "a rect" do
+  setup { Ray::Rect.new(10, 15, 20, 30) }
+
+  asserts(:pos).equals(Ray::Vector2[10, 15])
+  asserts(:size).equals(Ray::Vector2[20, 30])
+
+  [:x, :y, :w, :h].each do |param|
+    context "after having changed #{param}" do
+      setup do |rect|
+        rect = Ray::Rect.new(10, 10, 10, 10)
+        rect.send("#{param}=", 5)
+        rect
+      end
+
+      asserts(param).equals(5)
+
+      asserts "the others components keep their values" do
+        [:x, :y, :w, :h].all? do |other|
+          other == param || topic.send(other) == 10
+        end
+      end
+    end
+  end
+
+  context "copied from another rect" do
+    setup do
+      @old_topic = topic
+      topic.dup
+    end
+
+    asserts "is equal to the original object" do
+      topic == @old_topic
+    end
+
+    asserts "is eql? to the original object" do
+      topic.eql? @old_topic
+    end
+
+    asserts(:hash).equals { @old_topic.hash }
+  end
+
+  context "created with two integers" do
+    setup { Ray::Rect.new(30, 35) }
+
+    asserts(:w).equals(0)
+    asserts(:h).equals(0)
+
+    asserts(:x).equals(30)
+    asserts(:y).equals(35)
+  end
+
+  asserts("creating a rect with a hash without x or y") {
+    Ray::Rect.new(:x => 10)
+  }.raises(ArgumentError)
+
+  asserts("creting a rect with a hash with width but not height") {
+    Ray::Rect.new(:x => 10, :y => 200, :width => 300)
+  }.raises(ArgumentError)
+
+  asserts("creating a rect with a hash with a size but without position") {
+    Ray::Rect.new(:width => 100, :height => 100)
+  }.raises(ArgumentError)
+
+  asserts "inside itself" do
+    topic.inside? Ray::Rect.new(10, 15, 20, 30)
+  end
+
+  asserts "inside a rect inside itself" do
+    topic.inside? Ray::Rect.new(8, 13, 30, 40)
+  end
+
+  asserts "not inside a rect only colliding with it" do
+    !Ray::Rect.new(5, 10, 20, 20).inside?(topic) &&
+      !Ray::Rect.new(11, 16, 40, 50).inside?(topic)
+  end
+
+  asserts "not inside a rect outside the receiver" do
+    !Ray::Rect.new(1, 2, 3, 5).inside?(topic) &&
+      !Ray::Rect.new(100, 150, 350, 450).inside?(topic)
+  end
+
+  asserts "not outside itself" do
+    not topic.outside? Ray::Rect.new(10, 15, 20, 30)
+  end
+
+  asserts "outside a rect outside itself" do
+    Ray::Rect.new(1, 2, 3, 5).outside?(topic) &&
+      Ray::Rect.new(100, 150, 350, 450).outside?(topic)
+  end
+
+  asserts "not outside a rect inside itself" do
+    not Ray::Rect.new(13, 17, 10, 20).outside?(topic)
+  end
+
+  asserts "not outside a rect colliding with itself" do
+    !Ray::Rect.new(5, 10, 20, 20).outside?(topic) &&
+      !Ray::Rect.new(11, 16, 40, 50).outside?(topic)
+  end
+
+  asserts "collides with itself" do
+    topic.collide? Ray::Rect.new(10, 15, 20, 30)
+  end
+
+  asserts "doesn't collide with a rect outside itself" do
+    !Ray::Rect.new(1, 2, 3, 5).collide?(topic) &&
+      !Ray::Rect.new(100, 150, 350, 450).collide?(topic)
+  end
+
+  asserts "collides with a rect inside itself" do
+    Ray::Rect.new(13, 17, 10, 20).collide?(topic)
+  end
+
+  asserts "collides with rects colliding with itself" do
+    Ray::Rect.new(5, 10, 20, 20).collide?(topic) &&
+      Ray::Rect.new(11, 16, 40, 50).collide?(topic)
+  end
+end
+
+run_tests if __FILE__ == $0

data/test/resource_set_test.rb

@@ -0,0 +1,99 @@
+require File.expand_path(File.dirname(__FILE__)) + '/helpers.rb'
+
+context "a resource set" do
+  setup do
+    Module.new do
+      extend Ray::ResourceSet
+
+      def self.missing_pattern(*args)
+        args
+      end
+
+      add_set(/^string:(.+)$/) do |str|
+        str
+      end
+    end
+  end
+
+  asserts "uses the block it was passed to create objects" do
+    topic["string:test"] == "test"
+  end
+
+  asserts "always returns the same object" do
+    topic["string:my string"].equal? topic["string:my string"]
+  end
+
+  asserts "uses the missing_pattern method when a string isn't matched" do
+    topic["Hello world"] == ["Hello world"]
+  end
+
+  asserts("using it with another arguments") {
+    topic["foo", 3]
+  }.raises(ArgumentError)
+
+  asserts "can select objects from cache" do
+    first, sec = topic["string:first"], topic["string:sec"]
+    topic.select! { |key, val| key == "string:first" }
+
+    first.equal?(topic["string:first"]) && !sec.equal?(topic["string:sec"])
+  end
+
+  asserts "can reject objects from cache" do
+    first, sec = topic["string:first"], topic["string:sec"]
+    topic.reject! { |key, val| key == "string:first" }
+
+    !first.equal?(topic["string:first"]) && sec.equal?(topic["string:sec"])
+  end
+end
+
+context "a resource set without missing_pattern" do
+  setup do
+    Module.new { extend Ray::ResourceSet }
+  end
+
+  asserts("using an unmatched string") {
+    topic["anything"]
+  }.raises(Ray::NoPatternError)
+end
+
+context "a resource set with more arugments" do
+  setup do
+    Module.new do
+      extend Ray::ResourceSet
+
+      need_argument_count 1
+
+      def self.missing_pattern(*args)
+        args
+      end
+
+      add_set(/^string:(.+)$/) do |str, times|
+        str * times
+      end
+    end
+  end
+
+  denies("using it with more arguments") {
+    topic["string:foo", 3]
+  }.raises(StandardError)
+
+  asserts "provides user arguments after captures" do
+    res = []
+
+    topic.add_set(/my_(.)/) do |char, times|
+      res << char
+      res << times
+
+      true
+    end
+
+    topic["my_a", 3]
+    res == ["a", 3]
+  end
+
+  asserts "passes all the arguments to missing_pattern" do
+    topic["a", 3] == ["a", 3]
+  end
+end
+
+run_tests if __FILE__ == $0

data/test/run_all.rb

@@ -0,0 +1,7 @@
+require File.expand_path(File.dirname(__FILE__)) + '/helpers.rb'
+
+Dir["#{File.dirname(__FILE__)}/*_test.rb"].each do |filename|
+  load filename
+end
+
+run_tests

data/test/shape_test.rb

@@ -0,0 +1,101 @@
+require File.expand_path(File.dirname(__FILE__)) + '/helpers.rb'
+
+context "a shape" do
+  setup { Ray::Shape.new }
+
+  asserts(:pos).equals(Ray::Vector2[0, 0])
+  asserts(:point_count).equals(0)
+  asserts(:outline_width).equals(0)
+  asserts(:angle).equals(0)
+  asserts(:scale).equals(Ray::Vector2[1.0, 1.0])
+
+  asserts("setting the color of a point outside bounds") {
+    topic.set_color_of(0, Ray::Color.blue)
+  }.raises(ArgumentError)
+
+  asserts("setting the outline of a point outside bounds") {
+    topic.set_outline_of(0, Ray::Color.blue)
+  }.raises(ArgumentError)
+
+  asserts("setting the position of a point outside bounds") {
+    topic.set_position_of(0, [10, 10])
+  }.raises(ArgumentError)
+
+  asserts("color, outline, and position of a point outside bounds") {
+    [topic.color_of(0), topic.outline_of(0), topic.position_of(0)]
+  }.equals([nil, nil, nil])
+
+  context "with a point" do
+    hookup do
+      topic.add_point([5, 3], Ray::Color.red, Ray::Color.black)
+    end
+
+    asserts(:point_count).equals(1)
+
+    asserts("position of the point") { topic.position_of(0) }.equals(Ray::Vector2[5, 3])
+    asserts("color of the point") { topic.color_of(0) }.equals(Ray::Color.red)
+    asserts("outline of the point") { topic.outline_of(0) }.equals(Ray::Color.black)
+
+    context "copied from another shape" do
+      setup do
+        @old_topic = topic
+        topic.dup
+      end
+
+      asserts(:point_count).equals(1)
+
+      asserts("position of the point") { topic.position_of(0) }.equals(Ray::Vector2[5, 3])
+      asserts("color of the point") { topic.color_of(0) }.equals(Ray::Color.red)
+      asserts("outline of the point") { topic.outline_of(0) }.equals(Ray::Color.black)
+
+      denies "is the same object as the original one" do
+        topic.equal? @old_topic
+      end
+    end
+  end
+
+  context "with outline_width = 10" do
+    hookup { topic.outline_width = 10 }
+    asserts(:outline_width).equals(10)
+  end
+
+  context "with angle = 10" do
+    hookup { topic.angle = 10 }
+    asserts(:angle).equals(10)
+  end
+
+  context "with scale = [10, 5.5]" do
+    hookup { topic.scale = [10, 5.5] }
+    asserts(:scale).equals(Ray::Vector2[10, 5.5])
+  end
+
+  context "with position = [3, 4]" do
+    hookup { topic.pos = [3, 4] }
+    asserts(:pos).equals(Ray::Vector2[3, 4])
+  end
+end
+
+context "a shape point" do
+  setup do
+    shape = Ray::Shape.new(1) do |p|
+      p.pos     = [10, 15]
+      p.color   = Ray::Color.new(1, 2, 3)
+      p.outline = Ray::Color.new(4, 5, 6)
+    end
+
+    shape[0]
+  end
+
+  asserts(:pos).equals(Ray::Vector2[10, 15])
+  asserts(:color).equals(Ray::Color.new(1, 2, 3))
+  asserts(:outline).equals(Ray::Color.new(4, 5, 6))
+
+  asserts(:id).equals(0)
+
+  asserts("first position, color, and outline of the shape") {
+    shape = topic.shape
+    [shape.position_of(0), shape.color_of(0), shape.outline_of(0)]
+  }.equals([Ray::Vector2[10, 15], Ray::Color.new(1, 2, 3), Ray::Color.new(4, 5, 6)])
+end
+
+run_tests if __FILE__ == $0