redshift 1.3.15

data/test/test_inherit_event.rb

@@ -0,0 +1,74 @@
+#!/usr/bin/env ruby
+
+require 'redshift'
+
+include RedShift
+
+=begin
+
+Tests events with inheritance.
+
+=end
+
+class Super < Component
+  state :S1
+  transition Enter => S1 do
+    event :e1 => 1
+  end
+end
+
+class Sub < Super
+  state :S2
+  transition S1 => S2 do
+    event :e2 => 2
+  end
+end
+
+class EventTestComponent < Component
+  link :sub => Sub
+  state :T1, :T2
+  setup {@result = []; self.sub = create(Sub)}
+  transition Enter => T1 do
+    sync :sub => :e1
+    action {@result << sub.e1}
+  end
+  transition T1 => T2 do
+    sync :sub => :e2
+    action {@result << sub.e2}
+  end
+
+  def assert_consistent test
+    test.assert_equal([1,2], @result)
+  end
+end
+
+#-----#
+
+require 'test/unit'
+
+class TestInheritEvent < Test::Unit::TestCase
+  def setup
+    @world = World.new
+    @world.time_step = 0.1
+  end
+  
+  def teardown
+    @world = nil
+  end
+  
+  def test_inherit_event
+    testers = []
+    ObjectSpace.each_object(Class) do |cl|
+      if cl <= EventTestComponent and
+         cl.instance_methods.include? "assert_consistent"
+        testers << @world.create(cl)
+      end
+    end
+    
+    @world.run
+    
+    for t in testers
+      t.assert_consistent self
+    end
+  end
+end

data/test/test_inherit_flow.rb

@@ -0,0 +1,139 @@
+#!/usr/bin/env ruby
+
+require 'redshift'
+
+include RedShift
+
+#-- Flow-specific test classes --#
+
+class FlowTestComponent < Component
+  def initialize(*args)
+    super
+    @start_time = world.clock
+  end
+end
+
+#     ------------------------
+#     Per equation granularity
+
+class Flow_1 < FlowTestComponent
+  flow { alg "x = 0", "y = 1", "z = 2" }
+end
+
+class Flow_1_1 < Flow_1
+  flow { alg "x = 3" }        # override one of several flows
+  def assert_consistent test
+    test.assert_equal([3,1,2], [x,y,z])
+  end
+end
+
+class Flow_1_2 < Flow_1
+  flow { alg "w = 4" }        # add a new, unrelated flow
+  def assert_consistent test
+    test.assert_equal([0,1,2,4], [x,y,z,w])
+  end
+end
+
+class Flow_1_2_1 < Flow_1_2
+  flow { alg "w = 5" }        # ...and override it in a subclass
+  def assert_consistent test
+    test.assert_equal([0,1,2,5], [x,y,z,w])
+  end
+end
+
+#     ----------------------------------
+#     Overriding the type of an equation
+
+class Flow_2 < FlowTestComponent
+  flow { alg "x = 0" }
+end
+
+class Flow_2_1 < Flow_2
+  flow { diff "x' = 1" }
+  def assert_consistent test
+    test.assert_in_delta(world.clock - @start_time, x, 0.00001)
+  end
+end
+
+class Flow_2_1_1 < Flow_2_1
+  flow { alg "x = -1" }
+  def assert_consistent test
+    test.assert_in_delta(-1, x, 0.00001)
+  end
+end
+
+#     ---------------------
+#     Per state granularity
+
+class Flow_3 < FlowTestComponent
+  state :S1, :S2
+  
+  flow S1 do diff "x'=1" end
+  flow S2 do diff "x'=-1" end
+  
+  transition Enter => S1
+  transition S1 => S2 do guard {x >= 1} end
+  transition S2 => S1 do guard {x <= 0} end
+  
+  def assert_consistent test
+    test.assert_in_delta(0.5, x, 0.5 + world.time_step)
+  end
+end
+
+class Flow_3_1 < Flow_3
+  flow S2 do diff "x'=1" end        # override in just one state
+  
+  transition Enter => S1
+  transition S1 => S2 do guard {x >= 1} end
+  transition S2 => S1 do guard {x <= 0} end
+  
+  def assert_consistent test
+    test.assert(state == S2 || world.clock <= 1)
+  end
+end
+
+#     ---------------------
+#     Overriding a flow referenced in a flow in the parent class
+
+class Flow_4 < FlowTestComponent
+  flow do diff "x' = y", "y' = 1" end
+end
+
+class Flow_4_1 < Flow_4
+  flow do diff "y' = -1" end
+  def assert_consistent test
+    test.assert_in_delta(-0.5*world.clock**2, x, 1E-10)
+  end
+end
+
+## other kinds of alg and diff flows (cached-alg, euler, cflow, etc.)
+
+#-----#
+
+require 'test/unit'
+
+class TestInheritFlow < Test::Unit::TestCase
+  
+  def setup
+    @world = World.new
+    @world.time_step = 0.1
+  end
+  
+  def teardown
+    @world = nil
+  end
+  
+  def test_inherit_flow
+    testers = []
+    ObjectSpace.each_object(Class) do |cl|
+      if cl <= FlowTestComponent and
+         cl.instance_methods.include? "assert_consistent"
+        testers << @world.create(cl)
+      end
+    end
+    
+    testers.each { |t| t.assert_consistent self }
+    @world.run 100
+    testers.each { |t| t.assert_consistent self }
+  end
+end

data/test/test_inherit_link.rb

@@ -0,0 +1,65 @@
+#!/usr/bin/env ruby
+
+require 'redshift'
+
+include RedShift
+
+class LinkTestComponent < Component
+  class Foo < Component; end
+  link :foo => Foo
+end
+
+class Link_1 < LinkTestComponent
+  setup {self.foo = create Foo}
+  def assert_consistent test
+    test.assert_equal(LinkTestComponent::Foo, foo.class)
+  end
+end
+
+class Link_2 < LinkTestComponent
+  class Bar < Foo; end
+###  link :foo => Bar ### ==> "already exists"
+end
+
+# test forward references
+class Link_FwdRef < Component
+  link :fwd => :FwdRefClass
+  setup {self.fwd = create FwdRefClass}
+  def assert_consistent test
+    test.assert_equal(1, fwd.x)
+  end
+end
+
+class FwdRefClass < Component
+  flow {alg "x = 1"}
+end
+
+#-----#
+
+require 'test/unit'
+
+class TestInheritLink < Test::Unit::TestCase
+  
+  def setup
+    @world = World.new
+    @world.time_step = 0.1
+  end
+  
+  def teardown
+    @world = nil
+  end
+  
+  def test_inherit_link
+    testers = []
+    ObjectSpace.each_object(Class) do |cl|
+      if cl <= LinkTestComponent and
+         cl.instance_methods.include? "assert_consistent"
+        testers << @world.create(cl)
+      end
+    end
+    
+    testers.each { |t| t.assert_consistent self }
+    @world.run 100
+    testers.each { |t| t.assert_consistent self }
+  end
+end

data/test/test_inherit_setup.rb

@@ -0,0 +1,56 @@
+#!/usr/bin/env ruby
+
+require 'redshift'
+
+include RedShift
+
+#-- Setup and default-specific test classes --#
+
+class A; end
+class B < A; end
+
+class SetupTestComponent < Component
+  attr_reader :x, :y, :z, :xx, :yy, :zz, :other
+
+  setup {@x = 0; @y = 1; @other = make_other}
+  defaults {@xx = 0; @yy = 1}
+  
+  def make_other  # see inherit.txt
+    A.new
+  end
+
+end
+
+class Setup_1 < SetupTestComponent
+
+  setup {@y = 2; @z = 3}
+  defaults {@yy = 2; @zz = 3}
+
+  def make_other
+    B.new
+  end
+
+end
+
+#-----#
+
+require 'test/unit'
+
+class TestInheritSetup < Test::Unit::TestCase
+  
+  def setup
+    @world = World.new
+    @world.time_step = 0.1
+  end
+  
+  def teardown
+    @world = nil
+  end
+  
+  def test_inherit_setup
+    t = @world.create(Setup_1)
+    assert_equal([0,2,3], [t.x,t.y,t.z])
+    assert_equal([0,2,3], [t.xx,t.yy,t.zz])
+    assert_equal(B, t.other.class)
+  end
+end

data/test/test_inherit_state.rb

@@ -0,0 +1,66 @@
+#!/usr/bin/env ruby
+
+require 'redshift'
+
+include RedShift
+
+class StateTestComponent < Component
+end
+
+class State_Inherit < StateTestComponent
+  class Sub < self
+  end
+  state :A, :B, :C
+  link :sub => Sub
+  
+  def assert_consistent test
+    test.assert_equal(self.states, create(Sub).states)
+  end
+end
+
+# repeating a state declaration is an error
+
+###class State_Duplicate < StateTestComponent
+###  state :A
+###  def assert_consistent test
+###    c = Class.new(self.class)
+###    class << self
+###      undef_method :assert_consistent
+###    end
+###    test.assert_exception(RuntimeError) {
+###      c.state :A
+###    }
+###  end
+###end
+
+#-----#
+
+require 'test/unit'
+
+class TestInheritState < Test::Unit::TestCase
+  
+  def setup
+    @world = World.new
+    @world.time_step = 0.01
+  end
+  
+  def teardown
+    @world = nil
+  end
+  
+  def test_inherit_state
+    testers = []
+    ObjectSpace.each_object(Class) do |cl|
+      if cl <= StateTestComponent and
+         cl.instance_methods.include? "assert_consistent"
+        testers << @world.create(cl)
+      end
+    end
+    
+    testers.each { |t| t.assert_consistent self }
+    
+#    @world.run 1000 do
+#      testers.each { |t| t.assert_consistent self }
+#    end
+  end
+end

data/test/test_inherit_transition.rb

@@ -0,0 +1,168 @@
+#!/usr/bin/env ruby
+
+require 'redshift'
+
+include RedShift
+
+#-- Transition-specific test classes --#
+
+class TransTestComponent < Component
+  def initialize(*args)
+    super
+    @t = world.clock
+  end
+end
+
+#     --------------------
+#     Per edge granularity
+
+class Trans_1 < TransTestComponent
+  defaults do
+    @x = 0
+  end
+  
+  state :A, :B, :C, :D
+  transition Enter => A  
+  transition A => B, B => C, C => D do
+    name :foo
+    action { @x += 1 }
+  end
+end
+
+class Trans_1_1 < Trans_1
+  transition B => C do
+    name :foo
+    action { }            # override one of several transitions
+  end
+  def assert_consistent test
+    test.assert_equal(state == Enter ? 0 : 2, @x, "@x = #@x, state = #{state}")
+  end
+end
+
+class Trans_1_2 < Trans_1
+  state :F                # E is the constant 2.718281828
+  transition D => F do
+    action { @x += 1 }    # add one new transition
+  end
+  def assert_consistent test
+    test.assert_equal(state == Enter ? 0 : 4, @x)
+  end
+end
+
+class Trans_1_3 < Trans_1
+  transition B => C do
+    name :foo
+    guard { false }
+    action { 1/0 }        # this shouldn't happen
+  end
+end
+
+class Trans_1_3_1 < Trans_1_3
+  transition B => C do
+    name :foo
+    # neither the guard nor the action of the superclass is inherited
+  end
+  def assert_consistent test
+    test.assert_equal(state == Enter ? 0 : 2, @x)
+  end
+end
+
+#     ----------------------------
+#     Redundant state declarations
+
+class Trans_2 < TransTestComponent
+  state :A, :B, :C, :D
+  transition Enter => A, A => B, C => D
+end
+
+class Trans_2_1 < Trans_2
+  transition B => C
+  def assert_consistent test
+    test.assert(state == Enter || state == D,
+                "State is #{state.name}, not Enter or D")
+  end
+end
+
+#     ------
+#     Events
+
+# events are inherited
+
+class Trans_3 < TransTestComponent
+  state :A
+  transition Enter => A do
+    event :e => literal("fred")
+  end
+end
+
+class Trans_3_1 < Trans_3
+end
+
+class Trans_3a < TransTestComponent
+  state :A
+  link :c
+  setup {self.c = create(Trans_3_1)}
+  
+  transition Enter => A do
+    sync :c => :e
+    action { @worked = (c.e == "fred") }
+  end
+  def assert_consistent test
+    test.assert(world.clock == 0 || @worked)
+  end
+end
+
+# priority of transitions is by subclasses first
+class Trans_4a < TransTestComponent
+  state :A, :B
+  transition Enter => A do name "A" end
+    # Note: assign a name or else B's transition will simply replace A's,
+    # since they will both be named "Always", and that won't be a useful test.
+  def assert_consistent test
+    test.flunk unless state == A or state == Enter
+  end
+end
+class Trans_4b < Trans_4a
+  transition Enter => B do name "B" end
+  def assert_consistent test
+    test.flunk("state was #{state}") unless state == B or state == Enter
+  end
+end
+
+#-----#
+
+require 'test/unit'
+
+class TestInheritTrans < Test::Unit::TestCase
+  
+  def setup
+    @world = World.new
+    @world.time_step = 0.1
+  end
+  
+  def teardown
+    @world = nil
+  end
+  
+  def test_inherit_trans
+    testers = []
+    ObjectSpace.each_object(Class) do |cl|
+      if cl <= TransTestComponent and
+         cl.instance_methods.include? "assert_consistent"
+        testers << @world.create(cl)
+      end
+    end
+    
+    for t in testers
+      assert_equal(RedShift::Enter, t.state)
+      t.assert_consistent self
+    end
+    
+    @world.run 100
+    
+    for t in testers
+      assert(RedShift::Enter != t.state, "#{t.class} didn't leave Enter!")
+      t.assert_consistent self
+    end
+  end
+end