ruote-maestrodev 2.2.1

data/test/functional/eft_24_add_branches.rb

@@ -0,0 +1,98 @@
+
+#
+# testing ruote
+#
+# Fri Sep 11 16:09:32 JST 2009
+#
+
+require File.join(File.dirname(__FILE__), 'base')
+
+
+class EftAddBranchesTest < Test::Unit::TestCase
+  include FunctionalBase
+
+
+  def test_add_branches
+
+    pdef = Ruote.process_definition :name => 'test' do
+      concurrent_iterator :on => 'a, b' do
+        sequence do
+          echo '${v:i}'
+          add_branches 'c, d', :if => '${v:ii} == 0'
+        end
+      end
+    end
+
+    #noisy
+
+    wfid = @engine.launch(pdef)
+    wait_for(wfid)
+
+    assert_equal %w[ a b c d ], @tracer.to_a.sort
+  end
+
+  def test_add_branches_times
+
+    pdef = Ruote.process_definition :name => 'test' do
+      concurrent_iterator :times => 3 do
+        sequence do
+          echo '${v:i}'
+          add_branches 2, :if => '${v:i} == 1'
+        end
+      end
+    end
+
+    #noisy
+
+    wfid = @engine.launch(pdef)
+    wait_for(wfid)
+
+    assert_equal %w[ 1 2 3 4 5 ], @tracer.to_a.sort
+  end
+
+  def test_add_branches_times_and_whatever
+
+    pdef = Ruote.process_definition :name => 'test' do
+      concurrent_iterator :times => 3 do
+        sequence do
+          echo '${v:i}'
+          add_branches 'a, b', :if => '${v:i} == 1'
+        end
+      end
+    end
+
+    #noisy
+
+    wfid = @engine.launch(pdef)
+    wait_for(wfid)
+
+    assert_equal %w[ 1 2 3 a b ], @tracer.to_a.sort
+  end
+
+  def test_add_branches_with_tag
+
+    pdef = Ruote.process_definition :name => 'test' do
+      concurrent_iterator :on => 'a, b', :to_v => 'x', :tag => 'here' do
+        sequence do
+          echo '<:${v:x}'
+          concurrent_iterator :on => '0, 1' do
+            sequence do
+              echo '>:${v:i}'
+              add_branch 'c', :ref => 'here', :if => '${v:x} == a'
+            end
+          end
+        end
+      end
+    end
+
+    #noisy
+
+    wfid = @engine.launch(pdef)
+    wait_for(wfid)
+
+    assert_equal(
+      %w[ <:a <:b <:c <:c >:0 >:0 >:0 >:0 >:1 >:1 >:1 >:1 ],
+      @tracer.to_a.sort)
+  end
+end
+

data/test/functional/eft_25_command.rb

@@ -0,0 +1,28 @@
+
+#
+# testing ruote
+#
+# Mon Sep 14 08:39:35 JST 2009
+#
+
+require File.join(File.dirname(__FILE__), 'base')
+
+
+class EftCommandTest < Test::Unit::TestCase
+  include FunctionalBase
+
+  def test_ref_to_missing_tag
+
+    pdef = Ruote.process_definition :name => 'test' do
+      sequence do
+        _break :ref => 'nemo'
+        echo 'done.'
+      end
+    end
+
+    #noisy
+
+    assert_trace 'done.', pdef
+  end
+end
+

data/test/functional/eft_26_error.rb

@@ -0,0 +1,77 @@
+
+#
+# testing ruote
+#
+# Tue Sep 15 19:26:33 JST 2009
+#
+
+require File.join(File.dirname(__FILE__), 'base')
+
+
+class EftErrorTest < Test::Unit::TestCase
+  include FunctionalBase
+
+  PDEF0 = Ruote.process_definition :name => 'test' do
+    sequence do
+      echo 'a'
+      error
+      echo 'b'
+    end
+  end
+
+  def test_error
+
+    #noisy
+
+    wfid = @engine.launch(PDEF0)
+
+    wait_for(wfid)
+
+    ps = @engine.process(wfid)
+
+    assert_equal(
+      'a', @tracer.to_s)
+    assert_equal(
+      1, ps.errors.size)
+    assert_equal(
+      '#<Ruote::ForcedError: error triggered from process definition>',
+      ps.errors.first.message)
+  end
+
+  def test_error_replay
+
+    #noisy
+
+    wfid = @engine.launch(PDEF0)
+
+    wait_for(wfid)
+
+    ps = @engine.process(wfid)
+
+    @engine.replay_at_error(ps.errors.first)
+
+    wait_for(wfid)
+
+    assert_nil @engine.process(wfid)
+    assert_equal "a\nb", @tracer.to_s
+  end
+
+  def test_error_cancel
+
+    wfid = @engine.launch(PDEF0)
+
+    wait_for(wfid)
+
+    ps = @engine.process(wfid)
+
+    sequence = ps.expressions.find { |fe| fe.fei.expid == '0_0' }
+
+    @engine.cancel_expression(sequence.fei)
+
+    wait_for(wfid)
+
+    assert_nil @engine.process(wfid)
+    assert_equal 'a', @tracer.to_s
+  end
+end
+

data/test/functional/eft_27_inc.rb

@@ -0,0 +1,280 @@
+
+#
+# testing ruote
+#
+# Sat Sep 19 12:56:16 JST 2009
+#
+
+require File.join(File.dirname(__FILE__), 'base')
+
+
+class EftIncTest < Test::Unit::TestCase
+  include FunctionalBase
+
+  def test_inc
+
+    pdef = Ruote.process_definition do
+      sequence do
+
+        set :var => 'x', :value => 0
+        set :field => 'y', :value => 0
+
+        inc 'v:x'
+        inc 'f:y'
+        inc :var => 'x'
+        inc :field => 'y'
+
+        echo '${v:x}|${f:y}'
+      end
+    end
+
+    #noisy
+
+    assert_trace '2|2', pdef
+  end
+
+  def test_inc_missing
+
+    pdef = Ruote.process_definition do
+      sequence do
+
+        inc 'v:x'
+        inc 'f:y'
+        inc :var => 'x'
+        inc :field => 'y'
+
+        echo '${v:x}|${f:y}'
+      end
+    end
+
+    #noisy
+
+    assert_trace '2|2', pdef
+  end
+
+  def test_inc_delta
+
+    pdef = Ruote.process_definition do
+      sequence do
+
+        inc 'v:x', :val => 2
+        inc 'f:y', :val => 3
+        inc 'v:z', :val => 1.0
+        inc :var => 'x', :val => '4'
+        inc :field => 'y', :val => 5
+        inc 'v:z', :val => '2.0'
+
+        echo '${v:x}|${f:y}|${v:z}'
+      end
+    end
+
+    #noisy
+
+    assert_trace '6|8|3.0', pdef
+  end
+
+  def test_inc_v_val
+
+    pdef = Ruote.process_definition do
+      sequence do
+
+        set 'v:x' => 2
+
+        inc 'v:x', :v_val => 'x'
+
+        echo '${v:x}'
+      end
+    end
+
+    #noisy
+
+    assert_trace '4', pdef
+  end
+
+  def test_inc_array
+
+    @engine.context['ruby_eval_allowed'] = true
+
+    pdef = Ruote.process_definition do
+      sequence do
+
+        set 'v:x' => %w[ alpha bravo ]
+
+        inc 'v:x', :val => 'charly'
+
+        echo '${r:fe.lv("x").join("\n")}'
+      end
+    end
+
+    #noisy
+
+    assert_trace %w[ alpha bravo charly ], pdef
+  end
+
+  def test_inc_array_head
+
+    #@engine.context['ruby_eval_allowed'] = true
+    @engine.configure('ruby_eval_allowed', true)
+
+    pdef = Ruote.process_definition do
+      sequence do
+
+        set 'v:x' => %w[ alpha bravo ]
+
+        inc 'v:x', :val => 'charly', :pos => :head
+
+        echo '${r:fe.lv("x").join("\n")}'
+      end
+    end
+
+    #noisy
+
+    assert_trace %w[ charly alpha bravo ], pdef
+  end
+
+  def test_inc_array_missing
+
+    @engine.context['ruby_eval_allowed'] = true
+
+    pdef = Ruote.process_definition do
+      sequence do
+
+        inc 'v:x', :val => 'charly'
+        inc 'v:y', :val => 'charly', :pos => :head
+
+        echo '${r:fe.lv("x").join(".")}'
+        echo '${r:fe.lv("y").join(".")}'
+      end
+    end
+
+    #noisy
+
+    assert_trace %w[ charly charly ], pdef
+  end
+
+  def test_dec
+
+    pdef = Ruote.process_definition do
+      sequence do
+
+        set :var => 'x', :value => 4
+        set :field => 'y', :value => 4
+
+        dec 'v:x'
+        dec 'f:y'
+        dec 'v:z'
+
+        echo '${v:x}|${f:y}|${v:z}'
+      end
+    end
+
+    #noisy
+
+    assert_trace '3|3|-1', pdef
+  end
+
+  def test_dec_array
+
+    @engine.context['ruby_eval_allowed'] = true
+
+    pdef = Ruote.process_definition do
+      sequence do
+
+        set 'v:x' => %w[ a b c ]
+        set 'v:y' => %w[ a b c ]
+
+        dec 'v:x'
+        dec 'v:y', :position => :head
+
+        echo '${r:fe.lv("x").join(".")}'
+        echo '${r:fe.lv("y").join(".")}'
+        echo '${v:d}'
+      end
+    end
+
+    #noisy
+
+    assert_trace %w[ a.b b.c a ], pdef
+  end
+
+  def test_dec_to
+
+    @engine.context['ruby_eval_allowed'] = true
+
+    pdef = Ruote.process_definition do
+      sequence do
+
+        set 'v:x' => %w[ a b c ]
+
+        dec 'v:x', :to_var => 'y'
+
+        echo '${r:fe.lv("x").join(".")}'
+        echo '${v:y}'
+      end
+    end
+
+    #noisy
+
+    assert_trace %w[ a.b c ], pdef
+  end
+
+  def test_dec_val
+
+    @engine.context['ruby_eval_allowed'] = true
+
+    pdef = Ruote.process_definition do
+      sequence do
+
+        set 'v:x' => %w[ a b c ]
+
+        dec 'v:x', :val => 'b'
+
+        echo '${r:fe.lv("x").join(".")}'
+        echo '${v:d}'
+      end
+    end
+
+    #noisy
+
+    assert_trace %w[ a.c b ], pdef
+  end
+
+  def test_cursor
+
+    pdef = Ruote.process_definition do
+      sequence do
+        set 'v:x' => %w[ a b c d ]
+        repeat do
+          dec 'v:x', :pos => :head
+          _break :unless => '${v:d}'
+          echo '${v:d}'
+        end
+      end
+    end
+
+    #noisy
+
+    assert_trace %w[ a b c d ], pdef
+  end
+
+  def test_bare_inc
+
+    pdef = Ruote.process_definition do
+      sequence do
+        inc
+        echo 'done.'
+      end
+    end
+
+    #noisy
+
+    wfid = @engine.launch(pdef)
+
+    wait_for(wfid)
+
+    ps = @engine.process(wfid)
+
+    assert_equal 1, ps.errors.size
+  end
+end
+