pione 0.2.2 → 0.3.0

data/test/component/spec_package.rb

@@ -1,109 +0,0 @@
-require_relative '../test-util'
-
-describe "Pione::Component::Package" do
-  before do
-    @location = TestUtil::Package.get("TestPackage1")
-    @package = Component::PackageReader.new(@location).read
-    @case1 = @package.scenarios[0]
-    @case2 = @package.scenarios[1]
-    @case3 = @package.scenarios[2]
-  end
-
-  it "should equal" do
-    Component::Package.new(location: @location, info: {"PackageName1" => "Test"}).should ==
-      Component::Package.new(location: @location, info: {"PackageName1" => "Test"})
-  end
-
-  it "should not equal" do
-    Component::Package.new(location: @location, info: {"PackageName1" => "Test1"}).should !=
-      Component::Package.new(location: @location, info: {"PackageName1" => "Test2"})
-  end
-
-  it "should get the package name" do
-    @package.name.should == "TestPackage1"
-  end
-
-  it "should get bin" do
-    @package.bin.should.directory
-  end
-
-  it "should get scenarios" do
-    names = @package.scenarios.map{|scenario| scenario.name}
-    names.should.include "Case1"
-    names.should.include "Case2"
-    names.should.include "Case3"
-  end
-
-  it "should get docuemtns" do
-    @package.documents.size.should == 1
-  end
-
-  it "should get rules" do
-    @package.rules.map{|rule| rule.path}.tap do |x|
-      x.should.include("&TestPackage1:Main")
-      x.should.include("&TestPackage1:Count")
-    end
-  end
-
-  it "should get a main rule" do
-    @package.find_rule("Main").path.should == "&TestPackage1:Main"
-  end
-
-  it "should upload package files" do
-    location = Location[Temppath.create]
-    @package.upload(location)
-    location.directory_entries.should.include(location + @package.name)
-    (location + @package.name + "bin").file_entries.should.include(location + @package.name + "bin" + "count")
-  end
-
-  it "should find sceinarios" do
-    @package.find_scenario(:anything).name.should == "Case1"
-    @package.find_scenario("Case1").name.should == "Case1"
-    @package.find_scenario("Case2").name.should == "Case2"
-    @package.find_scenario("Case3").name.should == "Case3"
-  end
-end
-
-describe "Pione::Component::PackageScenario" do
-  before do
-    @location = TestUtil::Package.get("TestPackage1")
-    @case1 = Component::PackageScenarioReader.new(@location, "scenario/case1").read
-    @case2 = Component::PackageScenarioReader.new(@location, "scenario/case2").read
-    @case3 = Component::PackageScenarioReader.new(@location, "scenario/case3").read
-  end
-
-  it 'should equal' do
-    Component::PackageScenario.new(@location, "scenario/case1", {"ScenarioName" => "Test"}).should ==
-      Component::PackageScenario.new(@location, "scenario/case1", {"ScenarioName" => "Test"})
-  end
-
-  it 'should not equal' do
-    Component::PackageScenario.new(@location, "scenario/case1", {"ScenarioName" => "Test1"}).should !=
-      Component::PackageScenario.new(@path, "scenario/case1", {"ScenarioName" => "Test2"})
-  end
-
-  it "should get the scenario name" do
-    @case1.name.should == "Case1"
-    @case2.name.should == "Case2"
-    @case3.name.should == "Case3"
-  end
-
-  it "should get input files" do
-    @case1.inputs[0].basename.should == "1.txt"
-    @case2.inputs[0].basename.should == "1.txt"
-    @case2.inputs[1].basename.should == "2.txt"
-    @case2.inputs[2].basename.should == "3.txt"
-    @case3.inputs[0].basename.should == "a.txt"
-    @case3.inputs[1].basename.should == "b.txt"
-  end
-
-  it "should get output files" do
-    @case1.outputs[0].basename.should == "1.count"
-    @case2.outputs[0].basename.should == "1.count"
-    @case2.outputs[1].basename.should == "2.count"
-    @case2.outputs[2].basename.should == "3.count"
-    @case3.outputs[0].basename.should == "a.count"
-    @case3.outputs[1].basename.should == "b.count"
-  end
-end
-

data/test/component/spec_rule.rb

@@ -1,140 +0,0 @@
-require_relative '../test-util'
-
-describe 'Pione::Component::RuleCondition' do
-  before do
-    @data_a = DataExpr.new("a")
-    @data_b = DataExpr.new("b")
-    @f_a = Feature::RequisiteExpr.new("a")
-    @f_b = Feature::RequisiteExpr.new("b")
-    @var_x = Variable.new("X")
-    @params_a = Parameters.new(@var_x => PioneString.new("a").to_seq)
-    @params_b = Parameters.new(@var_x => PioneString.new("b").to_seq)
-  end
-
-  it 'should be equal' do
-    a = Component::RuleCondition.new([@data_a], [@data_a], params: @params_a, features: Feature.and(@f_a))
-    b = Component::RuleCondition.new([@data_a], [@data_a], params: @params_a, features: Feature.and(@f_a))
-    a.should == b
-  end
-
-  it 'should not be equal' do
-    a = Component::RuleCondition.new([@data_a], [@data_a], params: @params_a, features: Feature.and(@f_a))
-    b = Component::RuleCondition.new([@data_b], [@data_b], params: @params_b, features: Feature.and(@f_b))
-    a.should != b
-  end
-end
-
-shared "rule" do
-  it "should get the rule name" do
-    @rule_a.name.should == "A"
-    @rule_b.name.should == "B"
-  end
-
-  it "should get the package name" do
-    @rule_a.package_name.should == "Test"
-    @rule_b.package_name.should == "Test"
-  end
-end
-
-describe 'Pione::Component::ActionRule' do
-  before do
-    @ts = create_tuple_space_server
-    @a = PioneString.new("a")
-    @b = PioneString.new("b")
-    @data_a = DataExpr.new("a").to_seq
-    @data_b = DataExpr.new("b").to_seq
-    @f_a = Feature::RequisiteExpr.new("a")
-    @f_b = Feature::RequisiteExpr.new("b")
-    @var_x = Variable.new("X")
-    @params_a = Parameters.new(@var_x => @a)
-    @params_b = Parameters.new(@var_x => @b)
-    @cond_a = Component::RuleCondition.new(
-      inputs: [@data_a],
-      outputs: [@data_a],
-      params: @params_a,
-      features: Feature.and(@f_a)
-    )
-    @cond_b = Component::RuleCondition.new(
-      inputs: [@data_b],
-      outputs: [@data_b],
-      params: @params_b,
-      features: Feature.and(@f_b)
-    )
-    @rule_a = Component::ActionRule.new("Test", "A", @cond_a, 'echo "a"')
-    @rule_b = Component::ActionRule.new("Test", "B", @cond_b, 'echo "b"')
-  end
-
-  after do
-    @ts.terminate
-  end
-
-  it 'should equal' do
-    Component::ActionRule.new("Test", "A", @cond_a, 'echo "a"').should == @rule_a
-  end
-
-  it 'should not equal' do
-    @rule_a.should != @rule_b
-  end
-
-  it 'should be action rule' do
-    @rule_a.should.action
-    @rule_b.should.action
-  end
-
-  it 'should be not flow rule' do
-    @rule_a.should.not.flow
-    @rule_b.should.not.flow
-  end
-
-  it 'should make the handler' do
-    inputs = [Tuple[:data].new(name: '1.a')]
-    handler = @rule_a.make_handler(@ts, inputs, Parameters.empty, [])
-    handler.should.be.kind_of(RuleHandler::ActionHandler)
-  end
-
-  behaves_like "rule"
-end
-
-describe 'Pione::Component::FlowRule' do
-  before do
-    @a = PioneString.new("a")
-    @b = PioneString.new("b")
-    @data_a = DataExpr.new("a")
-    @data_b = DataExpr.new("b")
-    @f_a = Feature::RequisiteExpr.new("a")
-    @f_b = Feature::RequisiteExpr.new("b")
-    @var_x = Variable.new("X")
-    @params_a = Parameters.new(@var_x => @a)
-    @params_b = Parameters.new(@var_x => @b)
-    @cond_a = Component::RuleCondition.new(
-      inputs: [@data_a],
-      outputs: [@data_a],
-      params: @params_a,
-      features: Feature.and(@f_a)
-    )
-    @cond_b = Component::RuleCondition.new(
-      inputs: [@data_b],
-      outputs: [@data_b],
-      params: @params_b,
-      features: Feature.and(@f_b)
-    )
-  end
-
-  it 'should equal' do
-    Component::FlowRule.new("Test", "Flow", @cond_a, 'echo "a"').should ==
-      Component::FlowRule.new("Test", "Flow", @cond_a, 'echo "a"')
-  end
-
-  it 'should not equal' do
-    Component::FlowRule.new("Test", "Flow1", @cond_a, 'echo "a"').should !=
-      Component::FlowRule.new("Test", "Flow2",  @cond_b, 'echo "b"')
-  end
-
-  it 'should be flow rule' do
-    Component::FlowRule.new("Test", "Flow", @cond_a, 'echo "a"').should.flow
-  end
-
-  it 'should be not action rule' do
-    Component::FlowRule.new("Test", "Flow", @cond_a, 'echo "a"').should.not.action
-  end
-end

data/test/model/spec_assignment.rb

@@ -1,52 +0,0 @@
-require_relative '../test-util'
-
-describe 'Pione::Model::Assignment' do
-  before do
-    @var_x = Variable.new("X")
-    @var_y = Variable.new("Y")
-    @var_z = Variable.new("Z")
-    @a = PioneString.new("a")
-    @b = PioneString.new("b")
-  end
-
-  it 'should be equal' do
-    x1 = Assignment.new(@var_x, @a)
-    x2 = Assignment.new(@var_x, @a)
-    x1.should.be.equal x2
-  end
-
-  it 'should not be equal' do
-    x1 = Assignment.new(@var_x, @a)
-    x2 = Assignment.new(@var_x, @b)
-    y1 = Assignment.new(@var_y, @a)
-    y2 = Assignment.new(@var_y, @b)
-    x1.should.not.be.equal x2
-    x1.should.not.be.equal y1
-    x1.should.not.be.equal y2
-  end
-
-  it 'should push variable and value into variable table' do
-    vtable = VariableTable.new
-    Assignment.new(@var_x, @a).eval(vtable).should == @a
-    vtable.get(@var_x).should == @a
-  end
-
-  it 'should evaluate the value' do
-    vtable = VariableTable.new
-    Assignment.new(
-      @var_x,
-      Message.new("as_string", IntegerSequence.new([1.to_pione]))
-    ).eval(vtable)
-    @var_x.eval(vtable).should == StringSequence.new([PioneString.new("1")])
-  end
-
-  it 'should update variable table' do
-    vtable = VariableTable.new
-    Assignment.new(@var_x, @a).eval(vtable).should == @a
-    vtable.get(@var_x).should == @a
-    Assignment.new(@var_y, @var_z).eval(vtable).should == @var_z
-    vtable.get(@var_y).should == @var_z
-    vtable.set(@var_z, @b)
-    vtable.get(@var_y).should == @b
-  end
-end

data/test/model/spec_block.rb

@@ -1,108 +0,0 @@
-require_relative '../test-util'
-
-describe 'Pione::Model::ActionBlock' do
-  it 'should be equal' do
-    ActionBlock.new("echo 'a'").should == ActionBlock.new("echo 'a'")
-  end
-
-  it 'should not be equal' do
-    ActionBlock.new("echo 'a'").should.not == ActionBlock.new("echo 'b'")
-  end
-
-  it 'should expand variables' do
-    block = ActionBlock.new("{$var1} {$var2} {$var3}")
-    vtable = VariableTable.new
-    vtable.set(Variable.new("var1"), PioneString.new("a").to_seq)
-    vtable.set(Variable.new("var2"), PioneString.new("b").to_seq)
-    vtable.set(Variable.new("var3"), PioneString.new("c").to_seq)
-    block.eval(vtable).should == ActionBlock.new("a b c")
-  end
-end
-
-describe 'Pione::Model::FlowBlock' do
-  before do
-    @rule_a = CallRule.new(RuleExpr.new(PackageExpr.new("test"), "a"))
-    @rule_b = CallRule.new(RuleExpr.new(PackageExpr.new("test"), "b"))
-    @rule_c = CallRule.new(RuleExpr.new(PackageExpr.new("test"), "c"))
-    @var_a = Variable.new("A")
-    @var_x = Variable.new("X")
-    @var_y = Variable.new("Y")
-    @var_z = Variable.new("Z")
-  end
-
-  it 'should be equal' do
-    FlowBlock.new(@rule_a).should == FlowBlock.new(@rule_a)
-  end
-
-  it 'should not equal' do
-    FlowBlock.new(@rule_a).should != FlowBlock.new(@rule_b)
-  end
-
-  it 'should get flow elements' do
-    FlowBlock.new(@rule_a, @rule_b, @rule_c).elements.should == [@rule_a, @rule_b, @rule_c]
-  end
-
-  it 'should evaluate and get call-rule elements' do
-    block = FlowBlock.new(
-      Assignment.new(@var_x, @var_y),
-      Assignment.new(@var_y, @var_z),
-      ConditionalBlock.new(
-        @var_a,
-        { BooleanSequence.new([PioneBoolean.true]) =>
-          FlowBlock.new(Assignment.new(@var_z, IntegerSequence.new([1.to_pione]))),
-        }
-      ),
-      Assignment.new(@var_a, BooleanSequence.new([PioneBoolean.true])),
-      ConditionalBlock.new(
-        Message.new("==", @var_z, IntegerSequence.new([1.to_pione])),
-        { BooleanSequence.new([PioneBoolean.true]) => FlowBlock.new(@rule_c) }
-      ),
-      @rule_a,
-      @rule_b
-    )
-    new_block = block.eval(VariableTable.new)
-    new_block.elements.should.include @rule_a
-    new_block.elements.should.include @rule_b
-    new_block.elements.should.include @rule_c
-    new_block.elements.each{|rule| rule.should.kind_of(CallRule)}
-  end
-end
-
-describe 'Pione::Model::ConditionalBlock' do
-  before do
-    @a = PioneString.new("a")
-    @b = PioneString.new("b")
-    @c = PioneString.new("c")
-    @rule_a = CallRule.new(RuleExpr.new(PackageExpr.new("test"), "a"))
-    @rule_b = CallRule.new(RuleExpr.new(PackageExpr.new("test"), "b"))
-    @rule_c = CallRule.new(RuleExpr.new(PackageExpr.new("test"), "c"))
-    @var_a = Variable.new("A")
-    @var_x = Variable.new("X")
-    @var_y = Variable.new("Y")
-    @var_z = Variable.new("Z")
-  end
-
-  it 'should be equal' do
-    ConditionalBlock.new(
-      @var_x, {@a => FlowBlock.new(@rule_a), @b => FlowBlock.new(@rule_b)}
-    ).should == ConditionalBlock.new(
-      @var_x, {@a => FlowBlock.new(@rule_a), @b => FlowBlock.new(@rule_b)}
-    )
-  end
-
-  it 'should not be equal' do
-    ConditionalBlock.new(
-      @var_x, {@a => FlowBlock.new(@rule_a), @b => FlowBlock.new(@rule_b)}
-    ).should != ConditionalBlock.new(
-      @var_y, {@a => FlowBlock.new(@rule_a), @b => FlowBlock.new(@rule_b)}
-    )
-  end
-
-  it 'should evaluate' do
-    block = ConditionalBlock.new(
-      @var_x, {@a => FlowBlock.new(@rule_a), @b => FlowBlock.new(@rule_b)}
-    )
-    vtable = VariableTable.new.set(@var_x, @a)
-    block.eval(vtable).should == FlowBlock.new(@rule_a)
-  end
-end

data/test/model/spec_boolean.rb

@@ -1,39 +0,0 @@
-require_relative '../test-util'
-
-describe 'Model::PioneBoolean' do
-  before do
-    @true = PioneBoolean.new(true)
-    @false = PioneBoolean.new(false)
-  end
-
-  it 'should get pione true object' do
-    PioneBoolean.true.should.true
-    PioneBoolean.false.should.false
-  end
-
-  it 'should equal' do
-    @true.should == PioneBoolean.true
-    @false.should == PioneBoolean.false
-  end
-
-  it 'should not equal' do
-    @true.should.not == PioneBoolean.false
-    @false.should.not == PioneBoolean.true
-  end
-
-  it 'should and' do
-    PioneBoolean.and(PioneBoolean.true, PioneBoolean.true).should.true
-    PioneBoolean.and(PioneBoolean.true, PioneBoolean.false).should.false
-    PioneBoolean.and(PioneBoolean.false, PioneBoolean.true).should.false
-    PioneBoolean.and(PioneBoolean.false, PioneBoolean.false).should.false
-  end
-
-  it 'should or' do
-    PioneBoolean.or(PioneBoolean.true, PioneBoolean.true).should.true
-    PioneBoolean.or(PioneBoolean.true, PioneBoolean.false).should.true
-    PioneBoolean.or(PioneBoolean.false, PioneBoolean.true).should.true
-    PioneBoolean.or(PioneBoolean.false, PioneBoolean.false).should.false
-  end
-
-  test_pione_method("boolean")
-end