weel 1.0.3 → 1.1.0

data/lib/weel.rb

@@ -7,6 +7,29 @@ class String # {{{
   end
 end # }}}
 
+# OMG!111! deep cloning for ReadHashes
+class Object #{{{
+  def deep_clone
+    return @deep_cloning_obj if @deep_cloning
+    @deep_cloning_obj = clone
+    @deep_cloning_obj.instance_variables.each do |var|
+      val = @deep_cloning_obj.instance_variable_get(var)
+      begin
+        @deep_cloning = true
+        val = val.deep_clone
+      rescue TypeError
+        next
+      ensure
+        @deep_cloning = false
+      end
+      @deep_cloning_obj.instance_variable_set(var, val)
+    end
+    deep_cloning_obj = @deep_cloning_obj
+    @deep_cloning_obj = nil
+    deep_cloning_obj
+  end
+end #}}}
+
 class WEEL
   def initialize(*args)# {{{
     @wfsource = nil
@@ -118,7 +141,7 @@ class WEEL
       temp = nil
       if args.empty? && @__weel_values.has_key?(name)
         @__weel_values[name] 
-        #TODO dont let user change stuff
+        #TODO dont let user change stuff e.g. if return value is an array (deep clone and/or deep freeze it?)
       else
         nil
       end
@@ -150,6 +173,12 @@ class WEEL
     def vote_sync_before; true; end
     def vote_sync_after; true; end
 
+    # type       => activity, loop, parallel, choice
+    # nesting    => none, start, end
+    # eid        => id's also for control structures
+    # parameters => stuff given to the control structure
+    def simulate(type,nesting,eid,parent,parameters={}); end
+
     def callback(result); end
   end  # }}}
 
@@ -230,6 +259,7 @@ class WEEL
       @__weel_handlerwrapper_args = []
       @__weel_state = :ready
       @__weel_status = Status.new(0,"undefined")
+      @__weel_sim = -1
     end
     attr_accessor :__weel_search_positions, :__weel_positions, :__weel_main, :__weel_data, :__weel_endpoints, :__weel_handlerwrapper, :__weel_handlerwrapper_args
     attr_reader :__weel_state, :__weel_status
@@ -251,6 +281,11 @@ class WEEL
         Thread.current[:continue] = Continue.new
         handlerwrapper = @__weel_handlerwrapper.new @__weel_handlerwrapper_args, @__weel_endpoints[endpoint], position, Thread.current[:continue]
 
+        if __weel_sim
+          handlerwrapper.simulate(:activity,:none,position,Thread.current[:branch_sim_pos],:parameters=>parameters, :endpoint => endpoint, :type => type)
+          return
+        end
+
         ipc = {}
         if searchmode == :after
           wp = WEEL::Position.new(position, :after, nil)
@@ -382,6 +417,9 @@ class WEEL
       Thread.current[:branch_finished_count] = 0
       Thread.current[:branch_event] = Continue.new
       Thread.current[:mutex] = Mutex.new
+
+      hw, pos = __weel_sim_start(:parallel) if __weel_sim
+
       yield
 
       Thread.current[:branch_wait_count] = (type.is_a?(Hash) && type.size == 1 && type[:wait] != nil && (type[:wait].is_a?(Integer)) ? type[:wait] : Thread.current[:branches].size)
@@ -398,7 +436,8 @@ class WEEL
       end
 
       Thread.current[:branch_event].wait
-      #Thread.current[:branch_event] = nil
+
+      __weel_sim_stop(:parallel,hw,pos) if __weel_sim
 
       unless self.__weel_state == :stopping || self.__weel_state == :stopped
         # first set all to no_longer_neccessary
@@ -419,19 +458,41 @@ class WEEL
     def parallel_branch(*vars)# {{{
       return if self.__weel_state == :stopping || self.__weel_state == :stopped || Thread.current[:nolongernecessary]
       branch_parent = Thread.current
+
+      if __weel_sim
+        # catch the potential execution in loops inside a parallel
+        current_branch_sim_pos = branch_parent[:branch_sim_pos]
+      end  
+
       Thread.current[:branches] << Thread.new(*vars) do |*local|
         branch_parent[:mutex].synchronize do
           Thread.current.abort_on_exception = true
           Thread.current[:branch_status] = false
           Thread.current[:branch_parent] = branch_parent
+
+          if __weel_sim
+            Thread.current[:branch_sim_pos] = @__weel_sim += 1
+          end  
+
+          # parallel_branch could be possibly around an alternative. Thus thread has to inherit the alternative_executed
+          # after branching, update it in the parent (TODO)
           if branch_parent[:alternative_executed] && branch_parent[:alternative_executed].length > 0
             Thread.current[:alternative_executed] = [branch_parent[:alternative_executed].last]
+            Thread.current[:alternative_mode] = [branch_parent[:alternative_mode].last]
           end
         end  
 
         Thread.stop
+
+        if __weel_sim
+          handlerwrapper = @__weel_handlerwrapper.new @__weel_handlerwrapper_args
+          handlerwrapper.simulate(:parallel_branch,:start,Thread.current[:branch_sim_pos],current_branch_sim_pos)
+        end
+
         yield(*local)
 
+        __weel_sim_stop(:parallel_branch,handlerwrapper,current_branch_sim_pos) if __weel_sim
+
         branch_parent[:mutex].synchronize do
           Thread.current[:branch_status] = true
           branch_parent[:branch_finished_count] += 1
@@ -458,12 +519,17 @@ class WEEL
     # Choose DSL-Construct
     # Defines a choice in the Workflow path.
     # May contain multiple execution alternatives
-    def choose # {{{
+    def choose(mode=:inclusive) # {{{
       return if self.__weel_state == :stopping || self.__weel_state == :stopped || Thread.current[:nolongernecessary]
       Thread.current[:alternative_executed] ||= []
+      Thread.current[:alternative_mode] ||= []
       Thread.current[:alternative_executed] << false
+      Thread.current[:alternative_mode] << mode
+      hw, pos = __weel_sim_start(:choose,:mode => Thread.current[:alternative_mode]) if __weel_sim
       yield
+      __weel_sim_stop(:choose,hw,pos,:mode => Thread.current[:alternative_mode]) if __weel_sim
       Thread.current[:alternative_executed].pop
+      Thread.current[:alternative_mode].pop
       nil
     end # }}}
 
@@ -472,12 +538,20 @@ class WEEL
     # searchmode is active (to find the starting position)
     def alternative(condition)# {{{
       return if self.__weel_state == :stopping || self.__weel_state == :stopped || Thread.current[:nolongernecessary]
-      yield if __weel_is_in_search_mode || condition
-      Thread.current[:alternative_executed][-1] = true if condition
+      hw, pos = __weel_sim_start(:alternative,:mode => Thread.current[:alternative_mode]) if __weel_sim
+      Thread.current[:mutex] ||= Mutex.new
+      Thread.current[:mutex].synchronize do
+        return if Thread.current[:alternative_mode] == :exclusive && Thread.current[:alternative_executed][-1] = true
+        Thread.current[:alternative_executed][-1] = true if condition
+      end  
+      yield if __weel_is_in_search_mode || __weel_sim || condition
+      __weel_sim_stop(:alternative,hw,pos,:mode => Thread.current[:alternative_mode]) if __weel_sim
     end # }}}
     def otherwise # {{{
       return if self.__weel_state == :stopping || self.__weel_state == :stopped || Thread.current[:nolongernecessary]
-      yield if __weel_is_in_search_mode || !Thread.current[:alternative_executed].last
+      hw, pos = __weel_sim_start(:otherwise,:mode => Thread.current[:alternative_mode]) if __weel_sim
+      yield if __weel_is_in_search_mode || __weel_sim || !Thread.current[:alternative_executed].last
+      __weel_sim_stop(:otherwise,hw,pos,:mode => Thread.current[:alternative_mode]) if __weel_sim
     end # }}}
 
     # Defines a critical block (=Mutex)
@@ -495,7 +569,7 @@ class WEEL
     end # }}}
 
     # Defines a Cycle (loop/iteration)
-    def loop(condition)# {{{
+    def loop(condition)# {{{ 
       unless condition.is_a?(Array) && condition[0].is_a?(Proc) && [:pre_test,:post_test].include?(condition[1])
         raise "condition must be called pre_test{} or post_test{}"
       end
@@ -504,6 +578,12 @@ class WEEL
         yield
         return if __weel_is_in_search_mode
       end  
+      if __weel_sim
+        hw, pos = __weel_sim_start(:loop,:testing=>condition[1])
+        yield
+        __weel_sim_stop(:loop,hw,pos,:testing=>condition[1])
+        return
+      end  
       case condition[1]
         when :pre_test
           yield while condition[0].call && self.__weel_state != :stopping && self.__weel_state != :stopped
@@ -594,6 +674,23 @@ class WEEL
         branch[:branch_search] = true
       end  
     end # }}}
+
+    def __weel_sim
+      @__weel_state == :simulating
+    end
+
+    def __weel_sim_start(what,options={})
+      current_branch_sim_pos = Thread.current[:branch_sim_pos]
+      Thread.current[:branch_sim_pos] = @__weel_sim += 1
+      handlerwrapper = @__weel_handlerwrapper.new @__weel_handlerwrapper_args
+      handlerwrapper.simulate(what,:start,Thread.current[:branch_sim_pos],current_branch_sim_pos,options)
+      [handlerwrapper, current_branch_sim_pos]
+    end  
+
+    def __weel_sim_stop(what,handlerwrapper,current_branch_sim_pos,options={})
+      handlerwrapper.simulate(what,:end,Thread.current[:branch_sim_pos],current_branch_sim_pos,options)
+      Thread.current[:branch_sim_pos] = current_branch_sim_pos
+    end
   
   public
     def __weel_finalize
@@ -616,7 +713,7 @@ class WEEL
       handlerwrapper.inform_state_change @__weel_state
     end # }}}
 
-  end # }}}
+  end # }}} 
 
 public
   def positions # {{{
@@ -648,7 +745,7 @@ public
     nil
   end #  }}}
 
-  # Get the state of execution (ready|running|stopping|stopped|finished)
+  # Get the state of execution (ready|running|stopping|stopped|finished|simulating)
   def state # {{{
     @dslr.__weel_state
   end #  }}}
@@ -700,9 +797,9 @@ public
     else
       @wfsource = code unless bgiven
       (class << self; self; end).class_eval do
-        define_method :__weel_control_flow do
+        define_method :__weel_control_flow do |state,final_state=:finished|
           @dslr.__weel_positions.clear
-          @dslr.__weel_state = :running
+          @dslr.__weel_state = state
           begin
             if bgiven
               @dslr.instance_eval(&blk)
@@ -721,7 +818,10 @@ public
             @dslr.__weel_positions.clear
             handlerwrapper = @dslr.__weel_handlerwrapper.new @dslr.__weel_handlerwrapper_args
             handlerwrapper.inform_position_change(ipc)
-          end 
+          end
+          if @dslr.__weel_state == :simulating
+            @dslr.__weel_state = final_state
+          end  
           if @dslr.__weel_state == :stopping
             @dslr.__weel_finalize
           end
@@ -742,7 +842,15 @@ public
   def start # {{{
     return nil if @dslr.__weel_state != :ready && @dslr.__weel_state != :stopped
     @dslr.__weel_main = Thread.new do
-      __weel_control_flow
+      __weel_control_flow(:running)
+    end
+  end # }}}
+
+  def sim # {{{
+    stat = @dslr.__weel_state
+    return nil if stat != :ready && stat != :stopped
+    @dslr.__weel_main = Thread.new do
+      __weel_control_flow :simulating, stat
     end
   end # }}}
 

data/test/SimHandlerWrapper.rb

@@ -0,0 +1,163 @@
+# Apache License, Version 2.0
+# 
+# Copyright (c) 2013 Juergen Mangler
+# 
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+# 
+#     http://www.apache.org/licenses/LICENSE-2.0
+# 
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+######
+# ADVENTURE Simulation Trace Generator Handler Wrapper
+######
+
+module TraceBasics #{{{
+  def <<(item)
+    @elements << item
+    item.parent = self  
+  end
+  def each
+    @elements.each do |ele|
+      yield ele
+    end  
+  end
+end #}}}
+
+class Trace #{{{
+  include TraceBasics
+  attr_accessor :elements
+  def initialize
+    @elements = []
+  end
+
+  def get_container(tid)
+    recursive_get_container(self,tid) || self
+  end
+  def recursive_get_container(container,tid)
+    return container if container.respond_to?(:tid) and container.tid == tid
+    container.each do |ele| 
+      if ele.kind_of?(TraceContainer)
+        ret = recursive_get_container(ele,tid) 
+        return ret unless ret.nil?
+      end  
+    end
+    nil
+  end
+
+  private :recursive_get_container
+end #}}}
+
+class TraceBase #{{{
+  attr_accessor :tid, :parent
+  def initialize(tid)
+    @tid = tid
+    @parent = nil
+  end
+end #}}}
+
+class TraceContainer < TraceBase #{{{
+  include TraceBasics
+  attr_accessor :elements
+  def initialize(tid)
+    super tid
+    @elements = []
+    @open = true
+  end
+  def open?; @open; end
+  def close!; @open = false; end
+end #}}}
+
+class TraceElement < TraceBase #{{{
+  attr_accessor :item
+  def initialize(tid, item)
+    super tid
+    @item = item
+  end
+end #}}}
+
+class TraceParallel < TraceContainer; end
+class TraceParallelBranch < TraceContainer #{{{
+  def initialize(tid,group_by)
+    super tid
+    @group_by = group_by
+  end
+  attr_reader :group_by
+end #}}}
+class TraceLoop < TraceContainer; end
+class TraceChoose < TraceContainer
+  attr_reader :mode
+  def initialize(tid,mode)
+    super tid
+    @mode = mode
+  end  
+end
+class TraceAlternative < TraceContainer; end
+class TraceOtherwise < TraceContainer; end
+
+class PlainTrace
+  def initialize
+    @container
+  end  
+end
+
+$trace = Trace.new
+
+class SimHandlerWrapper < WEEL::HandlerWrapperBase
+  def initialize(args,endpoint=nil,position=nil,continue=nil)
+    @__myhandler_stopped = false
+    @__myhandler_position = position
+    @__myhandler_continue = continue
+    @__myhandler_endpoint = endpoint
+    @__myhandler_returnValue = nil
+  end
+
+  def simulate(type,nesting,tid,parent,parameters={})
+    pp "#{type} - #{nesting} - #{tid} - #{parent} - #{parameters.inspect}"
+
+    case type
+      when :activity
+        $trace.get_container(parent) << TraceElement.new(tid,parameters[:endpoint])
+      when :parallel
+        simulate_add_to_container($trace,nesting,parent,tid) { TraceParallel.new(tid) }
+      when :loop
+        simulate_add_to_container($trace,nesting,parent,tid) { TraceLoop.new(tid) }
+      when :parallel_branch
+        if nesting == :start
+          clast = $trace.get_container(parent)
+          until clast.kind_of?(TraceParallel)
+            clast = clast.parent
+          end  
+          clast << TraceParallelBranch.new(tid,parent)
+        else
+          clast = $trace.get_container(tid)
+          clast.close! if clast.open?
+        end  
+      when :choose
+        simulate_add_to_container($trace,nesting,parent,tid) { TraceChoose.new(tid,parameters[:mode]) }
+      when :alternative
+        simulate_add_to_container($trace,nesting,parent,tid) { TraceAlternative.new(tid) }
+      when :otherwise
+        simulate_add_to_container($trace,nesting,parent,tid) { TraceOtherwise.new(tid) }
+    end  
+  end
+
+  private
+
+    def simulate_add_to_container(trace,nesting,parent,tid) #{{{
+      if nesting == :start
+        clast = trace.get_container(parent)
+        clast << yield
+      else
+        clast = trace.get_container(tid)
+        clast.close! if clast.open?
+      end  
+    end #}}}
+
+end

data/test/TestHandlerWrapper.rb

@@ -86,35 +86,3 @@ class TestHandlerWrapper < WEEL::HandlerWrapperBase
     $short_track << "|#{newstate}|"
   end
 end
-
-module TestMixin #{{{
-  def setup
-    $long_track = ""
-    $short_track = ""
-    @wf = TestWorkflow.new
-  end
-
-  def teardown
-    @wf.stop.join
-    $long_track = ""
-    $short_track = ""
-  end
-
-  def wf_assert(what,cond=true)
-    if cond
-      assert($long_track.include?(what),"Missing \"#{what}\":\n#{$long_track}")
-    else  
-      assert(!$long_track.include?(what),"Missing \"#{what}\":\n#{$long_track}")
-    end
-  end
-  def wf_sassert(what,cond=true)
-    if cond
-      assert($short_track.include?(what),"#{$short_track}\nNot Present \"#{what}\":\n#{$long_track}")
-    else  
-      assert(!$short_track.include?(what),"#{$short_track}\nNot Present \"#{what}\":\n#{$long_track}")
-    end
-  end
-  def wf_rsassert(pat='')
-    assert($short_track =~ /#{pat}/,"Somehow executed different #{$short_track} should be '#{pat}'")
-  end
-end  #}}}

data/test/TestMixin.rb

@@ -0,0 +1,64 @@
+module SimTestMixin #{{{
+  def setup
+    $long_track = ""
+    $short_track = ""
+    @wf = nil
+  end
+
+  def teardown
+    @wf.stop.join
+    $long_track = ""
+    $short_track = ""
+  end
+
+  def wf_assert(what,cond=true)
+    if cond
+      assert($long_track.include?(what),"Missing \"#{what}\":\n#{$long_track}")
+    else  
+      assert(!$long_track.include?(what),"Missing \"#{what}\":\n#{$long_track}")
+    end
+  end
+  def wf_sassert(what,cond=true)
+    if cond
+      assert($short_track.include?(what),"#{$short_track}\nNot Present \"#{what}\":\n#{$long_track}")
+    else  
+      assert(!$short_track.include?(what),"#{$short_track}\nNot Present \"#{what}\":\n#{$long_track}")
+    end
+  end
+  def wf_rsassert(pat='')
+    assert($short_track =~ /#{pat}/,"Somehow executed different #{$short_track} should be '#{pat}'")
+  end
+end  #}}}
+
+
+module TestMixin #{{{
+  def setup
+    $long_track = ""
+    $short_track = ""
+    @wf = TestWorkflow.new
+  end
+
+  def teardown
+    @wf.stop.join
+    $long_track = ""
+    $short_track = ""
+  end
+
+  def wf_assert(what,cond=true)
+    if cond
+      assert($long_track.include?(what),"Missing \"#{what}\":\n#{$long_track}")
+    else  
+      assert(!$long_track.include?(what),"Missing \"#{what}\":\n#{$long_track}")
+    end
+  end
+  def wf_sassert(what,cond=true)
+    if cond
+      assert($short_track.include?(what),"#{$short_track}\nNot Present \"#{what}\":\n#{$long_track}")
+    else  
+      assert(!$short_track.include?(what),"#{$short_track}\nNot Present \"#{what}\":\n#{$long_track}")
+    end
+  end
+  def wf_rsassert(pat='')
+    assert($short_track =~ /#{pat}/,"Somehow executed different #{$short_track} should be '#{pat}'")
+  end
+end  #}}}

data/test/TestWorkflow.rb

@@ -1,4 +1,5 @@
 require File.expand_path(::File.dirname(__FILE__) + '/../lib/weel')
+require File.expand_path(::File.dirname(__FILE__) + '/TestMixin')
 require File.expand_path(::File.dirname(__FILE__) + '/TestHandlerWrapper')
 
 class TestWorkflow < WEEL

data/weel.gemspec

@@ -1,6 +1,6 @@
 Gem::Specification.new do |s|
   s.name             = "weel"
-  s.version          = "1.0.3"
+  s.version          = "1.1.0"
   s.platform         = Gem::Platform::RUBY
   s.summary          = "preliminary release of the Workflow Execution Engine Library (WEEL)"
 
@@ -14,7 +14,7 @@ WEE Library is freely distributable according to the terms of the GNU Lesser Gen
 This program is distributed without any warranty. See the file 'COPYING' for details.
 EOF
 
-  s.files            = Dir['{example/**/*,lib/*}'] + %w(COPYING FEATURES INSTALL Rakefile weel.gemspec README AUTHORS)
+  s.files            = Dir['{example/**/*,lib/weel.rb}'] + %w(COPYING FEATURES INSTALL Rakefile weel.gemspec README AUTHORS)
   s.require_path     = 'lib'
   s.extra_rdoc_files = ['README']
   s.test_files       = Dir['{test/*,test/*/tc_*.rb}']

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: weel
 version: !ruby/object:Gem::Version
-  version: 1.0.3
+  version: 1.1.0
   prerelease: 
 platform: ruby
 authors:
@@ -10,7 +10,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-12-19 00:00:00.000000000 Z
+date: 2013-03-12 00:00:00.000000000 Z
 dependencies: []
 description: ! 'For WEE Library specific information see http://cpee.org/.
 
@@ -31,8 +31,8 @@ extensions: []
 extra_rdoc_files:
 - README
 files:
-- example/runme.rb
 - example/SimpleHandlerWrapper.rb
+- example/runme.rb
 - example/SimpleWorkflow.rb
 - lib/weel.rb
 - COPYING
@@ -42,35 +42,37 @@ files:
 - weel.gemspec
 - README
 - AUTHORS
-- test/ContinueTest.rb
+- test/SimHandlerWrapper.rb
 - test/TestHandlerWrapper.rb
+- test/ContinueTest.rb
+- test/TestMixin.rb
 - test/TestWorkflow.rb
-- test/complex/tc_generalsynchonizingmerge_loopsearch.rb
-- test/complex/tc_parallel_stop.rb
-- test/wfp_basic/tc_parallelsplit_synchronization.rb
-- test/wfp_basic/tc_sequence.rb
-- test/wfp_basic/tc_exclusivechoice_simplemerge.rb
+- test/wfp_state_based/tc_interleavedparallelrouting.rb
+- test/wfp_state_based/tc_deferredchoice.rb
+- test/wfp_iteration/tc_structuredloop.rb
+- test/wfp_adv_branching/tc_multichoice_structuredsynchronizingmerge.rb
 - test/wfp_adv_branching/tc_generalsynchronizingmerge.rb
-- test/wfp_adv_branching/tc_generalizedjoin.rb
 - test/wfp_adv_branching/tc_localsynchronizingmerge.rb
-- test/wfp_adv_branching/tc_multichoice_structuredsynchronizingmerge.rb
 - test/wfp_adv_branching/tc_threadmerge.rb
+- test/wfp_adv_branching/tc_generalizedjoin.rb
+- test/wfp_adv_branching/tc_threadsplit.rb
+- test/wfp_adv_branching/tc_multimerge.rb
 - test/wfp_adv_branching/tc_structured_discriminator.rb
 - test/wfp_adv_branching/tc_structured_partial_join.rb
-- test/wfp_adv_branching/tc_multimerge.rb
-- test/wfp_adv_branching/tc_threadsplit.rb
-- test/basic/tc_wf_control.rb
-- test/basic/tc_endpoint.rb
 - test/basic/tc_codereplace.rb
-- test/basic/tc_search.rb
-- test/basic/tc_state.rb
-- test/basic/tc_choose.rb
 - test/basic/tc_data.rb
-- test/basic/tc_parallel.rb
 - test/basic/tc_handler.rb
-- test/wfp_iteration/tc_structuredloop.rb
-- test/wfp_state_based/tc_interleavedparallelrouting.rb
-- test/wfp_state_based/tc_deferredchoice.rb
+- test/basic/tc_parallel.rb
+- test/basic/tc_search.rb
+- test/basic/tc_endpoint.rb
+- test/basic/tc_wf_control.rb
+- test/basic/tc_choose.rb
+- test/basic/tc_state.rb
+- test/complex/tc_parallel_stop.rb
+- test/complex/tc_generalsynchonizingmerge_loopsearch.rb
+- test/wfp_basic/tc_exclusivechoice_simplemerge.rb
+- test/wfp_basic/tc_sequence.rb
+- test/wfp_basic/tc_parallelsplit_synchronization.rb
 homepage: http://cpee.org
 licenses: []
 post_install_message: 
@@ -91,37 +93,39 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 1.8.23
+rubygems_version: 1.8.11
 signing_key: 
 specification_version: 3
 summary: preliminary release of the Workflow Execution Engine Library (WEEL)
 test_files:
-- test/ContinueTest.rb
+- test/SimHandlerWrapper.rb
 - test/TestHandlerWrapper.rb
+- test/ContinueTest.rb
+- test/TestMixin.rb
 - test/TestWorkflow.rb
-- test/complex/tc_generalsynchonizingmerge_loopsearch.rb
-- test/complex/tc_parallel_stop.rb
-- test/wfp_basic/tc_parallelsplit_synchronization.rb
-- test/wfp_basic/tc_sequence.rb
-- test/wfp_basic/tc_exclusivechoice_simplemerge.rb
+- test/wfp_state_based/tc_interleavedparallelrouting.rb
+- test/wfp_state_based/tc_deferredchoice.rb
+- test/wfp_iteration/tc_structuredloop.rb
+- test/wfp_adv_branching/tc_multichoice_structuredsynchronizingmerge.rb
 - test/wfp_adv_branching/tc_generalsynchronizingmerge.rb
-- test/wfp_adv_branching/tc_generalizedjoin.rb
 - test/wfp_adv_branching/tc_localsynchronizingmerge.rb
-- test/wfp_adv_branching/tc_multichoice_structuredsynchronizingmerge.rb
 - test/wfp_adv_branching/tc_threadmerge.rb
+- test/wfp_adv_branching/tc_generalizedjoin.rb
+- test/wfp_adv_branching/tc_threadsplit.rb
+- test/wfp_adv_branching/tc_multimerge.rb
 - test/wfp_adv_branching/tc_structured_discriminator.rb
 - test/wfp_adv_branching/tc_structured_partial_join.rb
-- test/wfp_adv_branching/tc_multimerge.rb
-- test/wfp_adv_branching/tc_threadsplit.rb
-- test/basic/tc_wf_control.rb
-- test/basic/tc_endpoint.rb
 - test/basic/tc_codereplace.rb
-- test/basic/tc_search.rb
-- test/basic/tc_state.rb
-- test/basic/tc_choose.rb
 - test/basic/tc_data.rb
-- test/basic/tc_parallel.rb
 - test/basic/tc_handler.rb
-- test/wfp_iteration/tc_structuredloop.rb
-- test/wfp_state_based/tc_interleavedparallelrouting.rb
-- test/wfp_state_based/tc_deferredchoice.rb
+- test/basic/tc_parallel.rb
+- test/basic/tc_search.rb
+- test/basic/tc_endpoint.rb
+- test/basic/tc_wf_control.rb
+- test/basic/tc_choose.rb
+- test/basic/tc_state.rb
+- test/complex/tc_parallel_stop.rb
+- test/complex/tc_generalsynchonizingmerge_loopsearch.rb
+- test/wfp_basic/tc_exclusivechoice_simplemerge.rb
+- test/wfp_basic/tc_sequence.rb
+- test/wfp_basic/tc_parallelsplit_synchronization.rb