redshift 1.3.15

data/test/test_numerics.rb

@@ -0,0 +1,34 @@
+#!/usr/bin/env ruby
+
+require 'mathn' # Use rationals for 1/2 etc.
+
+require 'test/unit'
+
+require 'redshift'
+
+include RedShift
+
+class Timer < Component
+  attr_accessor :x
+  flow { diff " x' = 1 " }
+end
+
+class TestNumerics < Test::Unit::TestCase
+  
+  def setup
+    @world = World.new
+    @world.time_step = 0.1
+  end
+  
+  def teardown
+    @world = nil
+  end
+  
+  def test_rational
+    c = @world.create(Timer) { |timer| timer.x = 1/2}
+    @world.run 100
+    assert_in_delta(10.5, c.x, 0.000001)
+  end
+end
+
+## should test NaN, Inf, precision, etc.

data/test/test_queue.rb

@@ -0,0 +1,90 @@
+require 'redshift'
+require 'test/unit'
+
+class TestQueue < Test::Unit::TestCase
+  class Receiver < RedShift::Component
+    queue :q
+    transition Enter => Exit do
+      wait :q
+    end
+  end
+  
+  class Sender < RedShift::Component
+    link :receiver => RedShift::Component
+    flow {diff "t'=1"}
+    transition Enter => Exit do
+      guard "t>1"
+      action do 
+        receiver.q << "hello"
+      end
+    end
+  end
+  
+  def setup
+    @world = RedShift::World.new
+    @s = @world.create(Sender)
+    @r = @world.create(Receiver)
+    @s.receiver = @r
+  end
+  
+  def test_msg_received
+    @world.evolve 0.9
+    assert_equal(RedShift::Component::Enter, @r.state)
+    assert(@world.queue_sleep[@r])
+    @world.evolve 0.2
+    assert_equal(RedShift::Component::Exit, @r.state)
+    assert_equal("hello", @r.q.pop)
+  end
+end
+
+class TestQueueAndStrict < Test::Unit::TestCase
+  class Receiver < RedShift::Component
+    queue :q
+    strictly_continuous :x
+    transition Enter => Exit do
+      guard "x>0"
+    end
+    transition Enter => Exit do
+      wait :q
+    end
+  end
+  
+  class Sender < RedShift::Component
+    link :receiver => RedShift::Component
+    flow {diff "t'=1"}
+    state :S1
+    transition Enter => S1 do
+      guard "t>1"
+      # this transition gives receiver a chance to go into strict sleep,
+      # if that bug exists in redshift
+    end
+    transition S1 => Exit do
+      action do 
+        receiver.q << "hello"
+      end
+    end
+  end
+  
+  def setup
+    @world = RedShift::World.new
+    @s = @world.create(Sender)
+    @r = @world.create(Receiver)
+    @s.receiver = @r
+  end
+  
+  def test_msg_received
+    @world.evolve 0.9
+    assert_equal(RedShift::Component::Enter, @r.state)
+    while @r.state == RedShift::Component::Enter do
+      # Can't be in queue sleep because of the x>0 guard.
+      assert(!@world.queue_sleep[@r])
+      @world.run 1
+    end
+    
+    # in 1 step, @r should *both* receive the message and exit,
+    # which shows that it did not go into strict sleep after the first
+    # pass thru discrete update
+    assert_equal(RedShift::Component::Exit, @r.state)
+    assert_equal("hello", @r.q.pop)
+  end
+end

data/test/test_queue_alone.rb

@@ -0,0 +1,115 @@
+require 'redshift/queue'
+require 'test/unit'
+
+# Test queue class outside of simulation using mocked World and
+# Component classes.
+class TestQueueAlone < Test::Unit::TestCase
+  class World
+    attr_accessor :step_count, :discrete_step
+  end
+  class Component
+    attr_accessor :world, :awake
+    def inc_queue_ready_count
+      @awake = true
+    end
+    def dec_queue_ready_count
+    end
+  end
+  
+  def setup
+    @w = World.new
+    @w.step_count = 0
+    @w.discrete_step = 0
+    @c = Component.new
+    @c.world = @w
+    @q = RedShift::Queue.new @c
+  end
+  
+  def test_fifo
+    3.times do |i|
+      @q.push i
+      @w.discrete_step += 1
+    end
+    
+    a = []
+    3.times do
+      a << @q.pop
+    end
+    
+    assert_equal([0,1,2], a)
+  end
+  
+  def test_unpop
+    @q.push 1
+    x = @q.pop
+    @q.unpop x
+    assert_equal(x, @q.pop)
+  end
+  
+  def test_simultaneous_entries
+    @w.step_count = 123
+    @w.discrete_step = 42
+    a = [1,2,3]
+    a.each do |x|
+      @q.push x
+    end
+    
+    head = @q.pop
+    assert_equal(a, head)
+    @q.unpop head
+    
+    @w.discrete_step += 1
+    @q.push "some stuff"
+    assert_equal(a, @q.pop)
+  end
+  
+  def test_unpop_partial
+    @w.step_count = 123
+    @w.discrete_step = 42
+    a = [1,2,3]
+    a.each do |x|
+      @q.push x
+    end
+    
+    head = @q.pop
+    head.shift
+    @q.unpop head
+    
+    head = @q.pop
+    assert_equal([2,3], head)
+    assert_equal(RedShift::SimultaneousQueueEntries, head.class)
+    head.shift
+    @q.unpop head
+    
+    head = @q.pop
+    assert_equal(3, head)
+  end
+  
+  def test_wake
+    @c.awake = false
+    @q.push 1
+    assert_equal(true, @c.awake)
+  end
+  
+  def test_match_empty_queue
+    assert_equal(false, @q.head_matches(Object))
+  end
+    
+  def test_match_one_entry
+    @q.push("foo")
+    assert(@q.head_matches(     )) 
+    assert(@q.head_matches( /o/ ))
+    assert(@q.head_matches( String, /o/, proc {|x| x.kind_of?(String)} ))
+    
+    assert_equal(false, @q.head_matches( /z/    ))
+    assert_equal(false, @q.head_matches( Symbol ))
+    assert_equal(false, @q.head_matches( proc {false} ))
+  end
+  
+  def test_match_simultaneous_entries
+    @q.push "foo"
+    @q.push "bar"
+    assert(@q.head_matches( /foo/ ))
+    assert(@q.head_matches( /bar/ ))
+  end
+end

data/test/test_reset.rb

@@ -0,0 +1,209 @@
+#!/usr/bin/env ruby
+
+require 'redshift'
+
+include RedShift
+
+# Tests resets in transitions.
+
+class A < Component
+  constant :k1, :k2
+
+  continuous :x
+  continuous :y
+  
+  link :other => A
+  
+  state :S1, :S2
+  
+  transition Enter => S1 do
+    reset :y => 1           # literal value (float or int)
+  end
+
+  transition S1 => S2 do
+    reset :x => "other.x",  # expr value
+          :y => proc {10-y}, # proc value
+          :k1 => "y",
+          :k2 => proc {42}
+  end
+  
+  transition S2 => Exit
+end
+
+class B < Component
+  state :S1, :S2
+  
+  start S1
+  
+  flow S1 do
+    alg " x = 1 "
+  end
+  flow S2 do
+    alg " x = 2 "
+  end
+
+  transition S1 => S2 do
+    reset :x => 3
+  end
+end
+
+class C < Component
+  constant :k, :kk
+  state :S
+  transition Enter => S do
+    reset :k => "kk"
+  end
+end
+
+class ResetVarToNonFloat < Component
+  continuous :var
+  state :S
+  transition Enter => S do
+    reset :var => proc {nil}
+  end
+end
+
+class ResetLink < Component
+  link :lnk => C
+  state :S
+  transition Enter => S do
+    reset :lnk => proc {create(C) {|c| c.kk = 1.337}}
+  end
+end
+
+class ResetLinkToNil < Component
+  link :lnk => C
+  state :S
+  transition Enter => S do
+    reset :lnk => proc {nil}
+  end
+end
+
+class ResetLinkToLiteralNil < Component
+  link :lnk => C
+  state :S
+  transition Enter => S do
+    reset :lnk => nil
+  end
+end
+
+class ResetLinkToWrongType < Component
+  link :lnk => C
+  state :S
+  transition Enter => S do
+    reset :lnk => proc {create(A)}
+  end
+end
+
+class Emitter < Component
+  transition Enter => Exit do
+    event :e => 42.0
+  end
+end
+
+class Receiver < Component
+  link :c => Emitter
+  constant :result
+  transition Enter => Exit do
+    sync :c => :e
+    event :e => 0.42
+    reset :result => "e + c.e"
+  end
+end
+
+require 'test/unit'
+
+class TestReset < Test::Unit::TestCase
+  
+  def setup
+    @world = World.new
+    @world.time_step = 0.1
+  end
+  
+  def teardown
+    @world = nil
+  end
+  
+  def test_reset
+    a1 = @world.create(A)
+    a2 = @world.create(A)
+    
+    a1.other = a2
+    a2.other = a1
+    
+    a1.x = v1 = 5
+    a2.x = v2 = 1.23
+    
+    @world.run 1
+    
+    assert_equal(v2, a1.x)
+    assert_equal(v1, a2.x)
+    
+    assert_equal(9, a1.y)
+    assert_equal(9, a2.y)
+    
+    assert_equal(1, a1.k1)
+    assert_equal(42, a1.k2)
+  end
+  
+  def test_reset_algebraic_flow_error
+    b = @world.create(B)
+
+    assert_equal(B::S1, b.state)
+    assert_equal(1, b.x)
+
+    @world.run 1
+
+    assert_equal(B::S2, b.state)
+    assert_equal(2, b.x)
+  end
+  
+  # This is to test the expansion of the reset value cache.
+  def test_many_constant_resets
+    ## need to get the limit as a const
+    n = World::CV_CACHE_SIZE + 10
+    cs = (0..n).map {|i| @world.create(C) {|c| c.kk = i}}
+    @world.run 1
+    cs.each do |c|
+      assert_equal(c.kk, c.k)
+    end
+  end
+  
+  def test_reset_var_to_wrong_type
+    rl = @world.create(ResetVarToNonFloat)
+    assert_raises(VarTypeError) {@world.run 1}
+  end
+  
+  def test_reset_link
+    rl = @world.create(ResetLink)
+    assert_equal(nil, rl.lnk)
+    @world.run 1
+    assert_equal(C, rl.lnk.class)
+    assert_equal(1.337, rl.lnk.k)
+  end
+  
+  def test_reset_link_to_nil
+    rl = @world.create(ResetLinkToNil)
+    assert_equal(nil, rl.lnk)
+    @world.run 1
+    assert_equal(nil, rl.lnk)
+  end
+  
+  def test_reset_link_to_literal_nil
+    rl = @world.create(ResetLinkToLiteralNil)
+    assert_equal(nil, rl.lnk)
+    @world.run 1
+    assert_equal(nil, rl.lnk)
+  end
+  
+  def test_reset_link_to_wrong_type
+    rl = @world.create(ResetLinkToWrongType)
+    assert_raises(LinkTypeError) {@world.run 1}
+  end
+  
+  def test_reset_using_event_val
+    r = @world.create(Receiver) {|r| r.c = r.create(Emitter)}
+    @world.run 1
+    assert_equal(42.42, r.result)
+  end
+end