rubygame 2.3.0-x86-linux

data/test/surface_spec.rb

@@ -0,0 +1,219 @@
+# This is mostly for regression testing and bugfix confirmation at the moment.
+
+require 'rubygame'
+include Rubygame
+
+samples_dir = File.join( File.dirname(__FILE__), "..", "samples", "")
+test_dir = File.join( File.dirname(__FILE__), "" )
+
+test_image = test_dir + "image.png"
+not_image = test_dir + "short.ogg"
+panda = samples_dir + "panda.png"
+dne = test_dir + "does_not_exist.png"
+
+
+describe Surface, "(creation)" do
+  before(:each) do
+    Rubygame.init()
+    @screen = Screen.new([100,100])
+  end
+
+  after(:each) do
+    Rubygame.quit()
+  end
+
+  it "should raise TypeError when #new size is not an Array" do
+    lambda {
+      Surface.new("not an array")
+    }.should raise_error(TypeError)
+  end
+
+  it "should raise ArgumentError when #new size is an Array of non-Numerics" do
+    lambda {
+      Surface.new(["not", "numeric", "members"])
+    }.should raise_error(TypeError)
+  end
+
+  it "should raise ArgumentError when #new size is too short" do
+    lambda {
+      Surface.new([1])
+    }.should raise_error(ArgumentError)
+  end
+end
+
+
+
+describe Surface, "(loading)" do
+  before :each do
+    unless( Rubygame::VERSIONS[:sdl_image] )
+      raise "Can't test image loading, no SDL_image installed."
+    end
+  end
+
+  it "should load image to a new Surface" do
+    surface = Surface.load( test_image )
+  end
+
+  it "should raise an error if file is not an image" do
+    lambda{ Surface.load( not_image ) }.should raise_error( SDLError )
+  end
+
+  it "should raise an error if file doesn't exist" do
+    lambda{ Surface.load( dne ) }.should raise_error( SDLError )
+  end
+end
+
+
+describe Surface, "(loading from string)" do
+  before :each do
+    unless( Rubygame::VERSIONS[:sdl_image] )
+      raise "Can't test image loading, no SDL_image installed."
+    end
+
+    @data = "\x42\x4d\x3a\x00\x00\x00\x00\x00"+
+            "\x00\x00\x36\x00\x00\x00\x28\x00"+
+            "\x00\x00\x01\x00\x00\x00\x01\x00"+
+            "\x00\x00\x01\x00\x18\x00\x00\x00"+
+            "\x00\x00\x04\x00\x00\x00\x13\x0b"+
+            "\x00\x00\x13\x0b\x00\x00\x00\x00"+
+            "\x00\x00\x00\x00\x00\x00\x00\x00"+
+            "\xff\x00"
+  end
+  
+  it "should be able to load from string" do
+    surf = Surface.load_from_string(@data)
+    surf.get_at(0,0).should == [255,0,0,255]
+  end
+  
+  it "should be able to load from string (typed)" do
+    surf = Surface.load_from_string(@data,"BMP")
+    surf.get_at(0,0).should == [255,0,0,255]
+  end
+end
+
+
+describe Surface, "(named resource)" do
+  before :each do
+    Surface.autoload_dirs = [samples_dir]
+  end
+
+  after :each do
+    Surface.autoload_dirs = []
+    Surface.instance_eval { @resources = {} }
+  end
+
+  it "should include NamedResource" do
+    Surface.included_modules.should include(NamedResource)
+  end
+
+  it "should respond to :[]" do
+    Surface.should respond_to(:[])
+  end
+
+  it "should respond to :[]=" do
+    Surface.should respond_to(:[]=)
+  end
+
+  it "should allow setting resources" do
+    s = Surface.load(panda)
+    Surface["panda"] = s
+    Surface["panda"].should == s
+  end
+
+  it "should reject non-Surface resources" do
+    lambda { Surface["foo"] = "bar" }.should raise_error(TypeError)
+  end
+
+  it "should autoload images as Surface instances" do
+    unless( Rubygame::VERSIONS[:sdl_image] )
+      raise "Can't test image loading, no SDL_image installed."
+    end
+
+    Surface["panda.png"].should be_instance_of(Surface)
+  end
+
+  it "should return nil for nonexisting files" do
+    unless( Rubygame::VERSIONS[:sdl_image] )
+      raise "Can't test image loading, no SDL_image installed."
+    end
+
+    Surface["foobar.png"].should be_nil
+  end
+
+  it "should set names of autoload Surfaces" do
+    unless( Rubygame::VERSIONS[:sdl_image] )
+      raise "Can't test image loading, no SDL_image installed."
+    end
+
+    Surface["panda.png"].name.should == "panda.png"
+  end
+end
+
+
+
+describe Surface, "(blit)" do
+  before(:each) do
+    Rubygame.init()
+    @screen = Screen.new([100,100])
+    @surface = Surface.new([100,100])
+  end
+
+  after(:each) do
+    Rubygame.quit
+  end
+
+  it "should raise TypeError when #blit target is not a Surface" do
+    lambda {
+      @surface.blit("not a surface", [0,0])
+    }.should raise_error(TypeError)
+  end
+
+  it "should raise TypeError when #blit dest is not an Array" do
+    lambda {
+      @surface.blit(@screen, "foo")
+    }.should raise_error(TypeError)
+  end
+
+  it "should raise TypeError when #blit src is not an Array" do
+    lambda { 
+      @surface.blit(@screen, [0,0], "foo")
+    }.should raise_error(TypeError)
+  end
+end
+
+
+
+describe Surface, "(fill)" do 
+  before(:each) do
+    Rubygame.init()
+    @surface = Surface.new([100,100])
+  end
+
+  after(:each) do
+    Rubygame.quit
+  end
+
+  it "should raise TypeError when #fill color is not an Array" do
+    lambda {
+      @surface.fill(nil)
+    }.should raise_error(TypeError)
+  end
+
+  it "should raise TypeError when #fill color is an Array of non-Numerics" do
+    lambda {
+      @surface.fill(["non", "numeric", "members"])
+    }.should raise_error(TypeError)
+  end
+
+  it "should raise ArgumentError when #fill color is too short" do
+    lambda {
+      @surface.fill([0xff, 0xff])
+    }.should raise_error(TypeError)
+  end
+
+  it "should raise TypeError when #fill rect is not an Array" do
+    lambda {
+      @surface.fill([0xff, 0xff, 0xff], "not_an_array")
+    }.should raise_error(TypeError)
+  end
+end

data/test/test_crop.rb

@@ -0,0 +1,45 @@
+#!/usr/bin/env ruby
+
+puts \
+"This test is almost certainly not correct, and needs a lot of improvement.
+Don't trust the results too much.
+~~~~~~~~~~"
+
+require "rubygame"
+
+screen = Rubygame::Screen.set_mode([200,200])
+surf = Rubygame::Surface.new([100,100]).fill([0,0,255])
+widesurf = Rubygame::Surface.new([250,100]).fill([0,0,255])
+tallsurf = Rubygame::Surface.new([100,250]).fill([0,0,255])
+bigsurf = Rubygame::Surface.new([250,250]).fill([0,0,255])
+
+tests = [
+	[surf,[
+			[50,50], # fully inside
+			[-50,0], # off left
+			[0,-50], # off top
+			[150,0], # off right
+			[0,150], # off bottom
+			[-50,-50], # off top-left
+			[150,-50], # off top-right
+			[150,150], # off bottom-right
+			[-50,150], # off bottom-left
+		]],
+	[widesurf,[[-25,50]],], # off left and right
+	[tallsurf,[[50,-25]],], # off top and bottom
+	[bigsurf,[[-25,-25]],], # off left, top, right, bottom
+]
+
+tests.each{ |test|
+	test[1].each{ |pos|
+		x = [0,pos[0]].max
+		y = [0,pos[1]].max
+		w = [pos[0]+test[0].w,200].min - x
+		h = [pos[1]+test[0].h,200].min - y
+		if (rect = test[0].blit(screen,pos)) == [x,y,w,h]
+			puts "Correct! %s"%rect
+		else
+			puts "Incorrect! %s should have been [%d,%d,%d,%d]"%[rect,x,y,w,h]
+		end
+	}
+}

data/test/test_rect.rb

@@ -0,0 +1,841 @@
+#!/usr/bin/env ruby
+
+# This program is PUBLIC DOMAIN.
+# It is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ 
+ 
+# This is a unit test suite for Rubygame Rects.
+# However. it is BY NO MEANS COMPREHENSIVE.
+#
+# If you have the time and motivation, please consider contributing
+# a few more tests to improve this suite.
+# 
+# The following methods (of Rect if unspecified) have NO TESTS AT ALL:
+#  new_from_object
+#  collide_hash
+#  collide_hash_all
+#  collide_array
+#  collide_array_all
+#  collide_point?
+#  collide_rect?
+#  contain?
+#  inflate!
+#  move
+#  move!
+#  normalize
+#  normalize!
+#  union_all
+#  union_all!
+#  Surface#make_rect
+# 
+# The following methods (of Rect if unspecified) have NOT ENOUGH TESTS:
+#  union
+#  union!
+# 
+# The following methods (of Rect if unspecified) have ENOUGH TESTS:
+#  initialize
+#  to_s
+#  inspect
+#  []
+#  []=
+#  x
+#  y
+#  w
+#  h
+#  width
+#  height
+#  size
+#  left
+#  top
+#  right
+#  bottom
+#  center
+#  centerx
+#  centery
+#  topleft
+#  topright
+#  bottomleft
+#  bottomright
+#  midleft
+#  midtop
+#  midright
+#  midbottomX
+#  clip
+#  clip!
+#
+
+# --
+# Table of Contents:
+#  INITIALIZATION
+#  CONVERSION
+#  PRIMARY ATTRIBUTES
+#  SIDES
+#  CENTERS
+#  CORNERS
+#  MIDPOINTS
+#  CLAMP
+#  INFLATE
+#  CLIP
+# ++
+
+
+require "test/unit"
+require "rubygame"
+Rect = Rubygame::Rect
+
+# A class to test Rect.new_from_object()'s ability to extract a Rect from
+# an object which responds to :rect
+class RectParent
+	attr_reader :rect
+	def initialize(r)
+		@rect = r
+	end
+end
+
+
+class TC_Rect < Test::Unit::TestCase
+
+	# --
+	# INITALIZATION
+	# ++
+
+	# Test init'n from 1 Array with 4 entries
+	def test_new1_arr
+		rect = Rect.new([3,5,20,40])
+		assert_equal([3,5,20,40],rect)
+	end
+
+	# Test init'n from 1 Rect
+	def test_new1_rect
+		base = Rect.new([3,5,20,40])
+		rect = Rect.new(base)
+		assert_equal([3,5,20,40],rect)
+	end
+
+	# Test init'n from 2 Arrays with 2 entries each
+	def test_new2
+		rect = Rect.new([3,5],[20,40])
+		assert_equal([3,5,20,40],rect)
+	end
+
+	# Test init'n from 4 Numerics
+	def test_new4
+		rect = Rect.new(3,5,20,40)
+		assert_equal([3,5,20,40],rect)
+	end
+
+	# Test #new_from_object with a Rect
+	def test_nfo_rect
+		rect = Rect.new_from_object(Rect.new(3,5,20,40))
+		assert_equal([3,5,20,40],rect)
+		assert_kind_of(Rect,rect)
+	end
+
+	# Test #new_from_object with an Array
+	def test_nfo_rect
+		rect = Rect.new_from_object([3,5,20,40])
+		assert_equal([3,5,20,40],rect)
+		assert_kind_of(Rect,rect)
+	end
+
+	# Test #new_from_object with a .rect attribute which is a Rect
+	def test_nfo_rect_attr_rect
+
+		rect = Rect.new_from_object(RectParent.new(Rect.new(3,5,20,40)))
+		assert_equal([3,5,20,40],rect)
+		assert_kind_of(Rect,rect)
+	end
+
+	# Test #new_from_object with a .rect attribute which is an Array
+	def test_nfo_rect_attr_rect
+		rect = Rect.new_from_object(RectParent.new([3,5,20,40]))
+		assert_equal([3,5,20,40],rect)
+		assert_kind_of(Rect,rect)
+	end
+
+	# --
+	# CONVERSION
+	# ++
+
+	# Test that output from #to_s is proper with a Rect of Integers
+	def test_to_s_int
+		rect = Rect.new(3,5,20,40)
+		assert_equal("#<Rect [3,5,20,40]>",rect.to_s)
+	end
+
+	# Test that output from #to_s is proper with a Rect of Floats
+	def test_to_s_float
+		rect = Rect.new(3.15,5.2,20.3,40.5)
+		assert_equal("#<Rect [3.15,5.2,20.3,40.5]>",rect.to_s)
+	end
+
+	# Test that output from #inspect is proper with a Rect of Integers
+	def test_inspect_int
+		rect = Rect.new(3,5,20,40)
+		assert_equal("#<Rect:#{rect.object_id} [3,5,20,40]>",rect.inspect)
+	end
+
+	# Test that output from #inspect is proper with a Rect of Floats
+	def test_inspect_float
+		rect = Rect.new(3.15,5.2,20.3,40.5)
+		assert_equal("#<Rect:#{rect.object_id} [3.15,5.2,20.3,40.5]>",rect.inspect)
+	end
+
+	# --
+	# PRIMARY ATTRIBUTES
+	# ++
+
+	def test_x
+		rect = Rect.new(3,5,20,40)
+		assert_equal(3,rect.x)
+	end
+
+	def test_set_x
+		rect = Rect.new(3,5,20,40)
+		rect.x=9
+		assert_equal([9,5,20,40],rect)
+	end
+
+	def test_index_0
+		rect = Rect.new(3,5,20,40)
+		assert_equal(3,rect[0])
+	end
+
+	def test_set_index_0
+		rect = Rect.new(3,5,20,40)
+		rect[0]=9
+		assert_equal([9,5,20,40],rect)
+	end
+
+
+	def test_y
+		rect = Rect.new(3,5,20,40)
+		assert_equal(5,rect.y)
+	end
+
+	def test_set_y
+		rect = Rect.new(3,5,20,40)
+		rect.y=23
+		assert_equal([3,23,20,40],rect)
+	end
+
+	def test_index_1
+		rect = Rect.new(3,5,20,40)
+		assert_equal(5,rect[1])
+	end
+
+	def test_set_index_1
+		rect = Rect.new(3,5,20,40)
+		rect[1]=9
+		assert_equal([3,9,20,40],rect)
+	end
+
+
+	def test_w
+		rect = Rect.new(3,5,20,40)
+		assert_equal(20,rect.w)
+	end
+
+	def test_set_w
+		rect = Rect.new(3,5,20,40)
+		rect.w=9
+		assert_equal([3,5,9,40],rect)
+	end
+
+	def test_width
+		rect = Rect.new(3,5,20,40)
+		assert_equal(20,rect.width)
+	end
+
+	def test_set_width
+		rect = Rect.new(3,5,20,40)
+		rect.width=9
+		assert_equal([3,5,9,40],rect)
+	end
+
+	def test_index_2
+		rect = Rect.new(3,5,20,40)
+		assert_equal(20,rect[2])
+	end
+
+	def test_set_index_2
+		rect = Rect.new(3,5,20,40)
+		rect[2]=9
+		assert_equal([3,5,9,40],rect)
+	end
+
+
+	def test_h
+		rect = Rect.new(3,5,20,40)
+		assert_equal(40,rect.h)
+	end
+
+	def test_set_h
+		rect = Rect.new(3,5,20,40)
+		rect.h=11
+		assert_equal([3,5,20,11],rect)
+	end
+
+	def test_height
+		rect = Rect.new(3,5,20,40)
+		assert_equal(40,rect.height)
+	end
+
+	def test_set_height
+		rect = Rect.new(3,5,20,40)
+		rect.height=9
+		assert_equal([3,5,20,9],rect)
+	end
+
+
+	def test_size
+		rect = Rect.new(3,5,20,40)
+		assert_equal([20,40],rect.size)
+	end
+
+	def test_set_size
+		rect = Rect.new(3,5,20,40)
+		rect.size = [9,5]
+		assert_equal([3,5,9,5],rect)
+	end
+
+	# --
+	# SIDES
+	# ++
+
+	def test_left
+		rect = Rect.new(3,5,20,40)
+		assert_equal(3,rect.left)
+	end
+
+	def test_set_left
+		rect = Rect.new(3,5,20,40)
+		rect.left=9
+		assert_equal([9,5,20,40],rect)
+	end
+
+
+	def test_top
+		rect = Rect.new(3,5,20,40)
+		assert_equal(5,rect.top)
+	end
+
+	def test_set_top
+		rect = Rect.new(3,5,20,40)
+		rect.top=9
+		assert_equal([3,9,20,40],rect)
+	end
+
+
+	def test_right
+		rect = Rect.new(3,5,20,40)
+		assert_equal(23,rect.right)
+	end
+
+	def test_set_right
+		rect = Rect.new(3,5,20,40)
+		rect.right = 42
+		assert_equal([22,5,20,40],rect)
+	end
+
+
+	def test_bottom
+		rect = Rect.new(3,5,20,40)
+		assert_equal(45,rect.bottom)
+	end
+
+	def test_set_bottom
+		rect = Rect.new(3,5,20,40)
+		rect.bottom = 42
+		assert_equal([3,2,20,40],rect)
+	end
+
+	# --
+	# CENTERS
+	# ++
+
+	def test_center
+		rect = Rect.new(3,5,20,40)
+		assert_equal([13,25],rect.center)
+	end
+
+	def test_set_center
+		rect = Rect.new(3,5,20,40)
+		rect.center = [16,42]
+		assert_equal([6,22,20,40],rect)
+	end
+
+	def test_centerx
+		rect = Rect.new(3,5,20,40)
+		assert_equal(13,rect.centerx)
+	end
+
+	def test_set_centerx
+		rect = Rect.new(3,5,20,40)
+		rect.centerx = 16
+		assert_equal([6,5,20,40],rect)
+	end
+
+	def test_centery
+		rect = Rect.new(3,5,20,40)
+		assert_equal(13,rect.centerx)
+	end
+
+	def test_set_centery
+		rect = Rect.new(3,5,20,40)
+		rect.centery = 43
+		assert_equal([3,23,20,40],rect)
+	end
+
+	# --
+	# CORNERS
+	# ++
+
+	def test_topleft
+		rect = Rect.new(3,5,20,40)
+		assert_equal([3,5],rect.topleft)
+	end
+
+	def test_set_topleft
+		rect = Rect.new(3,5,20,40)
+		rect.topleft = [6,2]
+		assert_equal([6,2,20,40],rect)
+	end
+
+	def test_tl
+		rect = Rect.new(3,5,20,40)
+		assert_equal([3,5],rect.tl)
+	end
+
+	def test_set_tl
+		rect = Rect.new(3,5,20,40)
+		rect.tl = [6,2]
+		assert_equal([6,2,20,40],rect)
+	end
+
+
+	def test_topright
+		rect = Rect.new(3,5,20,40)
+		assert_equal([23,5],rect.topright)
+	end
+
+	def test_set_topright
+		rect = Rect.new(3,5,20,40)
+		rect.topright = [26,2]
+		assert_equal([6,2,20,40],rect)
+	end
+
+	def test_tr
+		rect = Rect.new(3,5,20,40)
+		assert_equal([23,5],rect.tr)
+	end
+
+	def test_set_tr
+		rect = Rect.new(3,5,20,40)
+		rect.tr = [26,2]
+		assert_equal([6,2,20,40],rect)
+	end
+
+
+	def test_bottomright
+		rect = Rect.new(3,5,20,40)
+		assert_equal([23,45],rect.bottomright)
+	end
+
+	def test_set_bottomright
+		rect = Rect.new(3,5,20,40)
+		rect.bottomright = [26,42]
+		assert_equal([6,2,20,40],rect)
+	end
+
+	def test_br
+		rect = Rect.new(3,5,20,40)
+		assert_equal([23,45],rect.br)
+	end
+
+	def test_set_br
+		rect = Rect.new(3,5,20,40)
+		rect.br = [26,42]
+		assert_equal([6,2,20,40],rect)
+	end
+
+
+	def test_bottomleft
+		rect = Rect.new(3,5,20,40)
+		assert_equal([3,45],rect.bottomleft)
+	end
+
+	def test_set_bottomleft
+		rect = Rect.new(3,5,20,40)
+		rect.bottomleft = [6,42]
+		assert_equal([6,2,20,40],rect)
+	end
+
+	def test_bl
+		rect = Rect.new(3,5,20,40)
+		assert_equal([3,45],rect.bl)
+	end
+
+	def test_set_bl
+		rect = Rect.new(3,5,20,40)
+		rect.bl = [6,42]
+		assert_equal([6,2,20,40],rect)
+	end
+
+	# --
+	# MIDPOINTS
+	# ++
+
+	def test_midleft
+		rect = Rect.new(3,5,20,40)
+		assert_equal([3,25],rect.midleft)
+	end
+
+	def test_set_midleft
+		rect = Rect.new(3,5,20,40)
+		rect.midleft = [6,22]
+		assert_equal([6,2,20,40],rect)
+	end
+
+	def test_ml
+		rect = Rect.new(3,5,20,40)
+		assert_equal([3,25],rect.ml)
+	end
+
+	def test_set_ml
+		rect = Rect.new(3,5,20,40)
+		rect.ml = [6,22]
+		assert_equal([6,2,20,40],rect)
+	end
+
+
+	def test_midtop
+		rect = Rect.new(3,5,20,40)
+		assert_equal([13,5],rect.midtop)
+	end
+
+	def test_set_midtop
+		rect = Rect.new(3,5,20,40)
+		rect.midtop = [16,2]
+		assert_equal([6,2,20,40],rect)
+	end
+
+	def test_mt
+		rect = Rect.new(3,5,20,40)
+		assert_equal([13,5],rect.mt)
+	end
+
+	def test_set_mt
+		rect = Rect.new(3,5,20,40)
+		rect.mt = [16,2]
+		assert_equal([6,2,20,40],rect)
+	end
+
+
+	def test_midright
+		rect = Rect.new(3,5,20,40)
+		assert_equal([23,25],rect.midright)
+	end
+
+	def test_set_midright
+		rect = Rect.new(3,5,20,40)
+		rect.midright = [26,22]
+		assert_equal([6,2,20,40],rect)
+	end
+
+	def test_mr
+		rect = Rect.new(3,5,20,40)
+		assert_equal([23,25],rect.mr)
+	end
+
+	def test_set_mr
+		rect = Rect.new(3,5,20,40)
+		rect.mr = [26,22]
+		assert_equal([6,2,20,40],rect)
+	end
+
+
+	def test_midbottom
+		rect = Rect.new(3,5,20,40)
+		assert_equal([13,45],rect.midbottom)
+	end
+
+	def test_set_midbottom
+		rect = Rect.new(3,5,20,40)
+		rect.midbottom = [16,42]
+		assert_equal([6,2,20,40],rect)
+	end
+
+	def test_mb
+		rect = Rect.new(3,5,20,40)
+		assert_equal([13,45],rect.mb)
+	end
+
+	def test_set_mb
+		rect = Rect.new(3,5,20,40)
+		rect.mb = [16,42]
+		assert_equal([6,2,20,40],rect)
+	end
+
+
+	# --
+	# CLAMP
+	# ++
+
+	# Clamp a rect that fits.
+	def test_clamp_fits
+		rect_a = Rect.new(0,0,20,20)
+		rect_b = Rect.new(40,10,6,6)
+		assert_equal([14,10,6,6],rect_b.clamp(rect_a))
+	end
+
+	# Clamp a rect that fits, but is already contained (no effect)
+	def test_clamp_contained
+		rect_a = Rect.new(0,0,20,20)
+		rect_b = Rect.new(10,10,6,6)
+		assert_equal([10,10,6,6],rect_b.clamp(rect_a))
+	end
+
+	# Clamp a rect that is too wide.
+	def test_clamp_wide
+		rect_a = Rect.new(0,0,20,20)
+		rect_b = Rect.new(40,10,30,6)
+		assert_equal([-5,10,30,6],rect_b.clamp(rect_a))
+	end
+
+	# Clamp a rect that is too tall.
+	def test_clamp_tall
+		rect_a = Rect.new(0,0,20,20)
+		rect_b = Rect.new(10,40,6,30)
+		assert_equal([10,-5,6,30],rect_b.clamp(rect_a))
+	end
+
+	# Clamp a rect that is both too wide and too tall.
+	def test_clamp_nofit
+		rect_a = Rect.new(0,0,20,20)
+		rect_b = Rect.new(10,40,30,30)
+		assert_equal([-5,-5,30,30],rect_b.clamp(rect_a))
+	end
+
+
+	# --
+	# INFLATE
+	# ++
+
+	# Inflate a rect by zero on x and y
+	def test_inflate_zero_x_zero_y
+		assert_equal([0,0,20,20],
+								 Rect.new(0,0,20,20).inflate(0,0))
+	end
+
+	# Inflate a rect by an even positive integer on x and y
+	def test_inflate_evenposint_x_evenposint_y
+		assert_equal([-2,-3,24,26],
+								 Rect.new(0,0,20,20).inflate(4,6))
+	end
+
+	# Inflate a rect by an odd negative integer on x and y
+	# NOTE: Pygame would give a result of [-1,-3,23,25].
+	def test_inflate_oddposint_x_oddposint_y
+		assert_equal([-1,-2,23,25],
+								 Rect.new(0,0,20,20).inflate(3,5))
+	end
+
+	# Inflate a rect by an even negative integer on x and y
+	def test_inflate_evennegint_x_evennegint_y
+		assert_equal([2,3,16,14],
+								 Rect.new(0,0,20,20).inflate(-4,-6))
+	end
+
+	# Inflate a rect by an odd negative integer on x and y
+	# NOTE: Pygame would give a result of [1,2,17,15].
+	def test_inflate_oddnegint_x_oddnegint_y
+		assert_equal([2,3,17,15],
+								 Rect.new(0,0,20,20).inflate(-3,-5))
+	end
+
+	# --
+	# COLLIDE_RECT
+	# ++
+
+	# Test collision between rects which do not collide on either axis.
+	def test_collide_rect_nox_noy
+		r1 = Rect.new(0,0,10,10)
+		r2 = Rect.new(20,20,10,10)
+		assert(!(r1.collide_rect?(r2)), "r1 should not collide with r2")
+		assert(!(r2.collide_rect?(r1)), "r2 should not collide with r1")
+	end
+
+	# Test collision between rects which overlap on the X axis only
+	# (i.e. they would intersect if they were at the same vertical position).
+	def test_collide_rect_overlapx_noy
+		r1 = Rect.new(0,0,10,10)
+		r2 = Rect.new(5,30,10,10)
+		assert(!(r1.collide_rect?(r2)), "r1 should not collide with r2")
+		assert(!(r2.collide_rect?(r1)), "r2 should not collide with r1")
+	end
+
+	# Test collision between rects which overlap on the Y axis only
+	# (i.e. they would intersect if they were at the same horizontal position).
+	def test_collide_rect_nox_overlapy
+		r1 = Rect.new(0,0,10,10)
+		r2 = Rect.new(20,5,10,10)
+		assert(!(r1.collide_rect?(r2)), "r1 should not collide with r2")
+		assert(!(r2.collide_rect?(r1)), "r2 should not collide with r1")
+	end
+
+	# Test collision between rects which overlap on both axes.
+	def test_collide_rect_overlapx_overlapy
+		r1 = Rect.new(0,0,10,10)
+		r2 = Rect.new(5,5,10,10)
+		assert(r1.collide_rect?(r2), "r1 should collide with r2")
+		assert(r2.collide_rect?(r1), "r2 should collide with r1")
+	end
+
+	# Test collision between rects, one containing the other on both axes.
+	def test_collide_rect_conx_cony
+		r1 = Rect.new(0,0,10,10)
+		r2 = Rect.new(5,5,4,4)
+		assert(r1.collide_rect?(r2), "r1 should collide with r2")
+		assert(r2.collide_rect?(r1), "r2 should collide with r1")
+	end
+
+	# Test collision between rects touching but not overlapping on X axis only.
+	def test_collide_rect_touchx_noy
+		r1 = Rect.new(0,0,10,10)
+		r2 = Rect.new(10,0,10,10)
+		assert(r1.collide_rect?(r2), "r1 should collide with r2")
+		assert(r2.collide_rect?(r1), "r2 should collide with r1")
+	end
+
+	# Test collision between rects touching but not overlapping on Y axis only.
+	def test_collide_rect_nox_touchy
+		r1 = Rect.new(0,0,10,10)
+		r2 = Rect.new(0,10,10,10)
+		assert(r1.collide_rect?(r2), "r1 should collide with r2")
+		assert(r2.collide_rect?(r1), "r2 should collide with r1")
+	end
+
+	# Test collision between rects touching but not overlapping on both axes.
+	# (i.e. corners are touching)
+	def test_collide_rect_touchx_touchy
+		r1 = Rect.new(0,0,10,10)
+		r2 = Rect.new(10,10,10,10)
+		assert(r1.collide_rect?(r2), "r1 should collide with r2")
+		assert(r2.collide_rect?(r1), "r2 should collide with r1")
+	end
+
+	# --
+	# UNION
+	# ++
+
+  # Test union between two non-overlapping rects.
+  def test_union_separate
+    r1 = Rect.new([0,0,10,10])
+    r2 = Rect.new([20,20,10,10])
+    assert_equal([0,0,30,30], r1.union(r2))
+    assert_equal([0,0,30,30], r2.union(r1))
+    assert_equal(r1.union(r2), r2.union(r1))
+  end
+
+  # Test union between two overlapping rects.
+  def test_union_overlap
+    r1 = Rect.new([0,0,10,10])
+    r2 = Rect.new([5,5,10,10])
+    assert_equal([0,0,15,15], r1.union(r2))
+    assert_equal([0,0,15,15], r2.union(r1))
+  end
+
+  # Test union between a rect and another rect which it contains.
+  def test_union_contained
+    r1 = Rect.new([0,0,20,20])
+    r2 = Rect.new([5,5,10,10])
+    assert_equal([0,0,20,20], r1.union(r2))
+    assert_equal([0,0,20,20], r2.union(r1))
+  end
+
+  # Test union between two identical rects.
+  def test_union_identical
+    r1 = Rect.new([0,0,20,20])
+    r2 = Rect.new([0,0,20,20])
+    assert_equal([0,0,20,20], r1.union(r2))
+    assert_equal([0,0,20,20], r2.union(r1))
+  end
+
+	# --
+	# CLIP
+	# ++
+
+	def test_clip_offleft
+		r1 = Rect.new([2,5,10,10])
+    r2 = Rect.new([4,1,20,20])
+		should_be = Rect.new([4,5,8,10])
+		assert_equal(should_be, r1.clip(r2))
+		assert_equal(should_be, r2.clip(r1))
+	end
+
+	def test_clip_offright
+		r1 = Rect.new([15,5,10,10])
+    r2 = Rect.new([4,1,20,20])
+		should_be = Rect.new([15,5,9,10])
+		assert_equal(should_be, r1.clip(r2))
+		assert_equal(should_be, r2.clip(r1))
+	end
+
+	def test_clip_offtop
+		r1 = Rect.new([5,2,10,10])
+    r2 = Rect.new([1,4,20,20])
+		should_be = Rect.new([5,4,10,8])
+		assert_equal(should_be, r1.clip(r2))
+		assert_equal(should_be, r2.clip(r1))
+	end
+
+	def test_clip_offbottom
+		r1 = Rect.new([5,15,10,10])
+    r2 = Rect.new([1,4,20,20])
+		should_be = Rect.new([5,15,10,9])
+		assert_equal(should_be, r1.clip(r2))
+		assert_equal(should_be, r2.clip(r1))
+	end
+
+	def test_clip_offleftandright
+		r1 = Rect.new([2,5,30,10])
+    r2 = Rect.new([4,1,20,20])
+		should_be = Rect.new([4,5,20,10])
+		assert_equal(should_be, r1.clip(r2))
+		assert_equal(should_be, r2.clip(r1))
+	end
+
+	def test_clip_offtopandbottom
+		r1 = Rect.new([2,5,10,30])
+    r2 = Rect.new([4,1,20,20])
+		should_be = Rect.new([4,5,8,16])
+		assert_equal(should_be, r1.clip(r2))
+		assert_equal(should_be, r2.clip(r1))
+	end
+
+	def test_clip_offallsides
+		r1 = Rect.new([2,5,30,30])
+    r2 = Rect.new([4,1,20,20])
+		should_be = Rect.new([4,5,20,16])
+		assert_equal(should_be, r1.clip(r2))
+		assert_equal(should_be, r2.clip(r1))
+	end
+
+	def test_clip_contained
+		r1 = Rect.new([6,3,5,5])
+    r2 = Rect.new([4,1,20,20])
+		should_be = r1
+		assert_equal(should_be, r1.clip(r2))
+		assert_equal(should_be, r2.clip(r1))
+	end
+
+	def test_clip_nooverlap
+		r1 = Rect.new([6,3,5,5])
+    r2 = Rect.new([20,1,20,20])
+		assert_equal(Rect.new([6,3,0,0]), r1.clip(r2))
+		assert_equal(Rect.new([20,1,0,0]), r2.clip(r1))
+	end
+end