ruote 0.9.18 → 0.9.19

data/test/concurrence_test.rb

@@ -19,59 +19,59 @@ require 'openwfe/participants/storeparticipants'
 
 class ConcurrenceAndParticipantTest < Test::Unit::TestCase
 
-    def setup
-        @engine = OpenWFE::Engine.new({ 
-            :definition_in_launchitem_allowed => true })
+  def setup
+    @engine = OpenWFE::Engine.new({
+      :definition_in_launchitem_allowed => true })
+  end
+
+  #def teardown
+  #end
+
+  #
+  # concurrence test
+
+  class Hpc0 < OpenWFE::ProcessDefinition
+    concurrence do
+      #participant :alice
+      #participant :bob
+      alice
+      bob
     end
+  end
 
-    #def teardown
-    #end
+  def test_hpc_0
 
-    #
-    # concurrence test
+    @hpAlice = OpenWFE::HashParticipant.new
+    @hpBob = OpenWFE::HashParticipant.new
 
-    class Hpc0 < OpenWFE::ProcessDefinition
-        concurrence do
-            #participant :alice
-            #participant :bob
-            alice
-            bob
-        end
-    end
-
-    def test_hpc_0
+    @engine.register_participant :alice, @hpAlice
+    @engine.register_participant :bob, @hpBob
 
-        @hpAlice = OpenWFE::HashParticipant.new
-        @hpBob = OpenWFE::HashParticipant.new
+    @engine.launch Hpc0
 
-        @engine.register_participant :alice, @hpAlice
-        @engine.register_participant :bob, @hpBob
+    sleep 0.100
 
-        @engine.launch Hpc0
+    assert_equal @hpAlice.size, 1
+    assert_equal @hpBob.size, 1
+  end
 
-        sleep 0.100
+  def test_1
 
-        assert_equal @hpAlice.size, 1
-        assert_equal @hpBob.size, 1
+    @engine.register_participant :alice do |workitem|
+      puts "alice in"
+      sleep 0.100
+      puts "alice out"
+    end
+    @engine.register_participant :bob do |workitem|
+      puts "bob in"
+      sleep 0.100
+      puts "bob out"
     end
 
-    def test_1
-
-        @engine.register_participant :alice do |workitem|
-            puts "alice in"
-            sleep 0.100
-            puts "alice out"
-        end
-        @engine.register_participant :bob do |workitem|
-            puts "bob in"
-            sleep 0.100
-            puts "bob out"
-        end
-
-        @engine.launch Hpc0
+    @engine.launch Hpc0
 
-        sleep 2
-    end
+    sleep 2
+  end
 
 end
 

data/test/condition_test.rb

@@ -7,149 +7,163 @@
 # Sun Oct 29 16:18:25 JST 2006
 #
 
+require 'rubygems'
+
 require 'test/unit'
 
 require 'rutest_utils'
 
+require 'openwfe/rudefinitions'
+require 'openwfe/expressions/rprocdef'
 require 'openwfe/expressions/condition'
 
+
 #
 # testing expression conditions
 #
-
 class ConditionTest < Test::Unit::TestCase
-    include OpenWFE::ConditionMixin
 
-    def setup
-        @debug = false
-    end
+  include OpenWFE::ConditionMixin
+  include OpenWFE::OwfeServiceLocator
 
-    #def teardown
-    #end
 
-    def test_0
+  def setup
 
-        #@debug = true
+    @debug = false
 
-        assert_t "true"
-        assert_F "false"
+    @application_context = {}
+    @application_context = {
+      :s_tree_checker => OpenWFE::TreeChecker.new(nil, @application_context)
+    }
+  end
 
-        assert_t "1 == 1"
+  #def teardown
+  #end
 
-        assert_t "'a' == 'a'"
-        assert_t '"a" == "a"'
+  def test_0
 
-        assert_t "a == a"
-        assert_F "'a' == a"
+    #@debug = true
 
-        #assert_t "!= ''"
+    assert_t "true"
+    assert_F "false"
 
-        assert_F " == 1 "
-        assert_F " == 1"
-        assert_F "== 1"
-    end
+    assert_t "1 == 1"
 
-    def test_0b
+    assert_t "'a' == 'a'"
+    assert_t '"a" == "a"'
 
-        #@debug = true
+    assert_t "a == a"
+    assert_F "'a' == a"
 
-        assert_t "a"
-        assert_F ""
-    end
+    #assert_t "!= ''"
 
-    def test_1
+    assert_F " == 1 "
+    assert_F " == 1"
+    assert_F "== 1"
+  end
 
-        #@debug = true
+  def test_0b
 
-        assert_set_t "1 is set"
-        assert_set_t "1 set"
-        assert_set_F "1 is not set"
-        assert_set_F "1 not set"
+    #@debug = true
 
-        assert_set_t " is not set"
-        assert_set_t " not set"
-        assert_set_F " is set"
-        assert_set_F " set"
+    assert_t "a"
+    assert_F ""
+  end
 
-        assert_t "1 is set"
-        assert_t "1 set"
-        assert_F "1 is not set"
-        assert_F "1 not set"
+  def test_1
 
-        assert_t " is not set"
-        assert_t " not set"
-        assert_F " is set"
-        assert_F " set"
-    end
+    #@debug = true
 
-    def test_2
+    assert_set_t "1 is set"
+    assert_set_t "1 set"
+    assert_set_F "1 is not set"
+    assert_set_F "1 not set"
 
-        #@debug = true
+    assert_set_t " is not set"
+    assert_set_t " not set"
+    assert_set_F " is set"
+    assert_set_F " set"
 
-        $my_owferu_var = nil
+    assert_t "1 is set"
+    assert_t "1 set"
+    assert_F "1 is not set"
+    assert_F "1 not set"
 
-        #assert_F "f = File.open('toto', 'w'); f.puts('nada'); f.close"
-        assert_t "$my_owferu_var = 3; $my_owferu_var = 4"
+    assert_t " is not set"
+    assert_t " not set"
+    assert_F " is set"
+    assert_F " set"
+  end
 
-        target = on_jruby? ? 4 : nil
-        assert_equal target, $my_owferu_var
+  def test_2
 
-        #assert_F "fe.reply('a')"
-        assert_t "fe.reply('a')"
-    end
+    #@debug = true
+
+    $my_owferu_var = nil
+
+    #assert_F "f = File.open('toto', 'w'); f.puts('nada'); f.close"
+    assert_t "$my_owferu_var = 3; $my_owferu_var = 4"
 
-    protected
+    target = on_jruby? ? 4 : nil
+    assert_equal target, $my_owferu_var
 
-        #
-        # just for test_2
-        #
-        def reply (m)
-            @fei = nil
-        end
+    #assert_F "fe.reply('a')"
+    #assert_t "fe.reply('a')"
+  end
 
-        def assert_t (s, inv=false)
+  protected
 
-            r = eval_condition(s, nil)
+    #
+    # just for test_2
+    #
+    def reply (m)
 
-            #puts "raw r is _#{r}_" if @debug
+      @fei = nil
+    end
 
-            r = (not r) if inv
+    def assert_t (s, inv=false)
 
-            assert r, ">#{s}< should have evaluated to _#{not inv}_"
-        end
+      r = eval_condition(s, nil)
 
-        def assert_F (s)
+      #puts "raw r is _#{r}_" if @debug
 
-            assert_t s, true
-        end
+      r = (not r) if inv
 
-        def assert_set_t (s, inv=false)
+      assert r, ">#{s}< should have evaluated to _#{not inv}_"
+    end
 
-            r = eval_set s
-            r = (not r) if inv
+    def assert_F (s)
 
-            assert r, ">#{s}< should have evaluated to _#{not inv}_"
-        end
+      assert_t s, true
+    end
 
-        def assert_set_F (s)
+    def assert_set_t (s, inv=false)
 
-            assert_set_t s, true
-        end
+      r = eval_set s
+      r = (not r) if inv
 
-        #def evalc (s)
-        #    eval_condition(s, nil)
-        #end
+      assert r, ">#{s}< should have evaluated to _#{not inv}_"
+    end
 
-        def lookup_attribute (attname, workitem)
+    def assert_set_F (s)
 
-            attname
-        end
+      assert_set_t s, true
+    end
 
-        def ldebug (&block)
+    #def evalc (s)
+    #  eval_condition(s, nil)
+    #end
 
-            # don't do a thing
-            return unless @debug
+    def lookup_attribute (attname, workitem)
 
-            puts "  " + block.call
-        end
+      attname
+    end
+
+    def ldebug (&block)
+
+      # don't do a thing
+      return unless @debug
+
+      puts "  " + block.call
+    end
 end

data/test/description_test.rb

@@ -19,69 +19,70 @@ require 'openwfe/expool/parser'
 
 class DescriptionTest < Test::Unit::TestCase
 
-    #def setup
-    #end
+  #def setup
+  #end
 
-    #def teardown
-    #end
+  #def teardown
+  #end
 
-    DEF0 = """
+  DEF0 = """
 class MyDef0 < OpenWFE::ProcessDefinition
-    description 'not much to say'
-    sequence do
-    end
+  description 'not much to say'
+  sequence do
+  end
 end
-    """
+  """
 
-    def test_0
+  def test_0
 
-        #rep = OpenWFE::SimpleExpRepresentation.from_code DEF0
-        rep = OpenWFE::DefParser.parse_string DEF0
+    #rep = OpenWFE::SimpleExpRepresentation.from_code DEF0
+    #rep = OpenWFE::DefParser.parse_string DEF0
+    rep = OpenWFE::DefParser.parse DEF0
 
-        assert_equal(
-            "not much to say", 
-            OpenWFE::ExpressionTree.get_description(rep))
-    end
+    assert_equal(
+      "not much to say",
+      OpenWFE::ExpressionTree.get_description(rep))
+  end
 
-    DEF1 = <<-EOS
+  DEF1 = <<-EOS
 <process-definition name="x" revision="y">
-    <description>
-        just a tiny process
-    </description>
-    <participant ref="nada" />
+  <description>
+    just a tiny process
+  </description>
+  <participant ref="nada" />
 </process-definition>
-    EOS
+  EOS
 
-    def test_1
+  def test_1
 
-        rep = OpenWFE::DefParser.parse_string DEF1
+    rep = OpenWFE::DefParser.parse DEF1
 
-        assert_equal(
-            "just a tiny process",
-            OpenWFE::ExpressionTree.get_description(rep))
-    end
+    assert_equal(
+      "just a tiny process",
+      OpenWFE::ExpressionTree.get_description(rep))
+  end
 
-    class Test2 < OpenWFE::ProcessDefinition
-        # no description
-        sequence do
-        end
+  class Test2 < OpenWFE::ProcessDefinition
+    # no description
+    sequence do
+    end
+  end
+  class Test2b < OpenWFE::ProcessDefinition
+    # no description
+    sequence do
     end
-    class Test2b < OpenWFE::ProcessDefinition
-        # no description
-        sequence do
-        end
-        define "sub0" do
-        end
+    define "sub0" do
     end
+  end
 
-    def test_2
+  def test_2
 
-        tree = OpenWFE::DefParser.parse Test2
-        assert_nil OpenWFE::ExpressionTree.get_description(tree)
+    tree = OpenWFE::DefParser.parse Test2
+    assert_nil OpenWFE::ExpressionTree.get_description(tree)
 
-        tree = OpenWFE::DefParser.parse Test2b
-        #p tree
-        assert_nil OpenWFE::ExpressionTree.get_description(tree)
-    end
+    tree = OpenWFE::DefParser.parse Test2b
+    #p tree
+    assert_nil OpenWFE::ExpressionTree.get_description(tree)
+  end
 end