pione 0.1.0

data/test/model/spec_rule.rb

@@ -0,0 +1,158 @@
+require_relative '../test-util'
+
+describe 'Model::RuleCondition' do
+  it 'should be equal' do
+    a = RuleCondition.new(
+      [DataExpr.new("a")],
+      [DataExpr.new("a")],
+      Parameters.new(Variable.new("var") => "a".to_pione),
+      Feature.and(Feature::RequisiteExpr.new("a"))
+    )
+    b = RuleCondition.new(
+      [DataExpr.new("a")],
+      [DataExpr.new("a")],
+      Parameters.new(Variable.new("var") => "a".to_pione),
+      Feature.and(Feature::RequisiteExpr.new("a"))
+    )
+    a.should == b
+  end
+
+  it 'should not be equal' do
+    a = RuleCondition.new(
+      [DataExpr.new("a")],
+      [DataExpr.new("a")],
+      Parameters.new(Variable.new("var") => "a".to_pione),
+      Feature.and(Feature::RequisiteExpr.new("a"))
+    )
+    b = RuleCondition.new(
+      [DataExpr.new("b")],
+      [DataExpr.new("b")],
+      Parameters.new(Variable.new("var") => "b".to_pione),
+      Feature.and(Feature::RequisiteExpr.new("b"))
+    )
+    a.should.not == b
+  end
+end
+
+condition_a = RuleCondition.new(
+  [DataExpr.new("a")],
+  [DataExpr.new("a")],
+  Parameters.new(Variable.new("var") => "a".to_pione),
+  Feature.and(Feature::RequisiteExpr.new("a"))
+)
+condition_b = RuleCondition.new(
+  [DataExpr.new("b")],
+  [DataExpr.new("b")],
+  Parameters.new(Variable.new("var") => "b".to_pione),
+  Feature.and(Feature::RequisiteExpr.new("b"))
+)
+
+describe 'Model::ActionRule' do
+  it 'should be equal' do
+    a = ActionRule.new(
+      RuleExpr.new(Package.new("test"), 'a'),
+      condition_a,
+      'echo "a"'
+    )
+    b = ActionRule.new(
+      RuleExpr.new(Package.new("test"), 'a'),
+      condition_a,
+      'echo "a"'
+    )
+    a.should == b
+  end
+
+  it 'should be not equal' do
+    a = ActionRule.new(
+      RuleExpr.new(Package.new("test"), 'a'),
+      condition_a,
+      'echo "a"'
+    )
+    b = ActionRule.new(
+      RuleExpr.new(Package.new("test"), 'b'),
+      condition_b,
+      'echo "b"'
+    )
+    a.should.not == b
+  end
+
+  it 'should be action rule' do
+    ActionRule.new(
+      RuleExpr.new(Package.new("test"), 'a'),
+      condition_a,
+      'echo "a"'
+    ).should.action
+  end
+
+  it 'should be not flow rule' do
+    ActionRule.new(
+      RuleExpr.new(Package.new("test"), 'a'),
+      condition_a,
+      'echo "a"'
+    ).should.not.flow
+  end
+
+  it 'should make an action handler' do
+    create_remote_tuple_space_server
+    rule = ActionRule.new(
+      RuleExpr.new(Package.new("test"), 'a'),
+      condition_a,
+      'echo "a"'
+    )
+    dir = Dir.mktmpdir
+    uri_a = "local:#{dir}/1.a"
+    uri_b = "local:#{dir}/1.b"
+    Resource[uri_a].create("1")
+    inputs = [Tuple[:data].new(name: '1.a', uri: uri_a)]
+    params = Parameters.empty
+    handler = rule.make_handler(tuple_space_server, inputs, params, [])
+    handler.should.be.kind_of(RuleHandler::ActionHandler)
+    tuple_space_server.terminate
+  end
+end
+
+describe 'Model::FlowRule' do
+  it 'should be equal' do
+    a = FlowRule.new(
+      RuleExpr.new(Package.new("test"), 'a'),
+      condition_a,
+      'echo "a"'
+    )
+    b = FlowRule.new(
+      RuleExpr.new(Package.new("test"), 'a'),
+      condition_a,
+      'echo "a"'
+    )
+    a.should == b
+  end
+
+  it 'should be not equal' do
+    a = FlowRule.new(
+      RuleExpr.new(Package.new("test"), 'a'),
+      condition_a,
+      'echo "a"'
+    )
+    b = FlowRule.new(
+      RuleExpr.new(Package.new("test"), 'b'),
+      condition_b,
+      'echo "b"'
+    )
+    a.should.not == b
+  end
+
+  it 'should be flow rule' do
+    FlowRule.new(
+      RuleExpr.new(Package.new("test"), 'a'),
+      condition_a,
+      'echo "a"'
+    ).should.flow
+  end
+
+  it 'should be not action rule' do
+    FlowRule.new(
+      RuleExpr.new(Package.new("test"), 'a'),
+      condition_a,
+      'echo "a"'
+    ).should.not.action
+  end
+end

data/test/model/spec_string.rb

@@ -0,0 +1,106 @@
+require_relative '../test-util'
+
+describe 'Model::PioneString' do
+  before do
+    @a = PioneString.new("a")
+    @b = PioneString.new("b")
+  end
+
+  it 'should get a ruby object that has same value' do
+    @a.to_ruby.should == "a"
+  end
+
+  it 'should equal' do
+    @a.should == PioneString.new("a")
+  end
+
+  it 'should not equal' do
+    @a.should.not == @b
+  end
+
+  it 'should expand variables' do
+    vtable = VariableTable.new({
+        Variable.new("var1") => PioneString.new("a"),
+        Variable.new("var2") => PioneString.new("b")
+      })
+    PioneString.new("{$var1}:{$var2}").eval(vtable).should ==
+      PioneString.new("a:b")
+  end
+
+  it 'should expand an expression' do
+    vtable = VariableTable.new
+    PioneString.new("1 + 1 = <?1 + 1?>").eval(vtable).should ==
+      PioneString.new("1 + 1 = 2")
+    PioneString.new("1 + 2 = <? 1 + 2 ?>").eval(vtable).should ==
+      PioneString.new("1 + 2 = 3")
+  end
+
+  describe 'pione method ==' do
+    it 'should true' do
+      @a.call_pione_method("==", PioneString.new("a")).should.true
+    end
+
+    it 'should false' do
+      @a.call_pione_method("==", @b).should.not.true
+    end
+
+    it 'should raise type error' do
+      should.raise(PioneModelTypeError) do
+        @a.call_pione_method("==", PioneInteger.new(1))
+      end
+    end
+  end
+
+  describe 'pione method !=' do
+    it 'should true' do
+      @a.call_pione_method("!=", @b).should.true
+    end
+
+    it 'should false' do
+      @a.call_pione_method("!=", PioneString.new("a")).should.not.true
+    end
+
+    it 'should raise type error' do
+      should.raise(PioneModelTypeError) do
+        @a.call_pione_method("!=", PioneInteger.new(1))
+      end
+    end
+  end
+
+  describe 'pione method +' do
+    it 'should get appended string' do
+      @a.call_pione_method("+", @b).should == PioneString.new("ab")
+    end
+
+    it 'should raise type error' do
+      should.raise(PioneModelTypeError) do
+        @a.call_pione_method("!=", PioneInteger.new(1))
+      end
+    end
+  end
+
+  describe 'pione method as_string' do
+    it 'should get string' do
+      @a.call_pione_method("as_string").should == @a
+    end
+  end
+
+  describe 'pione method length' do
+    it 'should get length of string' do
+      @a.call_pione_method("length").should == PioneInteger.new(1)
+    end
+  end
+
+  describe 'pione method include?' do
+    it 'should get truth' do
+      PioneString.new("acd").call_pione_method("include?", @a).should.true
+      PioneString.new("acd").call_pione_method("include?", @b).should.false
+    end
+
+    it 'should raise type error' do
+      should.raise(PioneModelTypeError) do
+        @a.call_pione_method("include?", PioneInteger.new(1))
+      end
+    end
+  end
+end

data/test/model/spec_variable-table.rb

@@ -0,0 +1,117 @@
+require_relative '../test-util'
+
+describe 'Model::VariableTable' do
+  before do
+    @table = VariableTable.new
+    @table.set(Variable.new('A'), PioneInteger.new(1))
+    @table.set(Variable.new('B'), PioneInteger.new(2))
+    @table.set(Variable.new('C'), PioneInteger.new(3))
+  end
+
+  it 'should get an empty table' do
+    VariableTable.empty.should.empty
+  end
+
+  it 'should get a variable value' do
+    @table.get(Variable.new('A')).should == PioneInteger.new(1)
+    @table.get(Variable.new('B')).should == PioneInteger.new(2)
+    @table.get(Variable.new('C')).should == PioneInteger.new(3)
+  end
+
+  it 'should get nil if the variable is unknown in the table' do
+    @table.get(Variable.new('D')).should.nil
+  end
+
+  it 'should set a new variable' do
+    @table.set(Variable.new('D'), PioneInteger.new(4))
+    @table.get(Variable.new('D')).should == PioneInteger.new(4)
+  end
+
+  it 'should not raise errors by binding same value as same name variable' do
+    should.not.raise(VariableBindingError) do
+      @table.set(Variable.new('A'), PioneInteger.new(1))
+      @table.set(Variable.new('B'), PioneInteger.new(2))
+      @table.set(Variable.new('C'), PioneInteger.new(3))
+    end
+  end
+
+  it 'should raise an error by binding different value as same name variable' do
+    should.raise(VariableBindingError) do
+      @table.set(Variable.new('A'), PioneInteger.new(100))
+    end
+  end
+
+  it 'should expand a string with variable name form' do
+    @table.expand('{$A}').should == '1'
+    @table.expand('{$B}').should == '2'
+    @table.expand('{$C}').should == '3'
+  end
+
+  it 'should expand a string with variable expression form' do
+    @table.expand('<? $A + 1 ?>').should == '2'
+    @table.expand('<? $B + 1 ?>').should == '3'
+    @table.expand('<? $C + 1 ?>').should == '4'
+  end
+
+  it 'should get keys' do
+    vars = @table.variables
+    vars.should.include(Variable.new("A"))
+    vars.should.include(Variable.new("B"))
+    vars.should.include(Variable.new("C"))
+    vars.should.not.include(Variable.new("D"))
+  end
+
+  it 'should raise an error by unknown variable when expanding a string' do
+    should.raise(UnboundVariableError) do
+      @table.expand('{$D}')
+    end
+  end
+
+  it 'should have input auto variables' do
+    input_exprs = [
+      DataExpr.new('*.a'),
+      DataExpr.new('*.b').all
+    ]
+    input_tuples = [
+      Tuple[:data].new(name: '1.a', uri: 'test'),
+      [ Tuple[:data].new(name: '1.b', uri: 'test1'),
+        Tuple[:data].new(name: '2.b', uri: 'test2'),
+        Tuple[:data].new(name: '3.b', uri: 'test3')]
+    ]
+
+    @table.make_input_auto_variables(input_exprs, input_tuples)
+
+    input = @table.get(Variable.new('I'))
+    input.should.kind_of(RuleIOList)
+    input.should == @table.get(Variable.new('INPUT'))
+
+    input1 = input[0]
+    input1.should.kind_of(RuleIOElement)
+    input1.name.should == "1.a".to_pione
+    input1.match.size.should == 2
+    input1.match[0] == "1.a".to_pione
+    input1.match[1] == "1".to_pione
+    input1.uri = "test"
+
+    input2 = input[1]
+    input2.should.kind_of(RuleIOList)
+    input2.size.should == 3
+    input2[0].should.kind_of(RuleIOElement)
+    input2[0].name.should == "1.b".to_pione
+    input2[0].match.size.should == 2
+    input2[0].match[0].should == "1.b".to_pione
+    input2[0].match[1].should == "1".to_pione
+    input2[1].should.kind_of(RuleIOElement)
+    input2[1].name.should == "2.b".to_pione
+    input2[1].match.size.should == 2
+    input2[1].match[0].should == "2.b".to_pione
+    input2[1].match[1].should == "2".to_pione
+    input2[2].should.kind_of(RuleIOElement)
+    input2[2].name.should == "3.b".to_pione
+    input2[2].match.size.should == 2
+    input2[2].match[0].should == "3.b".to_pione
+    input2[2].match[1].should == "3".to_pione
+
+    @table.get(Variable.new('*')).should == PioneString.new('1')
+  end
+end

data/test/model/spec_variable.rb

@@ -0,0 +1,84 @@
+require_relative '../test-util'
+
+describe 'Model::Variable' do
+  before do
+    @a = Variable.new("a")
+    @b = Variable.new("b")
+  end
+
+  it 'should equal' do
+    @a.should == Variable.new("a")
+  end
+
+  it 'should not equal' do
+    @a.should.not == @b
+  end
+
+  describe 'pione method ==' do
+    it 'should true' do
+      @a.call_pione_method("==", @a).should.true
+      vtable = VariableTable.new
+      vtable.set(@a, PioneInteger.new(1))
+      vtable.set(@b, PioneInteger.new(1))
+      BinaryOperator.new("==", @a, @b).eval(vtable).should.true
+    end
+
+    it 'should false' do
+      vtable = VariableTable.new
+      vtable.set(@a, PioneInteger.new(1))
+      vtable.set(@b, PioneInteger.new(2))
+      BinaryOperator.new("==", @a, @b).eval(vtable).should.false
+    end
+
+    it 'should raise unbound variable error' do
+      vtable = VariableTable.new
+      vtable.set(@a, PioneInteger.new(1))
+      should.raise(UnboundVariableError) do
+        BinaryOperator.new("==", @a, @b).eval(vtable)
+      end
+    end
+
+    it 'should raise type error' do
+      vtable = VariableTable.new
+      vtable.set(@a, PioneInteger.new(1))
+      vtable.set(@b, PioneFloat.new(1.0))
+      should.raise(PioneModelTypeError) do
+        BinaryOperator.new("==", @a, @b).eval(vtable)
+      end
+    end
+  end
+
+  describe 'pione method !=' do
+    it 'should true' do
+      vtable = VariableTable.new
+      vtable.set(@a, PioneInteger.new(1))
+      vtable.set(@b, PioneInteger.new(2))
+      BinaryOperator.new("!=", @a, @b).eval(vtable).should.true
+    end
+
+    it 'should false' do
+      @a.call_pione_method("!=", @a).should.false
+      vtable = VariableTable.new
+      vtable.set(@a, PioneInteger.new(1))
+      vtable.set(@b, PioneInteger.new(1))
+      BinaryOperator.new("!=", @a, @b).eval(vtable).should.false
+    end
+
+    it 'should raise unbound variable error' do
+      vtable = VariableTable.new
+      vtable.set(@a, PioneInteger.new(1))
+      should.raise(UnboundVariableError) do
+        BinaryOperator.new("!=", @a, @b).eval(vtable)
+      end
+    end
+
+    it 'should raise type error' do
+      vtable = VariableTable.new
+      vtable.set(@a, PioneInteger.new(1))
+      vtable.set(@b, PioneFloat.new(1.0))
+      should.raise(PioneModelTypeError) do
+        BinaryOperator.new("!=", @a, @b).eval(vtable)
+      end
+    end
+  end
+end