shattered 0.5.0.1 → 0.7.0

data/test/unit/shattered_model/mouse_input_test.rb

@@ -0,0 +1,61 @@
+require File.dirname(__FILE__) + '/../test_helper'
+
+include Shattered
+
+class MouseInputTest < Test::Unit::TestCase
+
+  def setup
+    @ois_mock = mock()
+	  @input = Input::Mouse.new(@ois_mock)
+  end
+  
+	def test_press
+    @ois_mock.expects(:pressed?)
+	  @input.press(1)
+  end
+  
+  def test_release
+    @ois_mock.expects(:released?)
+	  @input.release(1)
+  end
+
+  def test_hold
+    @ois_mock.expects(:held?)
+	  @input.hold(1)
+  end
+  
+  def test_move
+    @ois_mock.expects(:x).returns 0
+    @ois_mock.expects(:y).returns 0
+	  assert_equal false, @input.move
+  end
+  
+  def test_scroll
+    @ois_mock.expects(:scrolled)
+	  @input.scroll
+  end
+  
+  def test_symbol_left
+    @ois_mock.expects(:held?).with 0
+    @input.hold(:left)
+  end
+  
+  
+  def test_symbol_middle
+    @ois_mock.expects(:pressed?).with 2
+    @input.press(:middle)
+  end
+  
+  
+  def test_symbol_right
+    @ois_mock.expects(:released?).with 1
+    @input.release(:right)
+  end
+  
+  def test_bad_symbol
+    assert_raises Exception do
+      @input.press(:bad_button)
+    end  
+  end
+  
+end

data/test/unit/shattered_model/shattered_model_test.rb

@@ -0,0 +1,117 @@
+require File.expand_path(File.dirname(__FILE__)+'/../test_helper')
+
+class NoViewTimer
+  include Shattered::Model
+  timer :every => :frame, :action => :update
+  attr_reader :timer_updated
+  def update
+    @timer_updated=true
+  end
+end
+
+class MovingTimer < NoViewTimer
+end
+
+class Color
+  include Shattered::Model
+  attr_accessor :luminance
+end
+
+
+class Guard 
+  include Shattered::Model
+  timer :every => :frame, :action => :update
+  attr_reader :updated
+  
+  def block
+  end
+  
+  def update
+    @updated=true
+  end
+end
+
+class DemonCatGuard < Guard
+  attr_reader :number_of_times_updated
+  
+  def initialize
+    @number_of_times_updated=0
+  end
+  def update
+    super
+    @number_of_times_updated+=1
+  end
+end
+
+class NoView 
+  include Shattered::Model
+end
+
+class Single 
+  include Shattered::Model
+  attr_reader :single
+  def hit
+    @single = true
+  end
+end
+
+class Double < Single
+  attr_reader :double
+  
+  def hit
+    @double = true
+    super
+  end
+end
+
+class HasEquals 
+  include Shattered::Model
+  def equals=(equals)
+  end
+end
+
+class HasAlot 
+  include Shattered::Model
+  def give_away(&block)
+    block.call
+  end
+end
+
+class BaseTest < Test::Unit::TestCase
+  
+ 
+  #Make sure View doesn't get called twice, and super works correctly.
+  def test_inheritance_and_return_values
+    double = Double.new
+    double.hit
+    assert(double.single)
+    assert(double.double)
+  end
+  
+  # Check if we can call blocks from Model after redefining the methods
+  def test_blocks
+    amount= nil
+    cash_face = HasAlot.new
+    cash_face.give_away { amount = "everything" }
+    assert_equal("everything", amount)
+  end
+  
+  # Ensure that subscription to timer events works
+  def test_all_timer_events
+    @timer = NoViewTimer.new
+    @timer.timer.update(0)
+    assert(@timer.timer_updated)
+    
+    @timer = MovingTimer.new
+    @timer.timer.update(0)
+    assert(@timer.timer_updated)
+  end
+  
+  #Ensure that we are only getting one method invocation even when super is invoked
+  def test_single_invocation_on_super
+    @kitty = DemonCatGuard.new
+    @kitty.update
+    assert_equal(1,@kitty.number_of_times_updated)
+  end
+
+end

data/test/unit/shattered_model/timed_event_test.rb

@@ -0,0 +1,79 @@
+require File.dirname(__FILE__) + "/../test_helper"
+
+include Shattered::Timer
+
+class ContinuousTimedEventTest < Test::Unit::TestCase
+  def setup
+    @adder = ContinuousTimedEvent.new(self,3) do
+      @number ||= 0
+      @number += 1
+    end
+  end
+  
+  def test_continuity
+    assert(!defined?(@number))
+    @adder.update(3)
+    assert_equal(1,@number)
+    @adder.update(3)
+    assert_equal(2,@number)
+  end
+  
+  def test_carry_over
+    @adder.update(4)
+    assert_equal(1,@number)
+    @adder.update(2)
+    assert_equal(2,@number)
+  end
+  
+  
+  def test_frame
+    @event = ContinuousTimedEvent.new(self,:frame) do |time_elapsed|
+      @frame_time = time_elapsed
+    end
+    @event.update(123)
+    assert_equal(123, @frame_time)
+    @event.update(234)
+    assert_equal(234, @frame_time)
+  end
+end
+
+class TimedEventTest < Test::Unit::TestCase
+  def setup
+    @event = TimedEvent.new(self,3) do
+      @event_proceeded = true
+    end
+  end
+  def test_update
+    @event.update(1.5)
+    assert_equal(1.5, @event.time_remaining)
+  end
+  def test_procession
+    @event.update(3)
+    assert(@event_proceeded)
+    assert(@event.processed?)
+  end
+  def test_after_procession
+    @event.update(3)
+    @event_proceeded = false
+    @event.update(1)
+    assert(!@event_proceeded)
+  end
+  def test_non_procession    
+    @event.update(1)
+    assert(@event_proceeded.nil?)
+    assert(!@event.processed?)
+  end
+  def test_reset
+    @event.update(1)
+    assert_equal(2,@event.time_remaining)
+    @event.reset
+    assert_equal(3,@event.time_remaining)
+  end
+  def test_frame
+    @event = TimedEvent.new(self,:frame) do |time_elapsed|
+      @frame_time = time_elapsed
+    end
+    @event.update(123)
+    assert_equal(123, @frame_time)
+  end
+end

data/test/unit/shattered_model/timer_test.rb

@@ -0,0 +1,325 @@
+require File.dirname(__FILE__) + '/../test_helper'
+
+class Bullet 
+  include Shattered::Timer
+  timer :every => :frame, :action => :update
+  attr_reader :updated
+  def update(time_elapsed)
+    @updated=true
+  end
+end
+
+class Gun 
+  include Shattered::Timer
+  timer :every => :frame, :action => :update
+  attr_reader :updated, :bullet
+  
+  def initialize
+    @bullet = Bullet.new
+  end
+  
+  def update(time_elapsed)
+    @updated=true
+  end
+  
+  def create_bullet
+    Bullet.new
+  end
+end
+
+class ShootState
+  include Shattered::Timer
+  timer :every => :frame, :action => :update
+  attr_accessor :update_order
+  
+  def initialize
+    @gun = Gun.new
+  end
+  
+  
+  def update
+    @update_order = :last if gun.bullet.updated
+  end
+
+  def gun
+    @gun
+  end
+  
+end
+
+# To test timer :if
+class Beetle
+  include Shattered::Timer
+  { :eat => true,
+    :fly => :has_wings?,
+    :talk => false
+  }.each_pair do |action, condition|
+    timer :every => :frame, :action => action, :if => condition 
+  end
+  timer :every => :frame, :action => :reproduce, :unless => :sterile?
+  
+  attr_reader :eaten, :flying, :reproduce
+  attr_writer :sterile, :has_wings
+  
+  def eat
+    @eaten = true
+  end 
+  
+  def fly
+    @flying = true
+  end
+  
+  def reproduce
+    @reproduced = true
+  end
+  
+  def sterile?
+    @sterile
+  end
+  
+  def has_wings?
+    @has_wings
+  end
+end
+
+class Bomb 
+  include Shattered::Timer
+  attr_reader :exploded, :ticks, :frame_time
+  timer :in => 1, :action => :explode
+  timer :every => 0.5, :action => :tick 
+  timer :every => :frame, :action => :frame
+  def explode
+    @exploded = true
+  end
+  def tick
+    @ticks ||= 0
+    @ticks += 1
+  end
+  def frame(time_elapsed)
+    @frame_time = time_elapsed
+  end
+end
+
+class Quarrelsome 
+  include Shattered::Timer
+  timer :in => 0.1, :action => :argument_error
+  
+  def argument_error
+    raise ArgumentError, "This error should go through"
+  end
+  
+end
+
+class JetPack 
+  include Shattered::Timer
+  attr_reader :name, :volume, :location, :boost
+  timer :in => 1.seconds, :action => { :play => ["Blast", {:volume => 0.8, :location => :front}] } 
+  timer :in => 2.seconds, :action => { :booster => 10 } 
+#  timer :in => 10.seconds, :action => { :powerup }  This syntax is not allowed
+  timer :in => 3.seconds, :action => { :booster => [] }
+  timer :in => 4.seconds, :action => { :booster => [10] }
+  
+  def booster(b = nil)
+    @boost = b
+  end  
+  def play(name, options)
+    @name = name
+    @volume = options[:volume]
+    @location = options[:location]
+  end
+end
+
+class BaseTimerTest < Test::Unit::TestCase
+
+  attr_reader :bomb
+  def setup
+    @bomb = Bomb.new
+    @state = ShootState.new
+  end
+  
+  # Ensure the timer :action parameters function properly
+  def test_timer_action_with_arguments
+    @jet_pack = JetPack.new
+    @jet_pack.timer.update(1)
+    assert_equal(0.8, @jet_pack.volume)
+    assert_equal(:front, @jet_pack.location)
+    assert_equal("Blast", @jet_pack.name)
+    
+    @jet_pack.timer.update(1)
+    assert_equal(10, @jet_pack.boost)
+    
+    @jet_pack.timer.update(1)
+    assert_nil(@jet_pack.boost)
+    
+    @jet_pack.timer.update(1)
+    assert_equal(10, @jet_pack.boost)
+  end
+  
+  # Make sure that ShatteredModels get a Timer object
+  def test_timer_creation
+    assert_equal( Shattered::Timer::Timer, bomb.timer.class )
+    assert_equal( 3, bomb.timer.events_remaining.length )
+  end
+  
+  #Make sure that :every events get called
+  def test_tick
+    bomb.timer.update(0.5)
+    assert_equal( 1, bomb.ticks)
+    bomb.timer.update(0.5)
+    assert_equal( 2, bomb.ticks)
+  end
+  
+  # Ensure :in events get called
+  def test_explode
+    bomb.timer.update(3)
+    assert(bomb.exploded)
+  end
+  
+  # Allow access to frame tick time for :every event
+  def test_frame
+    bomb.timer.update(0.123)
+    assert_equal(123, (bomb.frame_time*1000).round)
+  end
+  
+  # Make sure that :every events can take 0 or 1 params
+  def test_argument_error
+    quarrel = Quarrelsome.new
+    assert_raises(ArgumentError, "Event should raise an exception") do
+      quarrel.timer.update(0.1)      
+    end
+    quarrel.timer.destroy
+  end
+  
+  # Testing if clause
+  def test_if
+    bug = Beetle.new
+    bug.has_wings=false
+    bug.sterile=true
+    assert(!bug.eaten)
+    Shattered::Timer::Timer.update(0)
+    assert(bug.eaten)
+  end
+  
+end
+
+
+
+class TimerTest < Test::Unit::TestCase
+
+  attr_reader :waiter
+  def setup
+    @waiter = Shattered::Timer::Timer.new self
+  end
+  
+  # Tests multiple events' lifetime
+  def test_stacking
+    waiter.in(2) do
+    end
+    waiter.in(3) do
+    end
+    waiter.update(1)
+    assert_equal(2, waiter.events_remaining.length)
+  end
+  
+  # Tests passings blocks to :in events
+  def test_block
+    waiter.in(1) do
+     @first = true
+    end
+    waiter.in(2) do
+     @second = true
+    end
+    waiter.in(3) do
+      @third = true
+    end
+    waiter.update(2)
+    assert(@first)
+    assert(@second)
+    assert(@third.nil?)
+  end
+  
+  # Tests nesting of :in events
+  def test_nesting
+    waiter.in(2) do 
+      waiter.in(1) {}
+      waiter.in(1) {}
+    end
+    assert_equal(1, waiter.events_remaining.length)
+    waiter.update(2)
+    assert_equal(2,waiter.events_remaining.length)
+  end
+  
+  # Make sure Timer can handle nested every events
+  def test_every
+    waiter.every(2) do
+      waiter.every(2) {}
+      waiter.every(2) {}
+    end
+    assert_equal(1, waiter.events_remaining.length)
+    waiter.update(2)
+    assert_equal(3, waiter.events_remaining.length)
+  end
+
+  # Makes sure timer can handle multiple timed events, mixing :in and :every
+  def test_multiple_events
+    waiter.in(2) do
+      @in = true
+    end
+    waiter.every(1) do
+      @count ||= 0
+      @count += 1
+    end
+    waiter.update(1)
+    assert(@in.nil?)
+    assert_equal(1,@count)
+    waiter.update(1)
+    assert_equal(2,@count)
+    assert(@in)
+  end
+  
+  # Ensure if and unless work for instance functions.
+  def test_if
+    waiter.in(1.second, :if => true) do
+      @served=:if
+    end
+    waiter.in(2.seconds, :unless => false) do
+      @served=:unless
+    end
+    {:unless => true, :if => false}.each_pair do |action, condition|
+      waiter.in(3.seconds, action => condition) do
+        raise ShatteredModel::Error, "This should not happen"
+      end
+    end
+    waiter.update(1)
+    assert_equal(:if, @served)
+    waiter.update(1)
+    assert_equal(:unless,@served)
+    waiter.update(1)
+  end
+  
+  # See if we can pass arguments to an if function
+  # def test_if_arguments  
+  #   waiter.in(1.second, :unless => {:drunk => :today}) do
+  #     @worked=true
+  #   end
+  #   waiter.every(1.second,)
+  # end
+  
+  # Make sure we get the timer event object when creating a new event.
+  def test_timer_object
+    timer = waiter.in(1) {}
+    assert_kind_of(Shattered::Timer::TimedEvent, timer)
+    timer = waiter.every(1) {}
+    assert_kind_of(Shattered::Timer::ContinuousTimedEvent, timer)
+  end
+  
+  # See if we can stop a timer
+  def test_timer_halt
+    timer = waiter.every(1) do
+      @updated = true
+    end
+    timer.stop
+    timer.update(1)
+    assert_nil(@updated)
+  end
+end