ruote 0.9.18 → 0.9.19

data/test/participant_test.rb

@@ -20,82 +20,82 @@ require 'openwfe/participants/participants'
 
 class ParticipantTest < Test::Unit::TestCase
 
-    def setup
-        @engine = OpenWFE::Engine.new
-    end
+  def setup
+    @engine = OpenWFE::Engine.new
+  end
 
-    def teardown
-        @engine.stop
-    end
+  def teardown
+    @engine.stop
+  end
 
-    def test_lookup_participant
+  def test_lookup_participant
 
-        @engine.register_participant :toto, OpenWFE::NullParticipant
+    @engine.register_participant :toto, OpenWFE::NullParticipant
 
-        p = @engine.get_participant "toto"
-        assert_kind_of OpenWFE::NullParticipant, p
+    p = @engine.get_participant "toto"
+    assert_kind_of OpenWFE::NullParticipant, p
 
-        p = @engine.get_participant :toto
-        assert_kind_of OpenWFE::NullParticipant, p
+    p = @engine.get_participant :toto
+    assert_kind_of OpenWFE::NullParticipant, p
 
-        assert_equal 1, @engine.get_participant_map.size
-    end
+    assert_equal 1, @engine.get_participant_map.size
+  end
 
-    def test_unregister_participant
+  def test_unregister_participant
 
-        assert ( ! @engine.unregister_participant(:nada))
+    assert ( ! @engine.unregister_participant(:nada))
 
-        @engine.register_participant :toto, OpenWFE::NullParticipant
+    @engine.register_participant :toto, OpenWFE::NullParticipant
 
-        assert_equal 1, @engine.get_participant_map.size
+    assert_equal 1, @engine.get_participant_map.size
 
-        assert @engine.unregister_participant(:toto)
+    assert @engine.unregister_participant(:toto)
 
-        assert_equal 0, @engine.get_participant_map.size
+    assert_equal 0, @engine.get_participant_map.size
 
-        @engine.register_participant "user_.*", OpenWFE::NullParticipant
+    @engine.register_participant "user_.*", OpenWFE::NullParticipant
 
-        assert_equal 1, @engine.get_participant_map.size
+    assert_equal 1, @engine.get_participant_map.size
 
-        assert @engine.unregister_participant("user_.*")
+    assert @engine.unregister_participant("user_.*")
 
-        assert_equal 0, @engine.get_participant_map.size
-    end
+    assert_equal 0, @engine.get_participant_map.size
+  end
 
-    def test_order
+  def test_order
 
-        s = ""
+    s = ""
 
-        @engine.register_participant "a.*", :astar
-        @engine.register_participant "alpha", :alpha
+    @engine.register_participant "a.*", :astar
+    @engine.register_participant "alpha", :alpha
 
-        assert_equal :astar, @engine.get_participant("alpha")
+    assert_equal :astar, @engine.get_participant("alpha")
 
-        clean_participants
+    clean_participants
 
-        @engine.register_participant "alpha", :alpha
-        @engine.register_participant "a.*", :astar
+    @engine.register_participant "alpha", :alpha
+    @engine.register_participant "a.*", :astar
 
-        assert_equal :alpha, @engine.get_participant("alpha")
+    assert_equal :alpha, @engine.get_participant("alpha")
 
-        clean_participants
+    clean_participants
 
-        @engine.register_participant "a.*", :astar
+    @engine.register_participant "a.*", :astar
 
-        assert_equal :astar, @engine.get_participant("alpha")
+    assert_equal :astar, @engine.get_participant("alpha")
 
-        @engine.register_participant "alpha", { :participant => :alpha, :position => :first }
+    @engine.register_participant "alpha", { :participant => :alpha, :position => :first }
 
-        assert_equal :alpha, @engine.get_participant("alpha")
-        assert_equal :astar, @engine.get_participant("abricot")
-    end
+    assert_equal :alpha, @engine.get_participant("alpha")
+    assert_equal :astar, @engine.get_participant("abricot")
+  end
 
-    protected
+  protected
 
-        def clean_participants
+    def clean_participants
 
-            @engine.get_participant_map.instance_variable_set(
-                :@participants, [])
-        end
+      @engine.get_participant_map.instance_variable_set(
+        :@participants, [])
+    end
 
 end

data/test/pending.rb

@@ -5,19 +5,19 @@
 
 module PendingJobsMixin
 
-    def assert_no_jobs_left
+  def assert_no_jobs_left
 
-        #cname = @engine.class.name
-        #min_jobs = if cname == 'OpenWFE::CachedFilePersistedEngine'
-        #    1
-        #elsif cname == 'OpenWFE::Extras::CachedDbPersistedEngine'
-        #    1
-        #else
-        #    0
-        #end
-        #assert_equal min_jobs, @engine.get_scheduler.pending_job_count
+    #cname = @engine.class.name
+    #min_jobs = if cname == 'OpenWFE::CachedFilePersistedEngine'
+    #  1
+    #elsif cname == 'OpenWFE::Extras::CachedDbPersistedEngine'
+    #  1
+    #else
+    #  0
+    #end
+    #assert_equal min_jobs, @engine.get_scheduler.pending_job_count
 
-        assert_equal 0, @engine.get_scheduler.at_job_count
-    end
+    assert_equal 0, @engine.get_scheduler.at_job_count
+  end
 end
 

data/test/ps_representation.rb

@@ -16,118 +16,118 @@ require 'openwfe/engine'
 
 class PsRepresentationTest < Test::Unit::TestCase
 
-    def setup
+  def setup
 
-        @engine = OpenWFE::Engine.new :definition_in_launchitem_allowed => true
-    end
+    @engine = OpenWFE::Engine.new :definition_in_launchitem_allowed => true
+  end
 
-    def teardown
+  def teardown
 
-        @engine.stop if @engine
-    end
+    @engine.stop if @engine
+  end
 
-    #
-    # TEST 0
+  #
+  # TEST 0
 
-    class Test0 < OpenWFE::ProcessDefinition
-        sequence do
-            alpha
-            bravo
-        end
+  class Test0 < OpenWFE::ProcessDefinition
+    sequence do
+      alpha
+      bravo
     end
+  end
 
-    def test_0
+  def test_0
 
-        @engine.register_participant "alpha", OpenWFE::NullParticipant
+    @engine.register_participant "alpha", OpenWFE::NullParticipant
 
-        fei = @engine.launch Test0
+    fei = @engine.launch Test0
 
-        sleep 0.350
+    sleep 0.350
 
-        ps = @engine.process_stack fei, true
+    ps = @engine.process_stack fei, true
 
-        #p ps.representation
+    #p ps.representation
 
-        assert_equal(
-            ["process-definition", {"name"=>"Test", "revision"=>"0"}, [["sequence", {}, [["alpha", {"ref"=>"alpha"}, []], ["bravo", {}, []]]]]],
-            ps.representation)
+    assert_equal(
+      ["process-definition", {"name"=>"Test", "revision"=>"0"}, [["sequence", {}, [["alpha", {"ref"=>"alpha"}, []], ["bravo", {}, []]]]]],
+      ps.representation)
 
-        #
-        # change process instance (charly instead of bravo)
+    #
+    # change process instance (charly instead of bravo)
 
-        #puts ps.collect { |fexp| fexp.fei.to_s }.join("\n")
+    #puts ps.collect { |fexp| fexp.fei.to_s }.join("\n")
 
-        bravo_fei = ps.find { |fexp| fexp.fei.expid == "0.0.1" }.fei
+    bravo_fei = ps.find { |fexp| fexp.fei.expid == "0.0.1" }.fei
 
-        @engine.update_raw_expression bravo_fei, ["charly", {}, []]
+    @engine.update_raw_expression bravo_fei, ["charly", {}, []]
 
-        ps = @engine.process_stack fei, true
+    ps = @engine.process_stack fei, true
 
-        assert_equal(
-            ["process-definition", {"name"=>"Test", "revision"=>"0"}, [["sequence", {}, [["alpha", {"ref"=>"alpha"}, []], ["charly", {}, []]]]]],
-            ps.representation)
-    end
+    assert_equal(
+      ["process-definition", {"name"=>"Test", "revision"=>"0"}, [["sequence", {}, [["alpha", {"ref"=>"alpha"}, []], ["charly", {}, []]]]]],
+      ps.representation)
+  end
 
-    #
-    # TEST 1
+  #
+  # TEST 1
 
-    class Test1 < OpenWFE::ProcessDefinition
+  class Test1 < OpenWFE::ProcessDefinition
 
-        description "interference of the description"
+    description "interference of the description"
 
-        sequence do
-            alpha
-            bravo
-        end
+    sequence do
+      alpha
+      bravo
     end
+  end
 
-    def test_1
+  def test_1
 
-        @engine.register_participant "alpha", OpenWFE::NullParticipant
+    @engine.register_participant "alpha", OpenWFE::NullParticipant
 
-        fei = @engine.launch Test1
+    fei = @engine.launch Test1
 
-        sleep 0.350
+    sleep 0.350
 
-        ps = @engine.process_stack fei, true
+    ps = @engine.process_stack fei, true
 
-        assert_equal(
-            ["process-definition", {"name"=>"Test", "revision"=>"1"}, [["description", {}, ["interference of the description"]], ["sequence", {}, [["alpha", {"ref"=>"alpha"}, []], ["bravo", {}, []]]]]],
-            ps.representation)
+    assert_equal(
+      ["process-definition", {"name"=>"Test", "revision"=>"1"}, [["description", {}, ["interference of the description"]], ["sequence", {}, [["alpha", {"ref"=>"alpha"}, []], ["bravo", {}, []]]]]],
+      ps.representation)
 
-        #
-        # change process instance (charly instead of bravo)
+    #
+    # change process instance (charly instead of bravo)
 
-        bravo_fei = ps.find { |fexp| fexp.fei.expid == "0.1.1" }.fei
+    bravo_fei = ps.find { |fexp| fexp.fei.expid == "0.1.1" }.fei
 
-        @engine.update_raw_expression bravo_fei, ["charly", {}, []]
+    @engine.update_raw_expression bravo_fei, ["charly", {}, []]
 
-        ps = @engine.process_stack fei, true
+    ps = @engine.process_stack fei, true
 
-        assert_equal(
-            ["process-definition", {"name"=>"Test", "revision"=>"1"}, [["description", {}, ["interference of the description"]], ["sequence", {}, [["alpha", {"ref"=>"alpha"}, []], ["charly", {}, []]]]]],
-            ps.representation)
+    assert_equal(
+      ["process-definition", {"name"=>"Test", "revision"=>"1"}, [["description", {}, ["interference of the description"]], ["sequence", {}, [["alpha", {"ref"=>"alpha"}, []], ["charly", {}, []]]]]],
+      ps.representation)
 
-        #
-        # nuke participant charly
+    #
+    # nuke participant charly
 
-        @engine.cancel_expression bravo_fei
+    @engine.cancel_expression bravo_fei
 
-        sleep 0.350
+    sleep 0.350
 
-        ps = @engine.process_stack fei, true
+    ps = @engine.process_stack fei, true
 
-        #p ps.representation
+    #p ps.representation
 
-        assert_equal(
-            ["process-definition", {"name"=>"Test", "revision"=>"1"}, [["description", {}, ["interference of the description"]], ["sequence", {}, [["alpha", {"ref"=>"alpha"}, []]]]]],
-            ps.representation)
+    assert_equal(
+      ["process-definition", {"name"=>"Test", "revision"=>"1"}, [["description", {}, ["interference of the description"]], ["sequence", {}, [["alpha", {"ref"=>"alpha"}, []]]]]],
+      ps.representation)
 
-        assert_equal(
-            ["process-definition", {"name"=>"Test", "revision"=>"1"}, [["description", {}, ["interference of the description"]], ["sequence", {}, [["alpha", {"ref"=>"alpha"}, []]]]]],
-            @engine.process_representation(fei.wfid))
-    end
+    assert_equal(
+      ["process-definition", {"name"=>"Test", "revision"=>"1"}, [["description", {}, ["interference of the description"]], ["sequence", {}, [["alpha", {"ref"=>"alpha"}, []]]]]],
+      @engine.process_representation(fei.wfid))
+  end
 
-    # see also test/ft_84_updateexp.rb
+  # see also test/ft_84_updateexp.rb
 
 end

data/test/rake_ltest.rb

@@ -28,8 +28,8 @@ require 'ft_51_stack'
 require 'ft_29_httprb' # needs net connection
 
 #require 'ft_30_socketlistener'
-    #
-    # shaky test...
+  #
+  # shaky test...
 
 #
 # the quick tests

data/test/rake_qtest.rb

@@ -26,6 +26,7 @@ require 'obs_test'
 require 'clone_test'
 require 'lookup_vf_test'
 require 'fe_lookup_att_test'
+require 'treechecker_test'
 
 require 'sec_test'
 require 'param_test'
@@ -40,8 +41,8 @@ require 'ps_representation'
 require 'util_xml_test'
 
 require 'ft_tests'
-    #
-    # all the 'ft' tests are required in 'ft_tests.rb'
+  #
+  # all the 'ft' tests are required in 'ft_tests.rb'
 
 #require 'ft_30_socketlistener'
 
@@ -50,19 +51,18 @@ require 'hparticipant_test'
 require 'timeout_test'
 
 require 'slock_test'
-require 'orest_test.rb'
 
 #require 'extras/atomfeedp_test.rb'
 
 
 #Signal.trap "SIGINT" do |signo|
-#    puts
-#    puts "Interrupt"
-#    puts
-#    puts caller[1..-1]
-#    puts
-#    exit 0
+#  puts
+#  puts "Interrupt"
+#  puts
+#  puts caller[1..-1]
+#  puts
+#  exit 0
 #end if on_jruby?
-    #
-    # useless
+  #
+  # useless
 

data/test/raw_prog_test.rb

@@ -7,6 +7,8 @@
 # Mon Oct  9 22:19:44 JST 2006
 #
 
+require 'rubygems'
+
 require 'test/unit'
 require 'openwfe/def'
 require 'openwfe/expool/parser'
@@ -14,399 +16,392 @@ require 'openwfe/expool/parser'
 
 class RawProgTest < Test::Unit::TestCase
 
-    #def setup
-    #end
-
-    #def teardown
-    #end
-
-    XML_DEF = 
-        "<process-definition name='test0' revision='0'>"+
-        "<sequence>"+
-        "<participant ref='a'/>"+
-        "<participant ref='b'/>"+
-        "</sequence>"+
-        "</process-definition>"
-
-    #
-    # TEST 0
-    #
-
-    class TestDefinition < OpenWFE::ProcessDefinition
-        def make
-            process_definition :name => "test0", :revision => "0" do
-                sequence do
-                    participant :ref => "a"
-                    participant :ref => "b"
-                end
-            end
+  #def setup
+  #end
+
+  #def teardown
+  #end
+
+  XML_DEF =
+    "<process-definition name='test0' revision='0'>"+
+    "<sequence>"+
+    "<participant ref='a'/>"+
+    "<participant ref='b'/>"+
+    "</sequence>"+
+    "</process-definition>"
+
+  #
+  # TEST 0
+  #
+
+  class TestDefinition < OpenWFE::ProcessDefinition
+    def make
+      process_definition :name => "test0", :revision => "0" do
+        sequence do
+          participant :ref => "a"
+          participant :ref => "b"
         end
+      end
     end
+  end
 
-    def test_prog_0
+  def test_prog_0
 
-        s = OpenWFE::ExpressionTree.to_s(TestDefinition.new.make)
+    s = OpenWFE::ExpressionTree.to_s(TestDefinition.new.make)
 
-        assert_equal XML_DEF, s
-    end
+    assert_equal XML_DEF, s
+  end
 
-    def test_prog_0b
+  def test_prog_0b
 
-        #s = TestDefinition.do_make.to_s
-        s = OpenWFE::ExpressionTree.to_s(TestDefinition.do_make)
+    #s = TestDefinition.do_make.to_s
+    s = OpenWFE::ExpressionTree.to_s(TestDefinition.do_make)
 
-        assert_equal XML_DEF, s
-    end
+    assert_equal XML_DEF, s
+  end
 
 
-    #
-    # TEST 1
-    #
+  #
+  # TEST 1
+  #
 
-    def test_prog_1
+  def test_prog_1
 
-        pg = OpenWFE::ProcessDefinition.new
+    pg = OpenWFE::ProcessDefinition.new
 
-        class << pg
-            def my_proc
-                process_definition :name => "test0", :revision => "0" do
-                    sequence do
-                        participant :ref => "a"
-                        participant :ref => "b"
-                    end
-                end
-            end
+    class << pg
+      def my_proc
+        process_definition :name => "test0", :revision => "0" do
+          sequence do
+            participant :ref => "a"
+            participant :ref => "b"
+          end
         end
-        pdef = pg.my_proc
-        s = pdef.to_s
-
-        assert XML_DEF, s
+      end
     end
+    pdef = pg.my_proc
+    s = pdef.to_s
 
+    assert XML_DEF, s
+  end
 
-    #
-    # TEST 2
-    #
 
-    class TestDefinition2 < OpenWFE::ProcessDefinition
-        def make
-            process_definition :name => "test2", :revision => "0" do
-                sequence do
-                    set :field => "toto" do
-                        "nada"
-                    end
-                    participant :ref => "b"
-                end
-            end
+  #
+  # TEST 2
+  #
+
+  class TestDefinition2 < OpenWFE::ProcessDefinition
+    def make
+      process_definition :name => "test2", :revision => "0" do
+        sequence do
+          set :field => "toto" do
+            "nada"
+          end
+          participant :ref => "b"
         end
+      end
     end
+  end
 
-    XML_DEF2 =
-        "<process-definition name='test2' revision='0'>"+
-        "<sequence>"+
-        "<set field='toto'>"+
-        "nada"+
-        "</set>"+
-        "<participant ref='b'/>"+
-        "</sequence>"+
-        "</process-definition>"
+  XML_DEF2 =
+    "<process-definition name='test2' revision='0'>"+
+    "<sequence>"+
+    "<set field='toto'>"+
+    "nada"+
+    "</set>"+
+    "<participant ref='b'/>"+
+    "</sequence>"+
+    "</process-definition>"
 
-    def test_prog_2
+  def test_prog_2
 
-        s = OpenWFE::ExpressionTree.to_s(TestDefinition2.do_make)
+    s = OpenWFE::ExpressionTree.to_s(TestDefinition2.do_make)
 
-        assert_equal XML_DEF2, s
+    assert_equal XML_DEF2, s
 
-        #puts
-        #puts TestDefinition2.do_make.to_code_s
-    end
+    #puts
+    #puts TestDefinition2.do_make.to_code_s
+  end
 
 
-    #
-    # TEST 3
-    #
+  #
+  # TEST 3
+  #
 
-    class TestDefinition3 < OpenWFE::ProcessDefinition
-        def make
-            process_definition :name => "test3", :revision => "0" do
-                _if do
-                    equals :field_value => "nada", :other_value => "surf"
-                    participant :ref => "b"
-                end
-            end
+  class TestDefinition3 < OpenWFE::ProcessDefinition
+    def make
+      process_definition :name => "test3", :revision => "0" do
+        _if do
+          equals :field_value => "nada", :other_value => "surf"
+          participant :ref => "b"
         end
+      end
     end
-
-    XML_DEF3 = 
-        "<process-definition name='test3' revision='0'>"+
-        "<if>"+
-        "<equals field-value='nada' other-value='surf'/>"+
-        "<participant ref='b'/>"+
-        "</if>"+
-        "</process-definition>"
-
-    CODE_DEF3 = """
-process_definition :name => 'test3', :revision => '0' do
-    _if do
-        equals :field_value => 'nada', :other_value => 'surf'
-        participant :ref => 'b'
-    end
+  end
+
+  XML_DEF3 =
+    "<process-definition name='test3' revision='0'>"+
+    "<if>"+
+    "<equals field-value='nada' other-value='surf'/>"+
+    "<participant ref='b'/>"+
+    "</if>"+
+    "</process-definition>"
+
+  CODE_DEF3 = """
+process_definition :name => \"test3\", :revision => \"0\" do
+  _if do
+    equals :field_value => \"nada\", :other_value => \"surf\"
+    participant :ref => \"b\"
+  end
 end""".strip
 
-    def test_prog_3
+  def test_prog_3
 
-        s = OpenWFE::ExpressionTree.to_s(TestDefinition3.do_make)
+    s = OpenWFE::ExpressionTree.to_s(TestDefinition3.do_make)
 
-        assert_equal XML_DEF3, s
+    assert_equal XML_DEF3, s
 
-        assert_equal(
-            CODE_DEF3, 
-            OpenWFE::ExpressionTree.to_code_s(TestDefinition3.do_make))
+    assert_equal(
+      CODE_DEF3,
+      OpenWFE::ExpressionTree.to_code_s(TestDefinition3.do_make))
 
-        #r = OpenWFE::SimpleExpRepresentation.from_xml(s)
-        r = OpenWFE::DefParser.parse_xml s
+    r = OpenWFE::DefParser.parse s
 
-        assert_equal CODE_DEF3, OpenWFE::ExpressionTree.to_code_s(r)
-    end
+    assert_equal CODE_DEF3, OpenWFE::ExpressionTree.to_code_s(r)
+  end
 
 
-    #
-    # TEST 4
-    #
+  #
+  # TEST 4
+  #
 
-    class TestDefinition4 < OpenWFE::ProcessDefinition
-        def make
-            process_definition :name => "test4", :revision => "0" do
-                sequence do
-                    3.times { participant :ref => "b" }
-                end
-            end
+  class TestDefinition4 < OpenWFE::ProcessDefinition
+    def make
+      process_definition :name => "test4", :revision => "0" do
+        sequence do
+          3.times { participant :ref => "b" }
         end
+      end
     end
-
-    CODE_DEF4 = """
-process_definition :name => 'test4', :revision => '0' do
-    sequence do
-        participant :ref => 'b'
-        participant :ref => 'b'
-        participant :ref => 'b'
-    end
-end""".strip
-
-    def test_prog_4
-
-        #puts
-        #puts TestDefinition4.do_make.to_s
-        #puts
-        #puts TestDefinition4.do_make.to_code_s
-
-        assert_equal(
-            CODE_DEF4, 
-            OpenWFE::ExpressionTree.to_code_s(TestDefinition4.do_make))
-    end
-
-
-    #
-    # TEST 4b
-    #
-
-    class TestDefinition4b < OpenWFE::ProcessDefinition
-        def make
-            sequence do
-                [ :b, :b, :b ].each do |p|
-                    participant p
-                end
-            end
+  end
+
+  CODE_DEF4 = %{
+process_definition :name => "test4", :revision => "0" do
+  sequence do
+    participant :ref => "b"
+    participant :ref => "b"
+    participant :ref => "b"
+  end
+end}.strip
+
+  def test_prog_4
+
+    #puts
+    #puts TestDefinition4.do_make.to_s
+    #puts
+    #puts TestDefinition4.do_make.to_code_s
+
+    assert_equal(
+      CODE_DEF4,
+      OpenWFE::ExpressionTree.to_code_s(TestDefinition4.do_make))
+  end
+
+
+  #
+  # TEST 4b
+  #
+
+  class TestDefinition4b < OpenWFE::ProcessDefinition
+    def make
+      sequence do
+        [ :b, :b, :b ].each do |p|
+          participant p
         end
+      end
     end
+  end
 
-    CODE_DEF4b = """
-process_definition :name => 'Test', :revision => '4b' do
-    sequence do
-        participant do
-            'b'
-        end
-        participant do
-            'b'
-        end
-        participant do
-            'b'
-        end
-    end
-end""".strip
+  CODE_DEF4b = %{
+process_definition :name => "Test", :revision => "4b" do
+  sequence do
+    participant 'b'
+    participant 'b'
+    participant 'b'
+  end
+end}.strip
 
-    def test_prog_4b
+  def test_prog_4b
 
-        assert_equal(
-            CODE_DEF4b, 
-            OpenWFE::ExpressionTree.to_code_s(TestDefinition4b.do_make))
-    end
+    assert_equal(
+      CODE_DEF4b,
+      OpenWFE::ExpressionTree.to_code_s(TestDefinition4b.do_make))
+  end
 
 
-    #
-    # TEST 5
-    #
-
-    class TestDefinition5 < OpenWFE::ProcessDefinition
-        def make
-            sequence do
-                participant :ref => :toto
-                sub0
-            end
-            process_definition :name => "sub0" do
-                nada
-            end
-        end
-    end
+  #
+  # TEST 5
+  #
 
-    CODE_DEF5 = """
-process_definition :name => 'Test', :revision => '5' do
-    sequence do
-        participant :ref => 'toto'
+  class TestDefinition5 < OpenWFE::ProcessDefinition
+    def make
+      sequence do
+        participant :ref => :toto
         sub0
+      end
+      process_definition :name => "sub0" do
+        nada
+      end
     end
-    process_definition :name => 'sub0' do
+  end
+
+  CODE_DEF5 = %{
+process_definition :name => "Test", :revision => "5" do
+  sequence do
+    participant :ref => :toto
+    sub0
+  end
+  process_definition :name => "sub0" do
+    nada
+  end
+end}.strip
+
+  def test_prog_5
+
+    assert_equal(
+      CODE_DEF5,
+      OpenWFE::ExpressionTree.to_code_s(TestDefinition5.do_make))
+  end
+
+
+  #
+  # TEST 6
+  #
+
+  class TestDefinition60 < OpenWFE::ProcessDefinition
+    def make
+      sequence do
+        participant :ref => :toto
         nada
+      end
     end
-end""".strip
+  end
 
-    def test_prog_5
+  CODE_DEF6 = %{
+process_definition :name => "Test", :revision => "60" do
+  sequence do
+    participant :ref => :toto
+    nada
+  end
+end}.strip
 
-        assert_equal(
-            CODE_DEF5, 
-            OpenWFE::ExpressionTree.to_code_s(TestDefinition5.do_make))
-    end
+  def test_prog_6
 
+    assert_equal(
+      CODE_DEF6,
+      OpenWFE::ExpressionTree.to_code_s(TestDefinition60.do_make))
+  end
 
-    #
-    # TEST 6
-    #
 
-    class TestDefinition60 < OpenWFE::ProcessDefinition
-        def make
-            sequence do
-                participant :ref => :toto
-                nada
-            end
-        end
-    end
+  #
+  # TEST 7
+  #
 
-    CODE_DEF6 = """
-process_definition :name => 'Test', :revision => '60' do
-    sequence do
-        participant :ref => 'toto'
-        nada
+  class TestDefinitionSeven < OpenWFE::ProcessDefinition
+    def make
+      participant :ref => :toto
     end
-end""".strip
+  end
 
-    def test_prog_6
+  CODE_DEF7 = %{
+process_definition :name => "TestDefinitionSeven", :revision => "0" do
+  participant :ref => :toto
+end}.strip
 
-        assert_equal(
-            CODE_DEF6, 
-            OpenWFE::ExpressionTree.to_code_s(TestDefinition60.do_make))
-    end
+  A_DEF7 = [
+    "process-definition",
+    { "name"=>"TestDefinitionSeven", "revision"=>"0" },
+    [ [ "participant", { "ref" => :toto }, [] ] ]
+  ]
 
+  def test_prog_7
 
-    #
-    # TEST 7
-    #
+    assert_equal(
+      CODE_DEF7,
+      OpenWFE::ExpressionTree.to_code_s(TestDefinitionSeven.do_make))
 
-    class TestDefinitionSeven < OpenWFE::ProcessDefinition
-        def make
-            participant :ref => :toto
-        end
-    end
+    assert_equal(
+      A_DEF7,
+      TestDefinitionSeven.do_make)
+  end
 
-    CODE_DEF7 = """
-process_definition :name => 'TestDefinitionSeven', :revision => '0' do
-    participant :ref => 'toto'
-end""".strip
-
-    A_DEF7 = [
-        "process-definition",
-        { "name"=>"TestDefinitionSeven", "revision"=>"0" },
-        [ [ "participant", { "ref" => :toto }, [] ] ]
-    ]
-
-    def test_prog_7
-
-        assert_equal(
-            CODE_DEF7, 
-            OpenWFE::ExpressionTree.to_code_s(TestDefinitionSeven.do_make))
-
-        assert_equal(
-            A_DEF7, 
-            TestDefinitionSeven.do_make)
-    end
+  #
+  # TEST 8
+  #
 
+  def do_test (class_name, pdef)
     #
-    # TEST 8
+    # losing my time with an eval
     #
+    result = eval """
+      class #{class_name} < OpenWFE::ProcessDefinition
+        def make
+          participant 'nada'
+        end
+      end
+      #{class_name}.do_make
+    """
+    assert_equal result[1]['name'], pdef[0]
+    assert_equal result[1]['revision'], pdef[1]
+  end
 
-    def do_test (class_name, pdef)
-        #
-        # losing my time with an eval
-        #
-        result = eval """
-            class #{class_name} < OpenWFE::ProcessDefinition
-                def make
-                    participant 'nada'
-                end
-            end
-            #{class_name}.do_make
-        """
-        assert_equal result[1]['name'], pdef[0]
-        assert_equal result[1]['revision'], pdef[1]
-    end
-
-    def test_process_names
+  def test_process_names
 
-        do_test "MyProcessDefinition_10", ["MyProcess", "10"]
-        do_test "MyProcessDefinition10", ["MyProcess", "10"]
-        do_test "MyProcessDefinition1_0", ["MyProcess", "1.0"]
-        do_test "MyProcessThing_1_0", ["MyProcessThing", "1.0"]
-    end
+    do_test "MyProcessDefinition_10", ["MyProcess", "10"]
+    do_test "MyProcessDefinition10", ["MyProcess", "10"]
+    do_test "MyProcessDefinition1_0", ["MyProcess", "1.0"]
+    do_test "MyProcessThing_1_0", ["MyProcessThing", "1.0"]
+  end
 
-    def do_test_2 (raw_name, expected)
+  def do_test_2 (raw_name, expected)
 
-        assert_equal(
-            expected, 
-            OpenWFE::ProcessDefinition.extract_name_and_revision(raw_name))
-    end
+    assert_equal(
+      expected,
+      OpenWFE::ProcessDefinition.extract_name_and_revision(raw_name))
+  end
 
-    def test_process_names_2
+  def test_process_names_2
 
-        do_test_2 "MyProcessDefinition_10", ["MyProcess", "10"]
-        do_test_2 "MyProcessDefinition5b", ["MyProcess", "5b"]
-    end
+    do_test_2 "MyProcessDefinition_10", ["MyProcess", "10"]
+    do_test_2 "MyProcessDefinition5b", ["MyProcess", "5b"]
+  end
 
 
-    #
-    # TEST 9
-    #
+  #
+  # TEST 9
+  #
 
-    class TestDefinition9 < OpenWFE::ProcessDefinition
-        def make
-            description "this is my process"
-            sequence do
-                participant :ref => :toto
-            end
-        end
+  class TestDefinition9 < OpenWFE::ProcessDefinition
+    def make
+      description "this is my process"
+      sequence do
+        participant :ref => :toto
+      end
     end
+  end
 
-    CODE_DEF9 = """
+  CODE_DEF9 = """
 process_definition :name => 'Test', :revision => '60' do
-    description 'this is my process'
-    sequence do
-        participant :ref => 'toto'
-        nada
-    end
+  description 'this is my process'
+  sequence do
+    participant :ref => 'toto'
+    nada
+  end
 end""".strip
 
-    def _test_prog_9
+  def _test_prog_9
 
-        assert CODE_DEF9, TestDefinition9.do_make.to_code_s
-    end
+    assert CODE_DEF9, TestDefinition9.do_make.to_code_s
+  end
 
 end