summaryrefslogtreecommitdiffstats
path: root/spec/evendoors_spec.rb
diff options
context:
space:
mode:
Diffstat (limited to 'spec/evendoors_spec.rb')
-rw-r--r--spec/evendoors_spec.rb717
1 files changed, 0 insertions, 717 deletions
diff --git a/spec/evendoors_spec.rb b/spec/evendoors_spec.rb
deleted file mode 100644
index 502abf7..0000000
--- a/spec/evendoors_spec.rb
+++ /dev/null
@@ -1,717 +0,0 @@
-#! /usr/bin/env ruby
-# -*- coding: UTF-8 -*-
-#
-begin
- require 'simplecov'
- SimpleCov.start do
- add_filter 'spec'
- end
-rescue LoadError
-end
-#
-require 'evendoors'
-#
-class Fake
- attr_accessor :parent
- attr_reader :p, :sp, :start, :stop
- def name
- "myname"
- end
- def path
- (@parent.nil? ? name : @parent.path+'/'+name )
- end
- def process_p p
- @p = p
- end
- def process_sys_p p
- @sp = p
- end
- def send_p p
- @p = p
- end
- def send_sys_p p
- @sp = p
- end
- def add_spot p
- end
- def start!
- @start=true
- end
- def stop!
- @stop=true
- end
-end
-#
-describe EvenDoors do
- #
- it "EvenDoors module should exists" do
- expect{ EvenDoors }.not_to raise_error(NameError)
- end
- #
- describe EvenDoors::Particle do
- #
- it "payload manipulation" do
- p = EvenDoors::Particle.new
- #
- p['key']=666
- p['key'].should eql 666
- p.data('key').should eql 666
- p.get_data('key').should eql 666
- #
- p.set_data 'key', 69
- p['key'].should eql 69
- p.data('key').should eql 69
- p.get_data('key').should eql 69
- end
- #
- it "payload clone" do
- p = EvenDoors::Particle.new
- p['k00'] = { 'k0'=>0,'k1'=>1}
- p['k11'] = [1,2,3]
- o = EvenDoors::Particle.new
- o.clone_data p
- p['k00']=nil
- p['k00'].should be_nil
- o['k00']['k0'].should eql 0
- o['k00']['k1'].should eql 1
- p['k11']=nil
- p['k11'].should be_nil
- o['k11'][0].should eql 1
- o['k11'][1].should eql 2
- o['k11'][2].should eql 3
- end
- #
- it "particle merge" do
- p = EvenDoors::Particle.new
- q = EvenDoors::Particle.new
- o = EvenDoors::Particle.new
- p.merge! q
- p.merge! o
- p.merged(0).should be q
- p.merged(1).should be o
- p.merged(2).should be_nil
- p.merged_shift.should be q
- p.merged(0).should be o
- p.merged(1).should be_nil
- p.merged_shift.should be o
- p.merged(0).should be_nil
- p.merge! q
- p.merge! o
- p.merged(0).should be q
- p.merged(1).should be o
- p.clear_merged!
- p.merged(0).should be_nil
- end
- #
- it "routing: add_dsts, next_dst and dst_routed!" do
- p = EvenDoors::Particle.new
- d0 = EvenDoors::Door.new 'door0'
- d1 = EvenDoors::Door.new 'door1'
- p.dst.should be_nil
- p.next_dst.should be_nil
- p.add_dsts 'some?where,room0/room1/door?action,room/door,door'
- p.next_dst.should eql 'some?where'
- p.dst_routed! d0
- p.dst.should be d0
- p.next_dst.should eql 'room0/room1/door?action'
- p.dst_routed! d1
- p.dst.should be d1
- p.next_dst.should eql 'room/door'
- p.dst_routed! nil
- p.dst.should be_nil
- p.next_dst.should eql 'door'
- end
- #
- it "wrong path should raise exeption" do
- p = EvenDoors::Particle.new
- lambda { p.set_dst! 'action', '/room' }.should raise_error(EvenDoors::Exception)
- lambda { p.set_dst! 'action', 'room/' }.should raise_error(EvenDoors::Exception)
- lambda { p.set_dst! '', 'room/' }.should raise_error(EvenDoors::Exception)
- lambda { p.set_dst! 'action', 'room//door' }.should raise_error(EvenDoors::Exception)
- lambda { p.set_dst! ' ' }.should raise_error(EvenDoors::Exception)
- lambda { p.set_dst! ' ', '' }.should raise_error(EvenDoors::Exception)
- lambda { p.set_dst! 'f f' }.should raise_error(EvenDoors::Exception)
- lambda { p.set_dst! '', ' d' }.should raise_error(EvenDoors::Exception)
- lambda { p.set_dst! '' }.should raise_error(EvenDoors::Exception)
- lambda { p.set_dst! '', '' }.should raise_error(EvenDoors::Exception)
- lambda { p.set_dst! nil }.should raise_error(TypeError)
- lambda { p.set_dst! 'action', nil }.should raise_error(NoMethodError)
- end
- #
- it "routing: set_dst! and split_dst!" do
- p = EvenDoors::Particle.new
- d0 = EvenDoors::Door.new 'door0'
- #
- p.set_dst! 'action', 'room0/room1/door'
- p.split_dst!
- p.room.should eql 'room0/room1'
- p.door.should eql 'door'
- p.action.should eql 'action'
- #
- p.set_dst! 'action', 'room/door'
- p.split_dst!
- p.room.should eql 'room'
- p.door.should eql 'door'
- p.action.should eql 'action'
- #
- p.set_dst! 'action', ''
- p.split_dst!
- p.room.should eql nil
- p.door.should eql nil
- p.action.should eql 'action'
- #
- p.set_dst! 'action'
- p.split_dst!
- p.room.should eql nil
- p.door.should eql nil
- p.action.should eql 'action'
- #
- p.clear_dsts!
- p.add_dsts 'door?action,?action'
- p.split_dst!
- p.room.should eql nil
- p.door.should eql 'door'
- p.action.should eql 'action'
- #
- p.dst_routed! d0
- #
- p.dst.should be d0
- p.split_dst!
- p.room.should eql nil
- p.door.should eql nil
- p.action.should eql 'action'
- #
- end
- #
- it "routing: error!" do
- p = EvenDoors::Particle.new
- d = EvenDoors::Door.new 'door'
- p.src = d
- p.add_dsts 'door?action,?action'
- p.next_dst.should eql 'door?action'
- p.error! 'err_msg'
- p[EvenDoors::ERROR_FIELD].should eql 'err_msg'
- p.action.should eq EvenDoors::ACT_ERROR
- p.dst.should be d
- end
- #
- it "link fields and link value" do
- p = EvenDoors::Particle.new
- p['k0'] = 'v0'
- p['k1'] = 'v1'
- p['k2'] = 'v2'
- p.set_link_fields 'k0,k2'
- p.link_value.should eql 'v0v2'
- p.set_link_fields 'k1,k0'
- p.link_value.should eql 'v1v0'
- p['k0']='vx'
- p.link_value.should eql 'v1vx'
- end
- #
- it "apply_link! should work" do
- p = EvenDoors::Particle.new
- p['k0'] = 'v0'
- p['k1'] = 'v1'
- p['k2'] = 'v2'
- p.set_link_fields 'k0,k2'
- p.add_dsts 'door?action,?action'
- p.src.should be_nil
- p.link_value.should eql 'v0v2'
- p.next_dst.should eql 'door?action'
- lnk = EvenDoors::Link.new('door0', 'door1?get,door2', 'k1', 'f0,f1', 'v0v1')
- f = Fake.new
- lnk.door = f
- p.apply_link! lnk
- p.src.should be f
- p.next_dst.should eql 'door1?get'
- p.link_value.should eql 'v1'
- end
- #
- end
- #
- describe EvenDoors::Link do
- #
- it "from particle data" do
- p = EvenDoors::Spin.require_p EvenDoors::Particle
- p.set_data EvenDoors::LNK_SRC, 'input1'
- p.set_data EvenDoors::LNK_DSTS, 'concat1?follow,output1'
- p.set_data EvenDoors::LNK_FIELDS, 'f0,f2'
- p.set_data EvenDoors::LNK_CONDF, 'f0,f1,f2'
- p.set_data EvenDoors::LNK_CONDV, 'v0v1v2'
- lnk = EvenDoors::Link.from_particle_data p
- lnk.src.should eql 'input1'
- lnk.dsts.should eql 'concat1?follow,output1'
- lnk.fields.should eql 'f0,f2'
- lnk.cond_fields.should eql 'f0,f1,f2'
- lnk.cond_value.should eql 'v0v1v2'
- end
- #
- end
- #
- describe EvenDoors::Link do
- #
- it "path construction should work" do
- s0 = EvenDoors::Spot.new 'top', nil
- s1 = EvenDoors::Spot.new 'room0', s0
- s2 = EvenDoors::Spot.new 'room1', s1
- s3 = EvenDoors::Spot.new 'door', s2
- s3.path.should eql 'top/room0/room1/door'
- lambda { EvenDoors::Spot.new('do/or0', nil) }.should raise_error(EvenDoors::Exception)
- lambda { EvenDoors::Spot.new('/door0', nil) }.should raise_error(EvenDoors::Exception)
- lambda { EvenDoors::Spot.new('door0/', nil) }.should raise_error(EvenDoors::Exception)
- end
- #
- end
- #
- describe EvenDoors::Spin do
- #
- class MyP < EvenDoors::Particle; end
- #
- it "should correctly manage Particles pool" do
- p0 = EvenDoors::Spin.require_p EvenDoors::Particle
- p1 = EvenDoors::Spin.require_p EvenDoors::Particle
- (p0===p1).should be_false
- EvenDoors::Spin.release_p p0
- p2 = EvenDoors::Spin.require_p EvenDoors::Particle
- (p0===p2).should be_true
- end
- #
- it "should correctly manage different Particles classes" do
- p0 = EvenDoors::Spin.require_p EvenDoors::Particle
- p1 = EvenDoors::Spin.require_p EvenDoors::Particle
- (p0===p1).should be_false
- EvenDoors::Spin.release_p p0
- p2 = EvenDoors::Spin.require_p MyP
- p3 = EvenDoors::Spin.require_p MyP
- (p2===p3).should be_false
- EvenDoors::Spin.release_p p2
- p4 = EvenDoors::Spin.require_p MyP
- (p2===p4).should be_true
- end
- #
- it "should correctly release merged data" do
- p0 = EvenDoors::Spin.require_p EvenDoors::Particle
- p1 = EvenDoors::Spin.require_p EvenDoors::Particle
- (p0===p1).should be_false
- p0.merge! p1
- EvenDoors::Spin.release_p p0
- p2 = EvenDoors::Spin.require_p EvenDoors::Particle
- (p2===p0).should be_true
- p3 = EvenDoors::Spin.require_p EvenDoors::Particle
- (p3===p1).should be_true
- end
- #
- it "send_p send_sys_p spin!" do
- f = Fake.new
- p0 = EvenDoors::Spin.require_p EvenDoors::Particle
- p0.dst_routed! f
- p1 = EvenDoors::Spin.require_p EvenDoors::Particle
- p1.dst_routed! f
- EvenDoors::Spin.send_p p0
- EvenDoors::Spin.send_sys_p p1
- EvenDoors::Spin.run = true
- EvenDoors::Spin.spin!
- f.p.should be p0
- f.sp.should be p1
- end
- #
- it "does really little for now" do
- EvenDoors::Spin.debug_routing.should be false
- spin = EvenDoors::Spin.new 'dom0', :debug_routing=>true
- EvenDoors::Spin.debug_routing.should be true
- spin.spin!
- EvenDoors::Spin.debug_routing = false
- EvenDoors::Spin.debug_routing.should be false
- #
- EvenDoors::Spin.debug_errors.should be false
- spin = EvenDoors::Spin.new 'dom0', :debug_errors=>true
- EvenDoors::Spin.debug_errors.should be true
- spin.spin!
- EvenDoors::Spin.debug_errors = false
- EvenDoors::Spin.debug_errors.should be false
- end
- #
- end
- #
- describe EvenDoors::Door do
- #
- it "require_p release_p should work" do
- door = EvenDoors::Door.new 'hell'
- p0 = door.require_p EvenDoors::Particle
- p0.src.should be door
- p1 = door.require_p EvenDoors::Particle
- p1.src.should be door
- (p0===p1).should be_false
- door.release_p p0
- p2 = door.require_p EvenDoors::Particle
- p2.src.should be door
- (p0===p2).should be_true
- end
- #
- it "should work and release lost particles" do
- class Door0 < EvenDoors::Door
- def receive_p p
- case p.action
- when 'RELEASE'
- release_p p
- when 'SEND'
- send_p p
- when 'SEND_SYS'
- send_sys_p p
- else
- # lost!!
- end
- end
- end
- f = Fake.new
- d0 = Door0.new 'door0', f
- p0 = EvenDoors::Spin.require_p EvenDoors::Particle
- #
- p0.set_dst! 'SEND'
- p0.split_dst!
- d0.process_p p0
- f.p.should eql p0
- #
- p0.set_dst! 'SEND_SYS'
- p0.split_dst!
- d0.process_p p0
- f.sp.should eql p0
- #
- p0.set_dst! 'RELEASE'
- p0.split_dst!
- d0.process_p p0
- p1 = EvenDoors::Spin.require_p EvenDoors::Particle
- p1.should be p0
- #
- p0.set_dst! 'LOST'
- p0.split_dst!
- d0.process_p p0
- p1 = EvenDoors::Spin.require_p EvenDoors::Particle
- p1.should be p0
- #
- d0.process_sys_p p0
- p1 = EvenDoors::Spin.require_p EvenDoors::Particle
- p1.should be p0
- end
- #
- end
- #
- describe EvenDoors::Board do
- #
- it "require_p release_p should work" do
- board = EvenDoors::Board.new 'hell'
- p0 = board.require_p EvenDoors::Particle
- p0.src.should be board
- p1 = board.require_p EvenDoors::Particle
- p1.src.should be board
- (p0===p1).should be_false
- board.release_p p0
- p2 = board.require_p EvenDoors::Particle
- p2.src.should be board
- (p0===p2).should be_true
- end
- #
- it "should" do
- p0 = EvenDoors::Particle.new
- p0['k0'] = 'v0'
- p0['k1'] = 'neither'
- p0['k2'] = 'v2'
- p0.set_link_fields 'k0,k2'
- p0.link_value.should eql 'v0v2'
- p1 = EvenDoors::Particle.new
- p1['k0'] = 'v0'
- p1['k1'] = 'nore'
- p1['k2'] = 'v2'
- p1.set_link_fields 'k0,k2'
- p1.link_value.should eql 'v0v2'
- P0 = p0
- P1 = p1
- class Board0 < EvenDoors::Board
- attr_reader :ok, :follow
- def receive_p p
- @ok = false
- case p.action
- when EvenDoors::ACT_FOLLOW
- @follow = true
- @ok = (p===P0 and p.merged(0)===P1)
- else
- @follow = false
- @ok = (p===P1 and p.merged(0)===P0)
- end
- end
- end
- b0 = Board0.new 'door0'
- b0.process_p p0
- p0.merged(0).should be_nil
- b0.process_p p1
- b0.ok.should be_true
- b0.follow.should be_false
- #
- p1.merged_shift
- #
- b0.process_p p0
- p0.merged(0).should be_nil
- # need to set it to p0 too, so casein Board0 is ok
- p0.set_dst! EvenDoors::ACT_FOLLOW
- p0.split_dst!
- p1.set_dst! EvenDoors::ACT_FOLLOW
- p1.split_dst!
- b0.process_p p1
- b0.ok.should be_true
- b0.follow.should be_true
- end
- #
- end
- #
- describe EvenDoors::Board do
- #
- it "add_spot and add_link correctly" do
- r0 = EvenDoors::Room.new 'room0', nil
- d0 = EvenDoors::Door.new 'door0', r0
- lambda { EvenDoors::Door.new('door0', r0) }.should raise_error(EvenDoors::Exception)
- lambda { r0.add_spot EvenDoors::Door.new('door1', r0) }.should raise_error(EvenDoors::Exception)
- r0.add_link EvenDoors::Link.new 'door0', 'somewhere'
- lambda { r0.add_link(EvenDoors::Link.new('nowhere', 'somewhere')) }.should raise_error(EvenDoors::Exception)
- end
- #
- it "start! and stop! should work" do
- r0 = EvenDoors::Room.new 'room0', nil
- d0 = Fake.new
- r0.add_spot d0
- d0.start.should be_nil
- d0.stop.should be_nil
- r0.start!
- d0.start.should be_true
- d0.stop.should be_nil
- r0.stop!
- d0.start.should be_true
- d0.stop.should be_true
- end
- #
- it "parent and spin should be ok" do
- s = EvenDoors::Spin.new 'dom0'
- r0 = EvenDoors::Room.new 'r0', s
- r1 = EvenDoors::Room.new 'r0', r0
- r2 = EvenDoors::Room.new 'r0', r1
- r2.parent.should be r1
- r1.parent.should be r0
- r0.parent.should be s
- r0.spin.should be s
- r1.spin.should be s
- r2.spin.should be s
- end
- #
- it "route error: no source" do
- room = EvenDoors::Room.new 'room', nil
- p = EvenDoors::Spin.require_p EvenDoors::Particle
- p.set_dst! 'get', 'room/door'
- room.send_p p
- p.action.should eql EvenDoors::ACT_ERROR
- p[EvenDoors::ERROR_FIELD].should eql EvenDoors::ERROR_ROUTE_NS
- p.dst.should be room.spin
- end
- #
- it "route error: no destination no links" do
- room = EvenDoors::Room.new 'room', nil
- p = EvenDoors::Spin.require_p EvenDoors::Particle
- p.src = Fake.new
- room.send_p p
- p.action.should eql EvenDoors::ACT_ERROR
- p[EvenDoors::ERROR_FIELD].should eql EvenDoors::ERROR_ROUTE_NDNL
- p.dst.should be p.src
- end
- #
- it "route error: top room, wrong room" do
- room0 = EvenDoors::Room.new 'room0', nil
- room1 = EvenDoors::Room.new 'room1', room0
- p = EvenDoors::Spin.require_p EvenDoors::Particle
- p.src = Fake.new
- p.set_dst! 'get', 'noroom/door'
- room1.send_p p
- p.action.should eql EvenDoors::ACT_ERROR
- p[EvenDoors::ERROR_FIELD].should eql EvenDoors::ERROR_ROUTE_TRWR
- p.dst.should be p.src
- end
- #
- it "route error: right room, wrong door" do
- room = EvenDoors::Room.new 'room', nil
- p = EvenDoors::Spin.require_p EvenDoors::Particle
- p.src = Fake.new
- p.set_dst! 'get', 'room/nodoor'
- room.send_p p
- p.action.should eql EvenDoors::ACT_ERROR
- p[EvenDoors::ERROR_FIELD].should eql EvenDoors::ERROR_ROUTE_RRWD
- p.dst.should be p.src
- end
- #
- it "route error: right room, wrong door (bubble up)" do
- room0 = EvenDoors::Room.new 'room0', nil
- room1 = EvenDoors::Room.new 'room1', room0
- p = EvenDoors::Spin.require_p EvenDoors::Particle
- p.src = Fake.new
- p.set_dst! 'get', 'room0/nodoor'
- room1.send_p p
- p.action.should eql EvenDoors::ACT_ERROR
- p[EvenDoors::ERROR_FIELD].should eql EvenDoors::ERROR_ROUTE_RRWD
- p.dst.should be p.src
- end
- #
- it "routing success (direct)" do
- room0 = EvenDoors::Room.new 'room0', nil
- door0 = EvenDoors::Door.new 'door0', room0
- p = EvenDoors::Spin.require_p EvenDoors::Particle
- p.src = Fake.new
- p.set_dst! 'get', 'door0'
- room0.send_p p
- p.action.should eql 'get'
- p.dst.should be door0
- end
- #
- it "routing success (bubble up the direct door)" do
- room0 = EvenDoors::Room.new 'room0', nil
- room1 = EvenDoors::Room.new 'room1', room0
- door0 = EvenDoors::Door.new 'door0', room0
- p = EvenDoors::Spin.require_p EvenDoors::Particle
- p.src = Fake.new
- p.set_dst! 'get', 'room0/door0'
- room1.send_p p
- p.action.should eql 'get'
- p.dst.should be door0
- end
- #
- it "route error: right room, no drill down (2xbubble up)" do
- room0 = EvenDoors::Room.new 'room0', nil
- room1 = EvenDoors::Room.new 'room1', room0
- room2 = EvenDoors::Room.new 'room2', room0
- room3 = EvenDoors::Room.new 'room3', room2
- door0 = EvenDoors::Door.new 'door01', room1
- p = EvenDoors::Spin.require_p EvenDoors::Particle
- p.src = Fake.new
- p.set_dst! 'get', 'room0/room1/door01'
- room3.send_p p
- p.action.should eql EvenDoors::ACT_ERROR
- p[EvenDoors::ERROR_FIELD].should eql EvenDoors::ERROR_ROUTE_RRNDD
- p.dst.should be p.src
- end
- #
- it "routing success: no door name -> src" do
- room0 = EvenDoors::Room.new 'room0', nil
- door0 = EvenDoors::Door.new 'door0', room0
- p = EvenDoors::Spin.require_p EvenDoors::Particle
- p.src = door0
- p.set_dst! 'get'
- room0.send_p p
- p.action.should eql 'get'
- p.dst.should be door0
- end
- #
- it "routing success: unconditional link" do
- room0 = EvenDoors::Room.new 'room0', nil
- door0 = EvenDoors::Door.new 'door0', room0
- door1 = EvenDoors::Door.new 'door1', room0
- room0.add_link EvenDoors::Link.new('door0', 'door1')
- p = EvenDoors::Spin.require_p EvenDoors::Particle
- door0.send_p p
- p.action.should be_nil
- p.dst.should be door1
- end
- #
- it "routing success: conditional link" do
- room0 = EvenDoors::Room.new 'room0', nil
- door0 = EvenDoors::Door.new 'door0', room0
- door1 = EvenDoors::Door.new 'door1', room0
- room0.add_link EvenDoors::Link.new('door0', 'door1', 'fields', 'f0,f1', 'v0v1')
- p = EvenDoors::Spin.require_p EvenDoors::Particle
- p['f0']='v0'
- p['f1']='v1'
- door0.send_p p
- p.action.should be_nil
- p.src.should be door0
- p.dst.should be door1
- end
- #
- it "routing success: more then one matching link" do
- room0 = EvenDoors::Room.new 'room0', nil
- door0 = EvenDoors::Door.new 'door0', room0
- class Out < EvenDoors::Door
- attr_reader :ps
- def receive_p p
- @ps||=[]
- @ps << p
- end
- end
- door1 = Out.new 'door1', room0
- room0.add_link EvenDoors::Link.new('door0', 'door1')
- room0.add_link EvenDoors::Link.new('door0', 'door1', 'fields', 'f0,f1', 'v0v1')
- p = EvenDoors::Spin.require_p EvenDoors::Particle
- EvenDoors::Spin.clear!
- p['f0']='v0'
- p['f1']='v1'
- door0.send_p p
- EvenDoors::Spin.run = true
- EvenDoors::Spin.spin!
- door1.ps.length.should eql 2
- p0 = door1.ps[0]
- p0.action.should be_nil
- p0.src.should be door0
- p0.dst.should be door1
- p1 = door1.ps[1]
- p1.action.should be_nil
- p1.src.should be door0
- p1.dst.should be door1
- p1.should be p
- end
- #
- it "system route error: system no destination" do
- room0 = EvenDoors::Room.new 'room0', nil
- p = EvenDoors::Spin.require_p EvenDoors::Particle
- room0.send_sys_p p
- p.action.should eql EvenDoors::ACT_ERROR
- p[EvenDoors::ERROR_FIELD].should eql EvenDoors::ERROR_ROUTE_SND
- end
- #
- it "system routing success: action only" do
- room0 = EvenDoors::Room.new 'room0', nil
- p = EvenDoors::Spin.require_p EvenDoors::Particle
- p.set_dst! EvenDoors::SYS_ACT_ADD_LINK
- room0.send_sys_p p
- p.action.should eql EvenDoors::SYS_ACT_ADD_LINK
- p.dst.should be room0.spin
- end
- #
- it "system routing success" do
- room0 = EvenDoors::Room.new 'room0', nil
- door0 = EvenDoors::Door.new 'door0', room0
- p = EvenDoors::Spin.require_p EvenDoors::Particle
- p.set_dst! EvenDoors::SYS_ACT_ADD_LINK, 'room0/door0'
- room0.send_sys_p p
- p.action.should eql EvenDoors::SYS_ACT_ADD_LINK
- p.dst.should be door0
- end
- #
- it "SYS_ACT_ADD_LINK should work" do
- EvenDoors::Spin.clear!
- spin = EvenDoors::Spin.new 'dom0' # needed to be able to route to door
- room0 = EvenDoors::Room.new 'room0', spin
- door0 = EvenDoors::Door.new 'door0', room0
- door1 = EvenDoors::Door.new 'door1', room0
- p0 = EvenDoors::Spin.require_p EvenDoors::Particle
- p0.set_data EvenDoors::LNK_SRC, 'door0'
- p0.set_data EvenDoors::LNK_DSTS, 'door1'
- p0.set_data EvenDoors::LNK_FIELDS, 'fields'
- p0.set_data EvenDoors::LNK_CONDF, 'f0,f1'
- p0.set_data EvenDoors::LNK_CONDV, 'v0v1'
- p0.set_dst! EvenDoors::SYS_ACT_ADD_LINK, room0.path
- room0.send_sys_p p0
- spin.spin!
- p = EvenDoors::Spin.require_p EvenDoors::Particle
- p['f0']='v0'
- p['f1']='v1'
- door0.send_p p
- p.action.should be_nil
- p.src.should be door0
- p.dst.should be door1
- end
- #
- end
-end
generated by cgit v1.1-2-g2b99 at 2024-11-22 07:41:40 +0100