ruote 0.9.18 → 0.9.19

data/test/lookup_vf_test.rb

@@ -16,79 +16,79 @@ require 'openwfe/expressions/expressionmap'
 
 class LookupVfTest < Test::Unit::TestCase
 
-    #def setup
-    #end
+  #def setup
+  #end
 
-    #def teardown
-    #end
+  #def teardown
+  #end
 
 
-    def test_0
+  def test_0
 
-        fexp = new_exp({
-            "on-value" => "toto"
-        })
-        wi = new_wi({
-            "toto" => "whatever"
-        })
+    fexp = new_exp({
+      "on-value" => "toto"
+    })
+    wi = new_wi({
+      "toto" => "whatever"
+    })
 
-        assert_equal(
-            "toto", 
-            fexp.lookup_vf_attribute(wi, "value", :prefix => "on"))
+    assert_equal(
+      "toto",
+      fexp.lookup_vf_attribute(wi, "value", :prefix => "on"))
 
-        fexp = new_exp({ "on-variable-value" => "toto" }, { "toto" => "surf" })
+    fexp = new_exp({ "on-variable-value" => "toto" }, { "toto" => "surf" })
 
-        assert_equal(
-            "surf", 
-            fexp.lookup_vf_attribute(wi, "value", :prefix => "on"))
+    assert_equal(
+      "surf",
+      fexp.lookup_vf_attribute(wi, "value", :prefix => "on"))
 
-        fexp = new_exp({ "on-field-value" => "toto" })
+    fexp = new_exp({ "on-field-value" => "toto" })
 
-        assert_equal(
-            "whatever", 
-            fexp.lookup_vf_attribute(wi, "value", :prefix => "on"))
-    end
-
-    def test_1
+    assert_equal(
+      "whatever",
+      fexp.lookup_vf_attribute(wi, "value", :prefix => "on"))
+  end
 
-        fexp = new_exp({
-            "on" => "surf"
-        })
-        wi = new_wi
+  def test_1
 
-        assert_equal(
-            "surf", 
-            fexp.lookup_vf_attribute(wi, "", :prefix => "on"))
+    fexp = new_exp({
+      "on" => "surf"
+    })
+    wi = new_wi
 
-        assert_equal(
-            "surf", 
-            fexp.lookup_vf_attribute(wi, "", :prefix => :on))
-    end
+    assert_equal(
+      "surf",
+      fexp.lookup_vf_attribute(wi, "", :prefix => "on"))
 
-    protected
+    assert_equal(
+      "surf",
+      fexp.lookup_vf_attribute(wi, "", :prefix => :on))
+  end
 
-        def new_exp (atts, vars={})
+  protected
 
-            fexp = OpenWFE::ParticipantExpression.new
-            fexp.attributes = atts
+    def new_exp (atts, vars={})
 
-            fexp.instance_variable_set :@vars, vars
+      fexp = OpenWFE::ParticipantExpression.new
+      fexp.attributes = atts
 
-            class << fexp
-                def lookup_variable (var_name)
-                    @vars[var_name]
-                end
-            end
+      fexp.instance_variable_set :@vars, vars
 
-            fexp
+      class << fexp
+        def lookup_variable (var_name)
+          @vars[var_name]
         end
+      end
 
-        def new_wi (atts={})
+      fexp
+    end
 
-            wi = OpenWFE::InFlowWorkItem.new
-            wi.attributes = atts
-            wi
-        end
+    def new_wi (atts={})
+
+      wi = OpenWFE::InFlowWorkItem.new
+      wi.attributes = atts
+      wi
+    end
 
 end
 

data/test/misc_test.rb

@@ -7,8 +7,11 @@
 # Sun Oct 29 16:18:25 JST 2006
 #
 
+require 'rubygems'
+
 require 'test/unit'
 
+require 'rufus/dollar'
 require 'openwfe/utils'
 require 'openwfe/expressions/raw'
 #require 'openwfe/def'
@@ -21,70 +24,71 @@ require 'openwfe/expressions/expressionmap'
 
 class MiscTest < Test::Unit::TestCase
 
-    #def setup
-    #end
-
-    #def teardown
-    #end
+  #def setup
+  #end
 
-    def test_starts_with
+  #def teardown
+  #end
 
-        assert OpenWFE::starts_with("//a", "//")
-        assert (not OpenWFE::starts_with("/a", "//"))
-    end
+  def test_starts_with
 
-    def test_ends_with
+    assert OpenWFE::starts_with("//a", "//")
+    assert (not OpenWFE::starts_with("/a", "//"))
+  end
 
-        assert OpenWFE::ends_with("c'est la fin", "fin")
-    end
+  def test_ends_with
 
-    def test_ensure_for_filename
+    assert OpenWFE::ends_with("c'est la fin", "fin")
+  end
 
-        assert_equal OpenWFE::ensure_for_filename("abc"), "abc"
-        assert_equal OpenWFE::ensure_for_filename("a/c"), "a_c"
-        assert_equal OpenWFE::ensure_for_filename("a\\c"), "a_c"
-        assert_equal OpenWFE::ensure_for_filename("a*c"), "a_c"
-        assert_equal OpenWFE::ensure_for_filename("a+?"), "a__"
-        assert_equal OpenWFE::ensure_for_filename("a b"), "a_b"
-    end
+  def test_ensure_for_filename
 
-    def test_clean_path
+    assert_equal OpenWFE::ensure_for_filename("abc"), "abc"
+    assert_equal OpenWFE::ensure_for_filename("a/c"), "a_c"
+    assert_equal OpenWFE::ensure_for_filename("a\\c"), "a_c"
+    assert_equal OpenWFE::ensure_for_filename("a*c"), "a_c"
+    assert_equal OpenWFE::ensure_for_filename("a+?"), "a__"
+    assert_equal OpenWFE::ensure_for_filename("a b"), "a_b"
+  end
 
-        assert_equal OpenWFE::clean_path("my//file/path"), "my/file/path"
-        assert_equal OpenWFE::clean_path("my//file//path"), "my/file/path"
-    end
+  def test_clean_path
 
-    def test_stu
+    assert_equal OpenWFE::clean_path("my//file/path"), "my/file/path"
+    assert_equal OpenWFE::clean_path("my//file//path"), "my/file/path"
+  end
 
-        assert_equal "a_b_c", OpenWFE::stu("a b c")
-    end
+  def test_stu
 
-    def test_grep_0
+    assert_equal "a_b_c", OpenWFE::stu("a b c")
+  end
 
-        assert OpenWFE::grep("sputnik", "Rakefile").empty?
-        assert_equal 2, OpenWFE::grep("Mettraux", "Rakefile").size
+  def test_grep_0
 
-        OpenWFE::grep "Mettraux", "Rakefile" do |line|
-            assert_match "Mettraux", line
-        end
-    end
+    assert OpenWFE::grep("sputnik", "Rakefile").empty?
+    assert_equal 1, OpenWFE::grep("Mettraux", "Rakefile").size
 
-    def test_expmap_get_classes
-
-        em = OpenWFE::ExpressionMap.new
-
-        assert_equal \
-            em.get_expression_classes(Rufus::Schedulable),
-            [
-                OpenWFE::ParticipantExpression,
-                OpenWFE::SleepExpression,
-                OpenWFE::CronExpression,
-                OpenWFE::WhenExpression,
-                OpenWFE::WaitExpression,
-                #OpenWFE::ReserveExpression,
-                OpenWFE::ListenExpression,
-                OpenWFE::TimeoutExpression,
-                OpenWFE::Environment
-            ]
+    OpenWFE::grep "Mettraux", "Rakefile" do |line|
+      assert_match "Mettraux", line
     end
+  end
+
+  def test_expmap_get_classes
+
+    em = OpenWFE::ExpressionMap.new
+
+    assert_equal(
+      [
+        OpenWFE::ParticipantExpression,
+        OpenWFE::SleepExpression,
+        OpenWFE::CronExpression,
+        OpenWFE::WhenExpression,
+        OpenWFE::WaitExpression,
+        #OpenWFE::ReserveExpression,
+        OpenWFE::ListenExpression,
+        OpenWFE::TimeoutExpression,
+        OpenWFE::HpollExpression,
+        OpenWFE::Environment
+      ],
+      em.get_expression_classes(Rufus::Schedulable))
+  end
 end

data/test/obs_test.rb

@@ -18,125 +18,125 @@ require 'openwfe/util/observable'
 
 class ObsTest < Test::Unit::TestCase
 
-    #def setup
-    #end
+  #def setup
+  #end
 
-    #def teardown
-    #end
+  #def teardown
+  #end
 
-    class Observed
-        include OpenWFE::OwfeObservable
+  class Observed
+    include OpenWFE::OwfeObservable
 
-        attr_reader :observers
+    attr_reader :observers
 
-        def initialize
-            super
-            @observers = {}
-        end
-
-        public :onotify
+    def initialize
+      super
+      @observers = {}
     end
 
-    def test_0
-
-        $s = nil
+    public :onotify
+  end
 
-        observed = Observed.new
+  def test_0
 
-        observed.add_observer :channel0 do
-            $s = 0
-        end
+    $s = nil
 
-        observer1 = Object.new
-        class << observer1
-            def call channel, *args
-                $s = 1
-            end
-        end
-        observed.add_observer :channel1, observer1
+    observed = Observed.new
 
-        observer2 = lambda do |channel, args|
-            $s = 2
-        end
-        observed.add_observer :channel2, observer2
+    observed.add_observer :channel0 do
+      $s = 0
+    end
 
-        observed.onotify :channel0, :nothing
-        assert_equal $s, 0
+    observer1 = Object.new
+    class << observer1
+      def call channel, *args
+        $s = 1
+      end
+    end
+    observed.add_observer :channel1, observer1
 
-        observed.onotify :channel1, :nothing
-        assert_equal $s, 1
+    observer2 = lambda do |channel, args|
+      $s = 2
+    end
+    observed.add_observer :channel2, observer2
 
-        observed.onotify :channel2, :nothing
-        assert_equal $s, 2
+    observed.onotify :channel0, :nothing
+    assert_equal $s, 0
 
-        $s = nil
+    observed.onotify :channel1, :nothing
+    assert_equal $s, 1
 
-        observed.remove_observer observer2, :channel99
+    observed.onotify :channel2, :nothing
+    assert_equal $s, 2
 
-        observed.onotify :channel2, :nothing
-        assert_equal $s, 2
+    $s = nil
 
-        $s = nil
+    observed.remove_observer observer2, :channel99
 
-        observed.remove_observer observer2
+    observed.onotify :channel2, :nothing
+    assert_equal $s, 2
 
-        observed.onotify :channel2, :nothing
-        assert_nil $s
+    $s = nil
 
-        $s = nil
+    observed.remove_observer observer2
 
-        observed.remove_observer observer1, :channel1
+    observed.onotify :channel2, :nothing
+    assert_nil $s
 
-        observed.onotify :channel1, :nothing
-        assert_nil $s
-    end
+    $s = nil
 
+    observed.remove_observer observer1, :channel1
 
-    def test_1
+    observed.onotify :channel1, :nothing
+    assert_nil $s
+  end
 
-        $s = nil
 
-        observed = Observed.new
+  def test_1
 
-        observed.add_observer :channel0 do
-            $s = 0
-        end
-        observed.add_observer "channel[0-9]+" do
-            $s = 9
-        end
+    $s = nil
 
-        $s = nil
-        observed.onotify "channel2", :nothing
-        assert_equal $s, 9
+    observed = Observed.new
 
-        $s = nil
-        observed.onotify "channelZ", :nothing
-        assert_nil $s
+    observed.add_observer :channel0 do
+      $s = 0
     end
+    observed.add_observer "channel[0-9]+" do
+      $s = 9
+    end
+
+    $s = nil
+    observed.onotify "channel2", :nothing
+    assert_equal $s, 9
+
+    $s = nil
+    observed.onotify "channelZ", :nothing
+    assert_nil $s
+  end
 
-    def test_2
+  def test_2
 
-        observed = Observed.new
+    observed = Observed.new
 
-        o1 = observed.add_observer :channel0 do
-            puts "whatever"
-        end
-        o2 = observed.add_observer :channel0 do
-            puts "whatever"
-        end
+    o1 = observed.add_observer :channel0 do
+      puts "whatever"
+    end
+    o2 = observed.add_observer :channel0 do
+      puts "whatever"
+    end
 
-        assert_equal observed.observers.size, 1
-        assert_equal observed.observers[:channel0].size, 2
+    assert_equal observed.observers.size, 1
+    assert_equal observed.observers[:channel0].size, 2
 
-        observed.remove_observer o1
+    observed.remove_observer o1
 
-        assert_equal observed.observers.size, 1
-        assert_equal observed.observers[:channel0].size, 1
+    assert_equal observed.observers.size, 1
+    assert_equal observed.observers[:channel0].size, 1
 
-        observed.remove_observer o2
+    observed.remove_observer o2
 
-        assert_equal observed.observers.size, 1
-        assert_equal observed.observers[:channel0].size, 0
-    end
+    assert_equal observed.observers.size, 1
+    assert_equal observed.observers[:channel0].size, 0
+  end
 
 end