pione 0.3.2 → 0.4.0

data/test/pnml/spec_reader.rb

@@ -0,0 +1,16 @@
+require 'pione/test-helper'
+
+TestHelper.scope do |this|
+  this::OUTPUT_REDUCTION_SIMPLE = Location[__FILE__].dirname + "data" + "OutputReductionSimple.pnml"
+
+  describe Pione::PNML::Reader do
+    it "should read a PNML file" do
+      PNML::Reader.read(this::OUTPUT_REDUCTION_SIMPLE).tap do |net|
+        net.should.kind_of PNML::Net
+        net.places.size.should == 3
+        net.transitions.size.should == 2
+        net.arcs.size.should == 4
+      end
+    end
+  end
+end

data/test/rootage/spec_argument.rb

@@ -0,0 +1,18 @@
+require 'rootage/test-helper'
+
+describe Rootage::Argument do
+  it "should parse argument" do
+    cmd = Rootage::Command.new(["/path/to/a"])
+    cmd.define(:name, "test")
+
+    cmd << Rootage::Argument.new.tap do |item|
+      item.name = "arg1"
+      item.type = :path
+    end
+
+    # run
+    Rootage::ScenarioTest.succeed(cmd)
+
+    cmd.model[:arg1].should == Pathname.new("/path/to/a")
+  end
+end

data/test/rootage/spec_command.rb

@@ -0,0 +1,239 @@
+require 'rootage/test-helper'
+
+describe Rootage::CommandPhase do
+  it "should be a phase" do
+    phase = Rootage::CommandPhase.new
+    phase.use(:test) {|item| item.assign {1}}
+    phase.table.size.should == 1
+    phase.list.size.should == 1
+    phase.should.kind_of Rootage::Phase
+  end
+end
+
+describe Rootage::Command do
+  it "should run" do
+    klass = Rootage::Command.make do
+      define_phase(:p1) do |phase|
+        phase.use(:test1) {|item| item.assign {1}}
+        phase.use(:test2) {|item| item.assign {2}}
+        phase.use(:test3) {|item| item.assign {3}}
+      end
+    end
+
+    scenario = klass.new([])
+    Rootage::ScenarioTest.succeed(scenario)
+
+    scenario.model[:test1].should == 1
+    scenario.model[:test2].should == 2
+    scenario.model[:test3].should == 3
+  end
+
+  it "should run with a argument" do
+    klass = Rootage::Command.make do
+      argument(:arg1) do |item|
+        item.type = :integer
+      end
+
+      define_phase(:p1) do |phase|
+        phase.use(:test1) {|item| item.assign {1 * model[:arg1]}}
+        phase.use(:test2) {|item| item.assign {2 * model[:arg1]}}
+        phase.use(:test3) {|item| item.assign {3 * model[:arg1]}}
+      end
+    end
+
+    scenario1 = klass.new(["1"])
+    Rootage::ScenarioTest.succeed(scenario1)
+
+    scenario2 = klass.new(["2"])
+    Rootage::ScenarioTest.succeed(scenario2)
+
+    scenario3 = klass.new(["3"])
+    Rootage::ScenarioTest.succeed(scenario3)
+
+    scenario1.model.tap do |model|
+      model[:arg1].should == 1
+      model[:test1].should == 1
+      model[:test2].should == 2
+      model[:test3].should == 3
+    end
+
+    scenario2.model.tap do |model|
+      model[:arg1].should == 2
+      model[:test1].should == 2
+      model[:test2].should == 4
+      model[:test3].should == 6
+    end
+
+    scenario3.model.tap do |model|
+      model[:arg1].should == 3
+      model[:test1].should == 3
+      model[:test2].should == 6
+      model[:test3].should == 9
+    end
+  end
+
+  it "should run with arguments" do
+    klass = Rootage::Command.make do
+      argument(:arg1) do |item|
+        item.type = :string
+      end
+
+      argument(:arg2) do |item|
+        item.type = :integer
+      end
+
+      define_phase(:p1) do |phase|
+        phase.use(:test1) {|item| item.assign {model[:arg1] * model[:arg2]}}
+      end
+    end
+
+    scenario1 = klass.new(["a", "1"])
+    Rootage::ScenarioTest.succeed(scenario1)
+
+    scenario2 = klass.new(["b", "2"])
+    Rootage::ScenarioTest.succeed(scenario2)
+
+    scenario3 = klass.new(["c", "3"])
+    Rootage::ScenarioTest.succeed(scenario3)
+
+    scenario1.model.tap do |model|
+      model[:arg1].should == "a"
+      model[:arg2].should == 1
+      model[:test1].should == "a"
+    end
+
+    scenario2.model.tap do |model|
+      model[:arg1].should == "b"
+      model[:arg2].should == 2
+      model[:test1].should == "bb"
+    end
+
+    scenario3.model.tap do |model|
+      model[:arg1].should == "c"
+      model[:arg2].should == 3
+      model[:test1].should == "ccc"
+    end
+  end
+
+  it "should run with a option" do
+    klass = Rootage::Command.make do
+      option(:option1) do |item|
+        item.type = :integer
+        item.long = "--option1"
+        item.arg  = "N"
+      end
+
+      define_phase(:p1) do |phase|
+        phase.use(:test1) {|item| item.assign {1 * model[:option1]}}
+        phase.use(:test2) {|item| item.assign {2 * model[:option1]}}
+        phase.use(:test3) {|item| item.assign {3 * model[:option1]}}
+      end
+    end
+
+    scenario1 = klass.new(["--option1","1"])
+    Rootage::ScenarioTest.succeed(scenario1)
+
+    scenario2 = klass.new(["--option1", "2"])
+    Rootage::ScenarioTest.succeed(scenario2)
+
+    scenario3 = klass.new(["--option1", "3"])
+    Rootage::ScenarioTest.succeed(scenario3)
+
+    scenario1.model.tap do |model|
+      model[:option1].should == 1
+      model[:test1].should == 1
+      model[:test2].should == 2
+      model[:test3].should == 3
+    end
+
+    scenario2.model.tap do |model|
+      model[:option1].should == 2
+      model[:test1].should == 2
+      model[:test2].should == 4
+      model[:test3].should == 6
+    end
+
+    scenario3.model.tap do |model|
+      model[:option1].should == 3
+      model[:test1].should == 3
+      model[:test2].should == 6
+      model[:test3].should == 9
+    end
+  end
+
+  it "should run with options" do
+    klass = Rootage::Command.make do
+      option(:option1) do |item|
+        item.type = :string
+        item.long = "--option1"
+        item.arg  = "N"
+      end
+
+      option(:option2) do |item|
+        item.type = :integer
+        item.long = "--option2"
+        item.arg  = "STR"
+      end
+
+      define_phase(:p1) do |phase|
+        phase.use(:test1) {|item| item.assign {model[:option1] * model[:option2]}}
+      end
+    end
+
+    scenario1 = klass.new(["--option1", "a", "--option2", "1"])
+    Rootage::ScenarioTest.succeed(scenario1)
+
+    scenario2 = klass.new(["--option1", "b", "--option2", "2"])
+    Rootage::ScenarioTest.succeed(scenario2)
+
+    scenario3 = klass.new(["--option1", "c", "--option2", "3"])
+    Rootage::ScenarioTest.succeed(scenario3)
+
+    scenario1.model.tap do |model|
+      model[:option1].should == "a"
+      model[:option2].should == 1
+      model[:test1].should == "a"
+    end
+
+    scenario2.model.tap do |model|
+      model[:option1].should == "b"
+      model[:option2].should == 2
+      model[:test1].should == "bb"
+    end
+
+    scenario3.model.tap do |model|
+      model[:option1].should == "c"
+      model[:option2].should == 3
+      model[:test1].should == "ccc"
+    end
+  end
+end
+
+describe Rootage::StandardCommand do
+  it "should run" do
+    klass = Rootage::StandardCommand.make do
+      phase(:setup) do |phase|
+        phase.use(:test1) {|item| item.assign {1}}
+        phase.use(:test2) {|item| item.assign {2}}
+        phase.use(:test3) {|item| item.assign {3}}
+      end
+      phase(:execution) do |phase|
+        phase.use(:test1) {|item| item.assign {model[:test1] + 1}}
+        phase.use(:test2) {|item| item.assign {model[:test2] + 2}}
+        phase.use(:test3) {|item| item.assign {model[:test3] + 3}}
+      end
+      phase(:termination) do |phase|
+        phase.use(:test1) {|item| item.assign {model[:test1] + 1}}
+        phase.use(:test2) {|item| item.assign {model[:test2] + 2}}
+        phase.use(:test3) {|item| item.assign {model[:test3] + 3}}
+      end
+    end
+
+    scenario = klass.new([])
+    Rootage::ScenarioTest.succeed(scenario)
+
+    scenario.model[:test1].should == 3
+    scenario.model[:test2].should == 6
+    scenario.model[:test3].should == 9
+  end
+end

data/test/rootage/spec_core.rb

@@ -0,0 +1,198 @@
+require 'rootage/test-helper'
+
+Rootage.scope do |this|
+  class this::E1 < StandardError; end
+
+  describe Rootage::Action do
+    it "should execute an action" do
+      val1 = nil
+      val2 = nil
+      val3 = nil
+
+      scenario = Rootage::Scenario.new
+      scenario << Rootage::Action.new.tap do |item|
+        item.name = :test
+        item.process { val1 = 1 }
+        item.process { val2 = 2 }
+        item.process { val3 = 3 }
+      end
+
+      # check pre-state
+      val1.should.nil
+      val2.should.nil
+      val3.should.nil
+
+      # run
+      Rootage::ScenarioTest.succeed(scenario)
+
+      # check post-state
+      val1.should == 1
+      val2.should == 2
+      val3.should == 3
+    end
+
+    it "should assign process result into model" do
+      scenario = Rootage::Scenario.new
+      scenario << Rootage::Action.new.tap do |item|
+        item.name = :test
+        item.assign { 0 }
+        item.assign(:var1) { 1 }
+        item.assign(:var2) { 2 }
+        item.assign(:var3) { 3 }
+      end
+      model = scenario.model
+
+      # check pre-state
+      model[:test].should.nil
+      model[:var1].should.nil
+      model[:var2].should.nil
+      model[:var3].should.nil
+
+      # run
+      Rootage::ScenarioTest.succeed(scenario)
+
+      # check post-state
+      model[:test].should == 0
+      model[:var1].should == 1
+      model[:var2].should == 2
+      model[:var3].should == 3
+    end
+
+    it "should execute processes in order" do
+      scenario = Rootage::Scenario.new
+      scenario << Rootage::Action.new.tap do |item|
+        item.name = :test
+        item.assign { 0 }
+        item.assign(:var1) { model[:test] + 1 }
+        item.assign(:var2) { model[:var1] + 1 }
+        item.assign(:var3) { model[:var2] + 1 }
+      end
+      model = scenario.model
+
+      # check pre-state
+      model[:test].should.nil
+      model[:var1].should.nil
+      model[:var2].should.nil
+      model[:var3].should.nil
+
+      # run
+      Rootage::ScenarioTest.succeed(scenario)
+
+      # check post-state
+      model[:test].should == 0
+      model[:var1].should == 1
+      model[:var2].should == 2
+      model[:var3].should == 3
+    end
+
+    it "should handle test failures" do
+      val1 = nil
+      val2 = nil
+
+      scenario = Rootage::Scenario.new
+      scenario << Rootage::Action.new.tap do |item|
+        item.name = :test
+        item.process { test(true) ; val1 = 1 }
+        item.process { test(false); val2 = 2 }
+        item.assign(:var1) { test(true) ; 3 }
+        item.assign(:var2) { test(false); 4 }
+      end
+      model = scenario.model
+
+      # check pre-state
+      val1.should.nil
+      val2.should.nil
+      model[:var1].should.nil
+      model[:var2].should.nil
+
+      # run
+      Rootage::ScenarioTest.succeed(scenario)
+
+      # check post-state
+      val1.should == 1
+      val2.should.nil
+      model[:var1].should == 3
+      model[:var2].should.nil
+    end
+
+    it "should quit halfway because of test failure" do
+      scenario = Rootage::Scenario.new
+      scenario << Rootage::Action.new.tap do |item|
+        item.name = :test
+        item.assign(:var1) {1}
+        item.condition { test(true) }
+        item.assign(:var2) {2}
+        item.condition { test(false) }
+        item.assign(:var3) {3}
+      end
+      model = scenario.model
+
+      # check pre-state
+      model[:var1].should.nil
+      model[:var2].should.nil
+      model[:var3].should.nil
+
+      # run
+      Rootage::ScenarioTest.succeed(scenario)
+
+      # check post-state
+      model[:var1].should == 1
+      model[:var2].should == 2
+      model[:var3].should.nil
+    end
+
+    it "should use specified context" do
+      class this::TestContext < Rootage::ProcessContext
+        def test1; 1       ; end
+        def test2; scenario; end
+        def test3; model   ; end
+      end
+
+      scenario = Rootage::Scenario.new
+      scenario << Rootage::Action.new.tap do |item|
+        item.name = :test
+        item.process_context_class = this::TestContext
+
+        item.assign(:var1) { test1 }
+        item.assign(:var2) { test2 }
+        item.assign(:var3) { test3 }
+      end
+      model = scenario.model
+
+      # check pre-state
+      model[:var1].should.nil
+      model[:var2].should.nil
+      model[:var3].should.nil
+
+      # run
+      Rootage::ScenarioTest.succeed(scenario)
+
+      # check post-state
+
+      model[:var1].should == 1
+      model[:var2].should == scenario
+      model[:var3].should == model
+    end
+
+    it "should handle an exception" do
+      val = nil
+
+      scenario = Rootage::Scenario.new([])
+      scenario << Rootage::Action.new.tap do |item|
+        item.name = :test
+
+        item.process { raise this::E1 }
+        item.exception(this::E1) { val = true }
+      end
+
+      # check pre-state
+      val.should.nil
+
+      # run
+      Rootage::ScenarioTest.succeed(scenario)
+
+      # check post-state
+      val.should.true
+    end
+  end
+end