RubyGems - roby - Versions diffs - 0.8.0 → 3.0.0 - Mend

@@ -1,15 +0,0 @@
-require 'roby/test/tasks/simple_task'
-SimpleTask = Roby::Test::SimpleTask
-module Services
-    class Navigation < SimpleTask; end
-    class Localization < SimpleTask
-	event :ready, :command => true
-	signal :start => :ready
-	def update_localization(state)
-	    state.pos += 1
-	end
-    end
-end

data/plugins/subsystems/test/test_subsystems.rb DELETED

@@ -1,78 +0,0 @@
-require 'test/unit'
-require 'roby'
-require 'roby/app'
-require 'roby/test/common'
-require 'roby/test/tasks/simple_task'
-APP_DIR = File.expand_path('app', File.dirname(__FILE__))
-require "#{APP_DIR}/tasks/services"
-require "#{APP_DIR}/planners/main"
-class TC_Subsystems < Test::Unit::TestCase
-    include Roby::Test
-    include Roby::Subsystems
-    def setup
-	super
-        Roby.app.setup_global_singletons
-        Roby.app.using :subsystems
-	DRb.start_service
-	Roby::State.pos = 0
-	Roby::State.services do |s|
-	    s.localization = 'test'
-	    s.navigation   = 'test'
-	end
-        @plan = Roby.plan
-        @engine = Roby.engine
-    end
-    def nav_loc
-	tasks = plan.known_tasks.to_a
-	assert_equal(2, tasks.size, tasks)
-	if tasks.first.kind_of?(Services::Navigation)
-	    tasks
-	else tasks.reverse
-	end
-    end
-    def test_initialize_plan
-	start_with, ready = Application.initialize_plan(plan)
-	nav, loc = nav_loc
-	assert(plan.permanent?(nav))
-	assert(plan.permanent?(loc))
-	assert(nav.depends_on?(loc))
-	assert_equal([loc.event(:start)], start_with.child_objects(EventStructure::Signal).to_a)
-	signalled_events = loc.event(:ready).child_objects(EventStructure::Signal).to_value_set
-        assert_equal 2, signalled_events.size
-        assert_equal([nav.start_event, ready].to_value_set,
-            loc.event(:ready).child_objects(EventStructure::Signal).to_value_set)
-	assert_equal([nav.event(:start), loc.event(:ready)].to_set, ready.parent_objects(EventStructure::Signal).to_set)
-    rescue Roby::Planning::NotFound
-	STDERR.puts $!.full_message
-	raise
-    end
-    def test_start_subsystems
-	Roby.logger.level = Logger::FATAL
-        Robot.logger.level = Logger::FATAL
-        engine.run
-        Subsystems::Application.run(Roby.app)
-        Roby.execute do
-            nav, loc = nav_loc
-            assert(nav.running?)
-            assert(loc.running?)
-        end
-	sleep(0.5)
-	assert(Roby::State.pos > 0)
-    end
-end

data/test/distributed/test_communication.rb DELETED

@@ -1,195 +0,0 @@
-$LOAD_PATH.unshift File.expand_path(File.join('..', '..', 'lib'), File.dirname(__FILE__))
-require 'test/unit'
-require 'roby/distributed'
-require 'roby/test/distributed'
-require 'flexmock'
-class TC_DistributedCommunication < Test::Unit::TestCase
-    include Roby
-    include Roby::Distributed::Test
-    attr_reader :local_peer
-    module FakePeerServerMethods
-	def reply(mock, value)
-	    mock.method_called(value) if mock
-	    value
-	end
-	def reply_error(count)
-	    @error_count ||= count
-	    if @error_count == 0
-		return
-	    end
-	    @error_count -= 1
-	    raise
-	end
-	def reply_with_callback(mock, value)
-	    peer.disable_tx
-	    mock.method_called(value)
-	    peer.transmit(:reply, mock, value + 1)
-	    mock.method_called(value + 2)
-	    peer.enable_tx
-	    value
-	end
-	def recursive_callbacks
-	    peer.transmit(:recursive_callbacks)
-	end
-	def setup(server); peer.setup(server) end
-	def peer_drb_object; DRbObject.new(peer) end
-    end
-    def setup
-	super
-	peer2peer do |remote|
-	    def remote.install_fake_methods
-		local_peer.local_server.extend FakePeerServerMethods
-	    end
-	end
-	remote_peer.local_server.extend FakePeerServerMethods
-	remote.install_fake_methods
-    end
-    def test_transmit
-	FlexMock.use do |mock|
-	    # Check that nothing is sent while the link is not alive
-	    remote_peer.disable_tx
-	    remote_peer.transmit(:reply, DRbObject.new(mock), 42) do |result|
-		mock.block_called(result)
-	    end
-	    remote_peer.transmit(:reply, DRbObject.new(mock), 24)
-	    remote_peer.transmit(:reply, DRbObject.new(mock), 24) do |result|
-		mock.block_called(result)
-	    end
-	    mock.should_receive(:link_alive).once.ordered
-	    mock.should_receive(:method_called).with(42).once.ordered(:first_call)
-	    mock.should_receive(:method_called).with(24).twice.ordered(:second_calls)
-	    mock.should_receive(:block_called).with(42).once.ordered(:second_calls)
-	    mock.should_receive(:block_called).with(24).once.ordered
-	    mock.link_alive
-	    remote_peer.enable_tx
-	    remote_peer.synchro_point
-	end
-    end
-    def disable_logging
-        remote.disable_logging
-        logger = Roby::Distributed.logger
-        old_loglevel = logger.level
-        logger.level = Logger::UNKNOWN
-        yield
-    ensure
-        remote.enable_logging
-        logger.level = old_loglevel
-    end
-    def test_transmit_error
-	FlexMock.use do |mock|
-	    remote_peer.disable_tx
-	    remote_peer.transmit(:reply_error, 2) do |result|
-		mock.block_called
-	    end
-	    mock.should_receive(:block_called).never
-            disable_logging do
-                remote_peer.enable_tx
-                assert_raises(Roby::Distributed::DisconnectedError) { remote_peer.synchro_point }
-            end
-	    assert(!remote_peer.connected?)
-	end
-    end
-    def test_call(value = 42)
-	FlexMock.use do |mock|
-	    mock.should_receive(:method_called).with(value).once
-	    assert_equal(value, remote_peer.call(:reply, DRbObject.new(mock), value))
-	end
-    end
-    def test_concurrent_calls
-	remote_peer.disable_tx
-	t1 = Thread.new { test_call(42) }
-	# wait for the TX thread to notice the new entry in the queue and
-	# wake up
-	sleep(0.5)
-	t2 = Thread.new { test_call(21) }
-	# Wait for +t2+ to insert its entry in the TX queue
-	sleep(0.5)
-	remote_peer.enable_tx
-	t1.value
-	t2.value
-    end
-    def test_call_raises
-        disable_logging do
-            assert_raises(RuntimeError) do
-                remote_peer.call(:reply_error, 2)
-            end
-        end
-    end
-    def test_call_disconnects
-	remote_peer.disable_tx
-	remote_peer.transmit(:reply_error, 2)
-	sleep(0.5)
-        disable_logging do
-            Thread.new do
-                sleep(0.5)
-                remote_peer.enable_tx
-            end
-            assert_raises(DisconnectedError) { remote_peer.call(:reply, nil, 42) }
-        end
-    end
-    def test_callback
-	FlexMock.use do |mock|
-	    # Check that nothing is sent while the link is not alive
-	    mock.should_receive(:method_called).with(42).once.ordered
-	    mock.should_receive(:method_called).with(44).once.ordered
-	    mock.should_receive(:method_called).with(43).once.ordered
-	    assert_equal(42, remote_peer.call(:reply_with_callback, DRbObject.new(mock), 42))
-	end
-    end
-    def test_recursive_callbacks
-        disable_logging do
-            assert_raises(DisconnectedError) { remote_peer.call(:recursive_callbacks) }
-        end
-    end
-    def test_synchro_point
-	remote_peer.disable_tx
-	remote.send_local_peer(:disable_tx)
-	FlexMock.use do |mock|
-	    remote_peer.transmit(:reply, DRbObject.new(mock), 42)
-	    remote_peer.transmit(:reply, DRbObject.new(mock), 21)
-	    remote.send_local_peer(:transmit, :reply, DRbObject.new(mock), 42)
-	    remote.send_local_peer(:transmit, :reply, DRbObject.new(mock), 21)
-	    Thread.current.priority = 10
-	    sleep(0.5)
-	    mock.should_receive(:method_called).times(4)
-	    remote_peer.enable_tx
-	    remote.send_local_peer(:enable_tx)
-	    remote_peer.synchro_point
-	end
-    ensure
-	Thread.current.priority = 0
-    end
-end

data/test/distributed/test_connection.rb DELETED

@@ -1,284 +0,0 @@
-$LOAD_PATH.unshift File.expand_path(File.join('..', '..', 'lib'), File.dirname(__FILE__))
-require 'roby/test/distributed'
-require 'roby/test/tasks/simple_task'
-require 'flexmock'
-class TC_DistributedConnection < Test::Unit::TestCase
-    include Rinda
-    include Roby
-    include Distributed
-    include Roby::Distributed::Test
-    def assert_has_neighbour(&check)
-	Distributed.state.start_neighbour_discovery
-	Distributed.state.wait_discovery
-	assert(!Distributed.state.discovering?)
-	assert(1, local.neighbours.size)
-	assert(local.neighbours.find(&check), local.neighbours.map { |n| [n.name, n.remote_id] }.to_s)
-    end
-    # Test neighbour discovery using a remote central tuplespace as neighbour list
-    def test_centralized_drb_discovery
-	DRb.stop_service
-	central_tuplespace = TupleSpace.new
-	DRb.start_service 'druby://localhost:1245', central_tuplespace
-	remote_pid = remote_process do
-	    DRb.stop_service
-	    DRb.start_service
-	    central_tuplespace = DRbObject.new_with_uri('druby://localhost:1245')
-	    Distributed.state = ConnectionSpace.new :ring_discovery => false,
-		:discovery_tuplespace => central_tuplespace, :plan => plan
-	end
-	@local = ConnectionSpace.new :ring_discovery => false,
-	    :discovery_tuplespace => central_tuplespace, :plan => plan
-        Distributed.state = local
-	assert_has_neighbour { |n| n.name == "#{Socket.gethostname}-#{remote_pid}" }
-    end
-    BROADCAST = (1..10).map { |i| "127.0.0.#{i}" }
-    # Test neighbour discovery using UDP for discovery
-    def test_ringserver_discovery
-	DRb.stop_service
-	remote_pid = remote_process do
-	    DRb.start_service
-	    Distributed.state = ConnectionSpace.new :period => 0.5, :ring_discovery => true, :ring_broadcast => BROADCAST, :plan => plan
-	    Distributed.publish :bind => '127.0.0.2'
-	end
-	DRb.start_service
-        @local = ConnectionSpace.new :period => 0.5, :ring_discovery => true, :ring_broadcast => BROADCAST, :plan => plan
-	Distributed.state = local
-	Distributed.publish :bind => '127.0.0.1'
-	assert_has_neighbour { |n| n.name == "#{Socket.gethostname}-#{remote_pid}" }
-    end
-    # Test establishing peer-to-peer connection between two ConnectionSpace objects
-    # Note that #peer2peer is the exact same process
-    def test_connect(standalone = true)
-	if standalone
-	    start_peers
-	    notified = []
-	    local.on_neighbour do |n|
-		notified << n
-	    end
-	end
-	assert(local.discovery_thread)
-	# Initiate the connection from +local+
-	remote_neighbour = local.neighbours.find { true }
-	engine.execute do
-	    did_yield = nil
-	    Peer.initiate_connection(local, remote_neighbour) do |did_yield|
-	    end
-	    # Wait for the remote peer to take into account the fact that we
-	    # try connecting
-	    local.synchronize do
-		remote_id = remote_neighbour.remote_id
-		assert(local.pending_connections[remote_id] ||
-		       local.peers[remote_id])
-	    end
-	    sleep(1)
-	    local.synchronize do
-		remote_id = remote_neighbour.remote_id
-		assert(@remote_peer = local.peers[remote_id], local.peers)
-		assert_equal(remote_peer, did_yield)
-	    end
-	    assert(remote_peer.connected?)
-	    assert(remote.send_local_peer(:connected?))
-	    assert(remote_peer.link_alive?)
-	    assert(remote.send_local_peer(:link_alive?))
-	    did_yield = nil
-	    Peer.initiate_connection(local, remote_neighbour) do |did_yield|
-	    end
-	    assert_equal(remote_peer, did_yield)
-	    assert_equal(remote_peer, Peer.connect(remote_neighbour))
-	end
-	engine.wait_one_cycle
-	assert(remote_peer.task.running?)
-	#assert_raises(ArgumentError) { Peer.initiate_connection(local, remote_neighbour) }
-	assert(remote_peer.link_alive?)
-	remote_peer.synchro_point
-	assert(remote_peer.connected?)
-	assert(remote_peer.task.ready?)
-	assert_equal('remote', remote_peer.remote_name)
-	assert_equal('remote', remote_peer.local_server.remote_name)
-	assert_equal('local', remote_peer.local_server.local_name)
-	if standalone
-	    assert_equal(1, notified.size)
-	    assert_equal([remote_neighbour], notified)
-	end
-    end
-    def test_synchronous_connect
-	start_peers do |remote|
-	    def remote.connected?
-		local_peer.connected?
-	    end
-	end
-	sleep(0.5)
-	assert(remote_neighbour = Distributed.neighbours.find { true })
-	assert(remote_peer = Peer.connect(remote_neighbour))
-	assert_kind_of(Distributed::Peer, remote_peer)
-	assert(remote.connected?)
-	assert(remote_peer.connected?)
-    end
-    def test_concurrent_connection
-	GC.disable
-	start_peers do |remote|
-	    class << remote
-		def find_neighbour
-		    @neighbour = Roby::Distributed.neighbours.find { true }
-		end
-		def connect
-		    Roby::Distributed::Peer.initiate_connection(Roby::Distributed.state, @neighbour) do
-			@callback_called ||= 0
-			@callback_called += 1
-		    end
-		    nil
-		end
-		attr_reader :callback_called
-		def peer_objects
-		    peer_objects = ObjectSpace.enum_for(:each_object, Roby::Distributed::Peer).to_a
-		    [Roby::Distributed.peers.keys.size, peer_objects.size]
-		end
-	    end
-	end
-	sleep(0.5)
-	assert(remote.find_neighbour)
-	assert(remote_neighbour = Distributed.neighbours.find { true })
-	# We want to check that a concurrent connection creates only one Peer
-	# object. Still, we have to take into account that the remote peer is a
-	# fork of ourselves, and as such inherits the Peer objects this process
-	# has in its ObjectSpace (like the leftovers of other tests)
-	registered_peer_count, initial_remote_peer_count = remote.peer_objects
-	assert_equal(0, registered_peer_count)
-	registered_peer_count, initial_local_peer_count = Distributed.peers.keys.size,
-	    ObjectSpace.enum_for(:each_object, Distributed::Peer).to_a.size
-	assert_equal(0, registered_peer_count)
-	remote.connect
-	remote.connect
-	callback_called = 0
-	2.times do
-	    Peer.initiate_connection(local, remote_neighbour) do
-		callback_called += 1
-	    end
-	end
-	sleep(1)
-	assert_equal(2, callback_called)
-	assert_equal(2, remote.callback_called)
-	assert_equal([1, initial_remote_peer_count + 1], remote.peer_objects)
-	assert_equal(1, Distributed.peers.keys.size)
-	assert_equal(initial_local_peer_count + 1, ObjectSpace.enum_for(:each_object, Distributed::Peer).to_a.size)
-    ensure
-	GC.enable
-    end
-    # Test the normal disconnection process
-    def test_disconnect
-	peer2peer do |remote|
-	    def remote.peers_empty?; Distributed.peers.empty? end
-	end
-	engine.wait_one_cycle
-	assert(remote_peer.task.ready?)
-	remote_peer.disconnect
-	assert(remote_peer.disconnecting?)
-	process_events
-	remote.process_events
-	assert(remote_peer.disconnected?)
-	remote.send_local_peer(:disconnected?)
-	assert(Distributed.peers.empty?)
-	assert(remote.peers_empty?)
-	remote.reset_local_peer
-	# Make sure that we can reconnect
-	test_connect(false)
-    end
-    # Tests that the remote peer disconnects if #demux raises DisconnectedError
-    def test_disconnect_on_error
-	Roby.logger.level = Logger::FATAL
-	peer2peer do |remote|
-	    class << remote
-		include Test::Unit::Assertions
-		def assert_demux_raises
-		    peer = peers.find { true }[1]
-		    peer.transmit(:whatever)
-		    peer.synchro_point rescue nil
-		end
-	    end
-	end
-	remote_peer.disconnect
-	remote.assert_demux_raises
-	assert(remote.send_local_peer(:disconnected?))
-	assert(remote_peer.disconnected?)
-	remote.reset_local_peer
-	# Make sure that we can reconnect
-	test_connect(false)
-    end
-    def test_socket_reconnect
-	peer2peer
-	Distributed.state.synchronize do
-	    remote_peer.socket.close
-	    assert(!remote_peer.link_alive?)
-	end
-	sleep(1)
-	assert(!remote_peer.socket.closed?)
-	assert(remote_peer.connected?)
-	assert(remote_peer.link_alive?)
-	assert(remote.send_local_peer(:connected?))
-	assert(remote.send_local_peer(:link_alive?))
-    end
-    def test_remote_dies
-	peer2peer
-	Process.kill('KILL', remote_processes[1][0])
-	sleep(1)
-	assert(remote_peer.disconnected?)
-    end
-    def test_abort_connection
-	peer2peer
-	remote_peer.disconnected!
-	sleep(1)
-	assert(remote_peer.socket.closed?)
-	assert(!remote_peer.connected?)
-	assert(!remote.send_local_peer(:connected?))
-    end
-end