pione 0.2.2 → 0.3.0

data/test/system/spec_domain-info.rb

@@ -1,25 +1,29 @@
-require_relative "../test-util"
+require 'pione/test-helper'
 
 describe "Pione::System::DomainInfo" do
   before do
-    @vtable = Model::VariableTable.new
-    @vtable.set(Variable.new("A"), Model::PioneInteger.new(1).to_seq)
-    @vtable.set(Variable.new("B"), Model::PioneFloat.new(1.23).to_seq)
-    @vtable.set(Variable.new("C"), Model::PioneString.new("A").to_seq)
-    @vtable.set(Variable.new("D"), Model::PioneBoolean.new(true).to_seq)
+    @env = TestHelper::Lang.env
+    TestHelper::Lang.declaration!(@env, "$A := 1")
+    TestHelper::Lang.declaration!(@env, "$B := 1.23")
+    TestHelper::Lang.declaration!(@env, "$C := $A")
+    TestHelper::Lang.declaration!(@env, "$D := true")
     @location = Location[Temppath.create].tap do |location|
-      System::DomainInfo.new(@vtable).write(location)
+      System::DomainInfo.new(@env).write(location)
     end
   end
 
   it "should write a domain info file" do
     location = Location[Temppath.create]
-    System::DomainInfo.new(@vtable).write(location)
+    System::DomainInfo.new(@env).write(location)
     location.should.exist
   end
 
   it "should read a domain info file" do
-    System::DomainInfo.read(@location).variable_table.should == @vtable
+    env = System::DomainInfo.read(@location).env
+    env.variable_get(Lang::Variable.new("A")).should == TestHelper::Lang.expr("1")
+    env.variable_get(Lang::Variable.new("B")).should == TestHelper::Lang.expr("1.23")
+    env.variable_get(Lang::Variable.new("C")).should == TestHelper::Lang.expr("1")
+    env.variable_get(Lang::Variable.new("D")).should == TestHelper::Lang.expr("true")
   end
 end
 

data/test/system/spec_file-cache.rb

@@ -1,13 +1,13 @@
-require_relative '../test-util'
+require 'pione/test-helper'
 
 describe 'System::FileCache' do
   before do
-    FileCache.clear
+    System::FileCache.clear
   end
 
   it 'shoud get cached file path' do
     orig_location = Location[Temppath.create].tap{|x| x.create("A")}
-    cache_location = FileCache.get(orig_location)
+    cache_location = System::FileCache.get(orig_location)
     orig_location.should.exist
     cache_location.should.exist
     cache_location.read.should == "A"
@@ -19,20 +19,20 @@ describe 'System::FileCache' do
   it 'should put source into destination' do
     src = Location[Temppath.create].tap{|x| x.create("A")}
     dest = Location[Temppath.create]
-    FileCache.put(src, dest)
+    System::FileCache.put(src, dest)
     src.should.cached
     dest.should.cached
-    FileCache.get(src).read.should == "A"
-    FileCache.get(dest).read.should == "A"
-    FileCache.get(src).should == FileCache.get(dest)
+    System::FileCache.get(src).read.should == "A"
+    System::FileCache.get(dest).read.should == "A"
+    System::FileCache.get(src).should == System::FileCache.get(dest)
     src.path.ftype == "link"
     dest.path.ftype == "file"
-    FileCache.get(src).path.ftype == "link"
+    System::FileCache.get(src).path.ftype == "link"
   end
 
   it 'should cached' do
     orig = Location[Temppath.create].tap{|x| x.create("A")}
-    FileCache.get(orig)
+    System::FileCache.get(orig)
     orig.should.cached
   end
 end

data/test/tuple-space/spec_tuple-space-server.rb

@@ -1,49 +1,51 @@
-require_relative '../test-util'
+require 'pione/test-helper'
 
-describe "Pione::TupleSpace::TupleSpaceServer" do
-  before do
-    DRb.start_service
-    @server = TupleSpaceServer.new
-    sleep 1
+TestHelper.scope do |this|
+  class this::TestTuple < TupleSpace::BasicTuple
+    define_format [:test_, :sym]
   end
 
-  after do
-    DRb.stop_service
-  end
+  describe Pione::TupleSpace::TupleSpaceServer do
+    before do
+      @server = TupleSpaceServer.new({}, false)
+    end
 
-  it "should create be alive" do
-    @server.should.alive
-  end
+    after do
+      @server.terminate
+    end
 
-  it "should count tuple size" do
-    Tuple.define_format [:test, :sym]
-    @server.write([:test, :a])
-    @server.count_tuple([:test, nil]).should == 1
-    @server.write([:test, :b])
-    @server.count_tuple([:test, nil]).should == 2
-    Tuple.delete_format(:test)
-  end
+    it "should create be alive" do
+      @server.should.alive
+    end
 
-  it "should count workers" do
-    @server.current_task_worker_size.should == 0
-    t1 = Tuple[:agent].new(agent_type: :task_worker, uuid: Util.generate_uuid)
-    @server.write(t1)
-    @server.current_task_worker_size.should == 1
-    t2 = Tuple[:agent].new(agent_type: :task_worker, uuid: Util.generate_uuid)
-    @server.write(t2)
-    @server.current_task_worker_size.should == 2
-    t3 = Tuple[:agent].new(agent_type: :task_worker, uuid: Util.generate_uuid)
-    @server.write(t3)
-    @server.current_task_worker_size.should == 3
-    @server.take(t1)
-    @server.current_task_worker_size.should == 2
-    @server.take(t2)
-    @server.current_task_worker_size.should == 1
-    @server.take(t3)
-    @server.current_task_worker_size.should == 0
-  end
+    it "should count tuple size" do
+      @server.write(this::TestTuple.new(:a))
+      @server.count_tuple(this::TestTuple.new).should == 1
+      @server.write(this::TestTuple.new(:b))
+      @server.count_tuple(this::TestTuple.new).should == 2
+    end
+
+    it "should count workers" do
+      @server.current_task_worker_size.should == 0
+      t1 = TupleSpace::AgentTuple.new(agent_type: :task_worker, uuid: Util::UUID.generate)
+      @server.write(t1)
+      @server.current_task_worker_size.should == 1
+      t2 = TupleSpace::AgentTuple.new(agent_type: :task_worker, uuid: Util::UUID.generate)
+      @server.write(t2)
+      @server.current_task_worker_size.should == 2
+      t3 = TupleSpace::AgentTuple.new(agent_type: :task_worker, uuid: Util::UUID.generate)
+      @server.write(t3)
+      @server.current_task_worker_size.should == 3
+      @server.take(t1)
+      @server.current_task_worker_size.should == 2
+      @server.take(t2)
+      @server.current_task_worker_size.should == 1
+      @server.take(t3)
+      @server.current_task_worker_size.should == 0
+    end
 
-  it "should know worker resource" do
-    @server.task_worker_resource.should == 1
+    it "should know worker resource" do
+      @server.task_worker_resource.should == 1
+    end
   end
 end

data/test/tuple/spec_basic-tuple.rb

@@ -1,86 +1,88 @@
-require_relative '../test-util'
+require 'pione/test-helper'
 
-class TestTuple < Pione::Tuple::BasicTuple
-  define_format([:test,
-      [:attr1, Integer],
-      [:attr2, Symbol],
-      [:attr3, Object]])
-end
-
-describe "Pione::Tuple::BasicTuple" do
-  it "should get a tuple class" do
-    Tuple[:test].should.not.be.nil
-    Tuple[:test].should == TestTuple
-    Tuple[:test].ancestors.should.include Pione::Tuple::BasicTuple
-    Tuple[:test].format.should == [:test,
-      [:attr1, Integer],
-      [:attr2, Symbol],
-      [:attr3, Object]
-    ]
+TestHelper.scope do |this|
+  class this::TestTuple < Pione::TupleSpace::BasicTuple
+    define_format([:test,
+        [:attr1, Integer],
+        [:attr2, Symbol],
+        [:attr3, Object]])
   end
 
-  it "should get a tuple object" do
-    t1 = Tuple[:test].new(attr1: 1, attr2: :a, attr3: 3)
-    t2 = Tuple[:test].new(attr1: 3, attr2: :a, attr3: 1)
-    t3 = Tuple[:test].new(attr2: :a, attr3: 3, attr1: 1)
-    t4 = Tuple[:test].new(1, :a, 3)
-    t5 = Tuple[:test].new(3, :a, 1)
-    [t1, t2, t3, t4, t5].each {|t| t.should.be.kind_of? Tuple[:test]}
-    t1.should.not == t2
-    t1.should == t3
-    t1.should == t4
-    t1.should.not == t5
-    t2.should.not == t3
-    t2.should.not == t4
-    t2.should == t5
-    t3.should == t4
-    t3.should.not == t5
-    t4.should.not == t5
-  end
+  describe "Pione::TupleSpace::BasicTuple" do
+    it "should get a tuple class" do
+      this::TestTuple.should.not.be.nil
+      TupleSpace[:test].should == this::TestTuple
+      this::TestTuple.ancestors.should.include Pione::TupleSpace::BasicTuple
+      this::TestTuple.format.should == [:test,
+        [:attr1, Integer],
+        [:attr2, Symbol],
+        [:attr3, Object]
+      ]
+    end
 
-  it "should get values of tuple objects" do
-    t1 = Tuple[:test].new(attr1: 1, attr2: :a, attr3: true)
-    t1.attr1.should == 1
-    t1.attr2.should == :a
-    t1.attr3.should == true
-    t2 = Tuple[:test].new(attr1: 2, attr3: false)
-    t2.attr1.should == 2
-    t2.attr2.should.be.nil
-    t2.attr3.should == false
-  end
+    it "should get a tuple object" do
+      t1 = this::TestTuple.new(attr1: 1, attr2: :a, attr3: 3)
+      t2 = this::TestTuple.new(attr1: 3, attr2: :a, attr3: 1)
+      t3 = this::TestTuple.new(attr2: :a, attr3: 3, attr1: 1)
+      t4 = this::TestTuple.new(1, :a, 3)
+      t5 = this::TestTuple.new(3, :a, 1)
+      [t1, t2, t3, t4, t5].each {|t| t.should.be.kind_of? this::TestTuple}
+      t1.should.not == t2
+      t1.should == t3
+      t1.should == t4
+      t1.should.not == t5
+      t2.should.not == t3
+      t2.should.not == t4
+      t2.should == t5
+      t3.should == t4
+      t3.should.not == t5
+      t4.should.not == t5
+    end
 
-  it "should set new data in each field" do
-    t = Tuple[:test].new(attr1: 1, attr2: :a, attr3: true)
-    t.attr1 = 2
-    t.attr2 = :b
-    t.attr3 = false
-    t.attr1.should.equal 2
-    t.attr2.should.equal :b
-    t.attr3.should.equal false
-  end
+    it "should get values of tuple objects" do
+      t1 = this::TestTuple.new(attr1: 1, attr2: :a, attr3: true)
+      t1.attr1.should == 1
+      t1.attr2.should == :a
+      t1.attr3.should == true
+      t2 = this::TestTuple.new(attr1: 2, attr3: false)
+      t2.attr1.should == 2
+      t2.attr2.should.be.nil
+      t2.attr3.should == false
+    end
 
-  it "should get any form" do
-    any = Tuple[:test].any
-    any.should == Tuple[:test].new
-    any.attr1.should.be.nil
-    any.attr2.should.be.nil
-    any.attr3.should.be.nil
-  end
+    it "should set new data in each field" do
+      t = this::TestTuple.new(attr1: 1, attr2: :a, attr3: true)
+      t.attr1 = 2
+      t.attr2 = :b
+      t.attr3 = false
+      t.attr1.should.equal 2
+      t.attr2.should.equal :b
+      t.attr3.should.equal false
+    end
 
-  it "should get tuple object from array" do
-    t = Tuple.from_array([:test, 1, :a, true])
-    t.should.be.kind_of TestTuple
-    t.attr1.should.== 1
-    t.attr2.should.== :a
-    t.attr3.should.== true
-    t.should.== Tuple[:test].new(attr1: 1, attr2: :a, attr3: true)
-  end
+    it "should get any form" do
+      any = this::TestTuple.any
+      any.should == this::TestTuple.new
+      any.attr1.should.be.nil
+      any.attr2.should.be.nil
+      any.attr3.should.be.nil
+    end
+
+    it "should get tuple object from array" do
+      t = TupleSpace.from_array([:test, 1, :a, true])
+      t.should.be.kind_of this::TestTuple
+      t.attr1.should.== 1
+      t.attr2.should.== :a
+      t.attr3.should.== true
+      t.should.== this::TestTuple.new(attr1: 1, attr2: :a, attr3: true)
+    end
 
-  it "should raise exception when tuple is redefined by different format" do
-    # different format
-    should.raise(ScriptError) do
-      class TestTuple
-        define_format([:test, :attr3, :attr2, :attr1])
+    it "should raise exception when tuple is redefined by different format" do
+      # different format
+      should.raise(ScriptError) do
+        class this::TestTuple
+          define_format([:test, :attr3, :attr2, :attr1])
+        end
       end
     end
   end

data/test/tuple/spec_data-tuple.rb

@@ -1,13 +1,13 @@
-require_relative '../test-util'
+require 'pione/test-helper'
 require_relative 'tuple-behavior'
 
-describe 'Pione::Tuple::DataTuple' do
+describe 'Pione::TupleSpace::DataTuple' do
   before do
     @domain = "A"
-    @name = Model::DataExpr.new("a.txt")
+    @name = Lang::DataExprSequence.of("a.txt")
     @location = Location["local:/home/keita/"]
     @time = Time.now
-    @tuple = Tuple::DataTuple.new(@domain, @name, @location, @time)
+    @tuple = TupleSpace::DataTuple.new(@domain, @name, @location, @time)
   end
 
   behaves_like "tuple"

data/test/tuple/spec_finished-tuple.rb

@@ -1,19 +1,18 @@
-require_relative '../test-util'
+require 'pione/test-helper'
 require_relative 'tuple-behavior'
 
-describe 'Pione::Tuple::FinishedTuple' do
+describe 'Pione::TupleSpace::FinishedTuple' do
   before do
     @domain = "A"
     @status = :success
 
-    name = Model::DataExpr.new("a.txt")
+    name = Lang::DataExprSequence.of("a.txt")
     location = Location["local:/home/keita/"]
     time = Time.now
-    data = Tuple::DataTuple.new(@domain, name, location, time)
+    data = TupleSpace::DataTuple.new(@domain, name, location, time)
 
     @outputs = [data]
-    @digest = "A"
-    @tuple = Tuple::FinishedTuple.new(@domain, @status, @outputs, @digest)
+    @tuple = TupleSpace::FinishedTuple.new(@domain, @status, @outputs)
   end
 
   behaves_like "tuple"

data/test/tuple/spec_message-tuple.rb

@@ -1,9 +1,9 @@
-require_relative '../test-util'
+require 'pione/test-helper'
 require_relative 'tuple-behavior'
 
-describe 'Pione::Tuple::MessageTuple' do
+describe 'Pione::TupleSpace::MessageTuple' do
   before do
-    @tuple = Tuple::MessageTuple.new(type: "test", head: "test", color: :green, level: 0, contents: "test")
+    @tuple = TupleSpace::MessageTuple.new(type: "test", head: "test", color: :green, level: 0, contents: "test")
   end
 
   behaves_like "tuple"

data/test/tuple/spec_task-tuple.rb

@@ -1,20 +1,22 @@
-require_relative '../test-util'
+require 'pione/test-helper'
 require_relative 'tuple-behavior'
 
-describe 'Pione::Tuple::TaskTuple' do
+describe 'Pione::TupleSpace::TaskTuple' do
   before do
     domain = "A"
-    data = Tuple[:data].new(domain, "a.txt", Location["local:/home/keita/"], Time.now)
+    data = TupleSpace::DataTuple.new(domain, "a.txt", Location["local:/home/keita/"], Time.now)
 
-    @rule_path = "main_Main"
+    @digest = "digest"
+    @package_id = "Main"
+    @rule_name = "Main"
     @inputs = [data]
-    @params = Parameters.new(Model::Variable.new("X") => Model::PioneInteger.new(1))
-    @features = Feature.empty
+    @params = Lang::ParameterSet.new(Lang::Variable.new("X") => Lang::IntegerSequence.of(1))
+    @features = Lang::FeatureSequence.new
     @domain = domain
-    @call_stack = []
+    @caller_id = "caller"
 
-    args = [@rule_path, @inputs, @params, @features, @domain, @call_stack]
-    @tuple = Tuple::TaskTuple.new(*args)
+    args = [@digest, @package_id, @rule_name, @inputs, @params, @features, @domain, @caller_id]
+    @tuple = TupleSpace::TaskTuple.new(*args)
   end
 
   behaves_like "tuple"

data/test/tuple/spec_touch-tuple.rb

@@ -1,12 +1,12 @@
-require_relative '../test-util'
+require 'pione/test-helper'
 require_relative 'tuple-behavior'
 
-describe 'Pione::Tuple::TouchTuple' do
+describe 'Pione::TupleSpace::TouchTuple' do
   before do
     @domain = "A"
     @name = "a.txt"
     @time = Time.now
-    @tuple = Tuple::TouchTuple.new(domain: @domain, name: @name, time: @time)
+    @tuple = TupleSpace::TouchTuple.new(domain: @domain, name: @name, time: @time)
   end
 
   behaves_like "tuple"