summaryrefslogtreecommitdiff
path: root/test/rinda/test_rinda.rb
diff options
context:
space:
mode:
Diffstat (limited to 'test/rinda/test_rinda.rb')
-rw-r--r--test/rinda/test_rinda.rb1097
1 files changed, 599 insertions, 498 deletions
diff --git a/test/rinda/test_rinda.rb b/test/rinda/test_rinda.rb
index 59b769c6e9a..0278eb3597d 100644
--- a/test/rinda/test_rinda.rb
+++ b/test/rinda/test_rinda.rb
@@ -2,519 +2,620 @@ require 'test/unit'
require 'drb/drb'
require 'drb/eq'
+require 'rinda/ring'
require 'rinda/tuplespace'
require 'singleton'
module Rinda
-class MockClock
- include Singleton
-
- class MyTS < Rinda::TupleSpace
- def keeper_thread
- nil
- end
- end
-
- def initialize
- @now = 2
- @reso = 1
- @ts = MyTS.new
- @ts.write([2, :now])
- @inf = 2**31 - 1
- end
-
- def now
- @now.to_f
- end
-
- def at(n)
- n
- end
-
- def _forward(n=nil)
- now ,= @ts.take([nil, :now])
- @now = now + n
- n = @reso if n.nil?
- @ts.write([@now, :now])
- end
-
- def forward(n)
- while n > 0
- _forward(@reso)
- n -= @reso
- Thread.pass
- end
- end
-
- def rewind
- now ,= @ts.take([nil, :now])
- @ts.write([@inf, :now])
- @ts.take([nil, :now])
- @now = 2
- @ts.write([2, :now])
- end
-
- def sleep(n=nil)
- now ,= @ts.read([nil, :now])
- @ts.read([(now + n)..@inf, :now])
- 0
- end
-end
-
-module Time
- def sleep(n)
- @m.sleep(n)
- end
- module_function :sleep
-
- def at(n)
- n
- end
- module_function :at
-
- def now
- @m ? @m.now : 2
- end
- module_function :now
-
- def rewind
- @m.rewind
- end
- module_function :rewind
-
- def forward(n)
- @m.forward(n)
- end
- module_function :forward
-
- @m = MockClock.instance
-end
-
-class TupleSpace
- def sleep(n)
- Kernel.sleep(n * 0.01)
- end
-end
-
-module TupleSpaceTestModule
- def sleep(n)
- if Thread.current == Thread.main
- Time.forward(n)
- else
- Time.sleep(n)
- end
- end
-
- def thread_join(th)
- while th.alive?
- Kernel.sleep(0.1)
- sleep(1)
- end
- th.value
- end
-
- def test_00_tuple
- tuple = Rinda::TupleEntry.new([1,2,3])
- assert(!tuple.canceled?)
- assert(!tuple.expired?)
- assert(tuple.alive?)
- end
-
- def test_00_template
- tmpl = Rinda::Template.new([1,2,3])
- assert_equal(3, tmpl.size)
- assert_equal(3, tmpl[2])
- assert(tmpl.match([1,2,3]))
- assert(!tmpl.match([1,nil,3]))
-
- tmpl = Rinda::Template.new([/^rinda/i, nil, :hello])
- assert_equal(3, tmpl.size)
- assert(tmpl.match(['Rinda', 2, :hello]))
- assert(!tmpl.match(['Rinda', 2, Symbol]))
- assert(!tmpl.match([1, 2, :hello]))
- assert(tmpl.match([/^rinda/i, 2, :hello]))
-
- tmpl = Rinda::Template.new([Symbol])
- assert_equal(1, tmpl.size)
- assert(tmpl.match([:hello]))
- assert(tmpl.match([Symbol]))
- assert(!tmpl.match(['Symbol']))
-
- tmpl = Rinda::Template.new({"message"=>String, "name"=>String})
- assert_equal(2, tmpl.size)
- assert(tmpl.match({"message"=>"Hello", "name"=>"Foo"}))
- assert(!tmpl.match({"message"=>"Hello", "name"=>"Foo", "1"=>2}))
- assert(!tmpl.match({"message"=>"Hi", "name"=>"Foo", "age"=>1}))
- assert(!tmpl.match({"message"=>"Hello", "no_name"=>"Foo"}))
-
- assert_raise(Rinda::InvalidHashTupleKey) do
- Rinda::Template.new({:message=>String, "name"=>String})
- end
- tmpl = Rinda::Template.new({"name"=>String})
- assert_equal(1, tmpl.size)
- assert(tmpl.match({"name"=>"Foo"}))
- assert(!tmpl.match({"message"=>"Hello", "name"=>"Foo"}))
- assert(!tmpl.match({"message"=>:symbol, "name"=>"Foo", "1"=>2}))
- assert(!tmpl.match({"message"=>"Hi", "name"=>"Foo", "age"=>1}))
- assert(!tmpl.match({"message"=>"Hello", "no_name"=>"Foo"}))
-
- tmpl = Rinda::Template.new({"message"=>String, "name"=>String})
- assert_equal(2, tmpl.size)
- assert(tmpl.match({"message"=>"Hello", "name"=>"Foo"}))
- assert(!tmpl.match({"message"=>"Hello", "name"=>"Foo", "1"=>2}))
- assert(!tmpl.match({"message"=>"Hi", "name"=>"Foo", "age"=>1}))
- assert(!tmpl.match({"message"=>"Hello", "no_name"=>"Foo"}))
-
- tmpl = Rinda::Template.new({"message"=>String})
- assert_equal(1, tmpl.size)
- assert(tmpl.match({"message"=>"Hello"}))
- assert(!tmpl.match({"message"=>"Hello", "name"=>"Foo"}))
- assert(!tmpl.match({"message"=>"Hello", "name"=>"Foo", "1"=>2}))
- assert(!tmpl.match({"message"=>"Hi", "name"=>"Foo", "age"=>1}))
- assert(!tmpl.match({"message"=>"Hello", "no_name"=>"Foo"}))
-
- tmpl = Rinda::Template.new({"message"=>String, "name"=>nil})
- assert_equal(2, tmpl.size)
- assert(tmpl.match({"message"=>"Hello", "name"=>"Foo"}))
- assert(!tmpl.match({"message"=>"Hello", "name"=>"Foo", "1"=>2}))
- assert(!tmpl.match({"message"=>"Hi", "name"=>"Foo", "age"=>1}))
- assert(!tmpl.match({"message"=>"Hello", "no_name"=>"Foo"}))
-
- assert_raise(Rinda::InvalidHashTupleKey) do
- @ts.write({:message=>String, "name"=>String})
- end
-
- @ts.write([1, 2, 3])
- assert_equal([1, 2, 3], @ts.take([1, 2, 3]))
-
- @ts.write({'1'=>1, '2'=>2, '3'=>3})
- assert_equal({'1'=>1, '2'=>2, '3'=>3}, @ts.take({'1'=>1, '2'=>2, '3'=>3}))
-
- entry = @ts.write(['1'=>1, '2'=>2, '3'=>3])
- assert_raise(Rinda::RequestExpiredError) do
- assert_equal({'1'=>1, '2'=>2, '3'=>3}, @ts.read({'1'=>1}, 0))
- end
- entry.cancel
- end
-
- def test_00_DRbObject
- ro = DRbObject.new(nil, "druby://host:1234")
- tmpl = Rinda::DRbObjectTemplate.new
- assert(tmpl === ro)
-
- tmpl = Rinda::DRbObjectTemplate.new("druby://host:1234")
- assert(tmpl === ro)
-
- tmpl = Rinda::DRbObjectTemplate.new("druby://host:12345")
- assert(!(tmpl === ro))
-
- tmpl = Rinda::DRbObjectTemplate.new(/^druby:\/\/host:/)
- assert(tmpl === ro)
-
- ro = DRbObject.new_with(12345, 1234)
- assert(!(tmpl === ro))
-
- ro = DRbObject.new_with("druby://foo:12345", 1234)
- assert(!(tmpl === ro))
-
- tmpl = Rinda::DRbObjectTemplate.new(/^druby:\/\/(foo|bar):/)
- assert(tmpl === ro)
-
- ro = DRbObject.new_with("druby://bar:12345", 1234)
- assert(tmpl === ro)
-
- ro = DRbObject.new_with("druby://baz:12345", 1234)
- assert(!(tmpl === ro))
- end
-
- def test_inp_rdp
- assert_raise(Rinda::RequestExpiredError) do
- @ts.take([:empty], 0)
- end
-
- assert_raise(Rinda::RequestExpiredError) do
- @ts.read([:empty], 0)
- end
- end
-
- def test_ruby_talk_264062
- th = Thread.new { @ts.take([:empty], 1) }
- sleep(10)
- assert_raise(Rinda::RequestExpiredError) do
- thread_join(th)
- end
-
- th = Thread.new { @ts.read([:empty], 1) }
- sleep(10)
- assert_raise(Rinda::RequestExpiredError) do
- thread_join(th)
- end
- end
-
- def test_symbol_tuple
- @ts.write([:symbol, :symbol])
- @ts.write(['string', :string])
- assert_equal([[:symbol, :symbol]], @ts.read_all([:symbol, nil]))
- assert_equal([[:symbol, :symbol]], @ts.read_all([Symbol, nil]))
- assert_equal([], @ts.read_all([:nil, nil]))
- end
-
- def test_core_01
- 5.times do
- @ts.write([:req, 2])
- end
-
- assert_equal([[:req, 2], [:req, 2], [:req, 2], [:req, 2], [:req, 2]],
- @ts.read_all([nil, nil]))
-
- taker = Thread.new(5) do |count|
- s = 0
- count.times do
- tuple = @ts.take([:req, Integer])
- assert_equal(2, tuple[1])
- s += tuple[1]
- end
- @ts.write([:ans, s])
- s
- end
-
- assert_equal(10, thread_join(taker))
- assert_equal([:ans, 10], @ts.take([:ans, 10]))
- assert_equal([], @ts.read_all([nil, nil]))
- end
-
- def test_core_02
- taker = Thread.new(5) do |count|
- s = 0
- count.times do
- tuple = @ts.take([:req, Integer])
- assert_equal(2, tuple[1])
- s += tuple[1]
- end
- @ts.write([:ans, s])
- s
- end
-
- 5.times do
- @ts.write([:req, 2])
- end
-
- assert_equal(10, thread_join(taker))
- assert_equal([:ans, 10], @ts.take([:ans, 10]))
- assert_equal([], @ts.read_all([nil, nil]))
- end
-
- def test_core_03_notify
- notify1 = @ts.notify(nil, [:req, Integer])
- notify2 = @ts.notify(nil, {"message"=>String, "name"=>String})
-
- 5.times do
- @ts.write([:req, 2])
- end
-
- 5.times do
- tuple = @ts.take([:req, Integer])
- assert_equal(2, tuple[1])
- end
-
- 5.times do
- assert_equal(['write', [:req, 2]], notify1.pop)
- end
- 5.times do
- assert_equal(['take', [:req, 2]], notify1.pop)
- end
-
- @ts.write({"message"=>"first", "name"=>"3"})
- @ts.write({"message"=>"second", "name"=>"1"})
- @ts.write({"message"=>"third", "name"=>"0"})
- @ts.take({"message"=>"third", "name"=>"0"})
- @ts.take({"message"=>"first", "name"=>"3"})
-
- assert_equal(["write", {"message"=>"first", "name"=>"3"}], notify2.pop)
- assert_equal(["write", {"message"=>"second", "name"=>"1"}], notify2.pop)
- assert_equal(["write", {"message"=>"third", "name"=>"0"}], notify2.pop)
- assert_equal(["take", {"message"=>"third", "name"=>"0"}], notify2.pop)
- assert_equal(["take", {"message"=>"first", "name"=>"3"}], notify2.pop)
- end
-
- def test_cancel_01
- entry = @ts.write([:removeme, 1])
- assert_equal([[:removeme, 1]], @ts.read_all([nil, nil]))
- entry.cancel
- assert_equal([], @ts.read_all([nil, nil]))
-
- template = nil
- taker = Thread.new do
- @ts.take([:take, nil], 10) do |t|
- template = t
- Thread.new do
- template.cancel
- end
- end
- end
-
- sleep(2)
-
- assert_raise(Rinda::RequestCanceledError) do
- assert_nil(thread_join(taker))
- end
-
- assert(template.canceled?)
-
- @ts.write([:take, 1])
-
- assert_equal([[:take, 1]], @ts.read_all([nil, nil]))
- end
-
- def test_cancel_02
- entry = @ts.write([:removeme, 1])
- assert_equal([[:removeme, 1]], @ts.read_all([nil, nil]))
- entry.cancel
- assert_equal([], @ts.read_all([nil, nil]))
-
- template = nil
- reader = Thread.new do
- @ts.read([:take, nil], 10) do |t|
- template = t
- Thread.new do
- template.cancel
- end
- end
- end
-
- sleep(2)
-
- assert_raise(Rinda::RequestCanceledError) do
- assert_nil(thread_join(reader))
- end
-
- assert(template.canceled?)
-
- @ts.write([:take, 1])
-
- assert_equal([[:take, 1]], @ts.read_all([nil, nil]))
- end
-
- class SimpleRenewer
- def initialize(sec, n = 1)
- @sec = sec
- @n = n
- end
-
- def renew
- return -1 if @n <= 0
- @n -= 1
- return @sec
- end
- end
-
- def test_00_renewer
- tuple = Rinda::TupleEntry.new([1,2,3], true)
- assert(!tuple.canceled?)
- assert(tuple.expired?)
- assert(!tuple.alive?)
-
- tuple = Rinda::TupleEntry.new([1,2,3], 1)
- assert(!tuple.canceled?)
- assert(!tuple.expired?)
- assert(tuple.alive?)
- sleep(2)
- assert(tuple.expired?)
- assert(!tuple.alive?)
-
- @renewer = SimpleRenewer.new(1,2)
- tuple = Rinda::TupleEntry.new([1,2,3], @renewer)
- assert(!tuple.canceled?)
- assert(!tuple.expired?)
- assert(tuple.alive?)
- sleep(1)
- assert(!tuple.canceled?)
- assert(!tuple.expired?)
- assert(tuple.alive?)
- sleep(2)
- assert(tuple.expired?)
- assert(!tuple.alive?)
- end
-end
-
-class TupleSpaceTest < Test::Unit::TestCase
- include TupleSpaceTestModule
+#class MockClock
+# include Singleton
+#
+# class MyTS < Rinda::TupleSpace
+# def keeper_thread
+# nil
+# end
+# end
+#
+# def initialize
+# @now = 2
+# @reso = 1
+# @ts = MyTS.new
+# @ts.write([2, :now])
+# @inf = 2**31 - 1
+# end
+#
+# def now
+# @now.to_f
+# end
+#
+# def at(n)
+# n
+# end
+#
+# def _forward(n=nil)
+# now ,= @ts.take([nil, :now])
+# @now = now + n
+# n = @reso if n.nil?
+# @ts.write([@now, :now])
+# end
+#
+# def forward(n)
+# while n > 0
+# _forward(@reso)
+# n -= @reso
+# Thread.pass
+# end
+# end
+#
+# def rewind
+# now ,= @ts.take([nil, :now])
+# @ts.write([@inf, :now])
+# @ts.take([nil, :now])
+# @now = 2
+# @ts.write([2, :now])
+# end
+#
+# def sleep(n=nil)
+# now ,= @ts.read([nil, :now])
+# @ts.read([(now + n)..@inf, :now])
+# 0
+# end
+#end
+#
+#module Time
+# def sleep(n)
+# @m.sleep(n)
+# end
+# module_function :sleep
+#
+# def at(n)
+# n
+# end
+# module_function :at
+#
+# def now
+# @m ? @m.now : 2
+# end
+# module_function :now
+#
+# def rewind
+# @m.rewind
+# end
+# module_function :rewind
+#
+# def forward(n)
+# @m.forward(n)
+# end
+# module_function :forward
+#
+# @m = MockClock.instance
+#end
+#
+#class TupleSpace
+# def sleep(n)
+# Kernel.sleep(n * 0.01)
+# end
+#end
+#
+#module TupleSpaceTestModule
+# def sleep(n)
+# if Thread.current == Thread.main
+# Time.forward(n)
+# else
+# Time.sleep(n)
+# end
+# end
+#
+# def thread_join(th)
+# while th.alive?
+# Kernel.sleep(0.1)
+# sleep(1)
+# end
+# th.value
+# end
+#
+# def test_00_tuple
+# tuple = Rinda::TupleEntry.new([1,2,3])
+# assert(!tuple.canceled?)
+# assert(!tuple.expired?)
+# assert(tuple.alive?)
+# end
+#
+# def test_00_template
+# tmpl = Rinda::Template.new([1,2,3])
+# assert_equal(3, tmpl.size)
+# assert_equal(3, tmpl[2])
+# assert(tmpl.match([1,2,3]))
+# assert(!tmpl.match([1,nil,3]))
+#
+# tmpl = Rinda::Template.new([/^rinda/i, nil, :hello])
+# assert_equal(3, tmpl.size)
+# assert(tmpl.match(['Rinda', 2, :hello]))
+# assert(!tmpl.match(['Rinda', 2, Symbol]))
+# assert(!tmpl.match([1, 2, :hello]))
+# assert(tmpl.match([/^rinda/i, 2, :hello]))
+#
+# tmpl = Rinda::Template.new([Symbol])
+# assert_equal(1, tmpl.size)
+# assert(tmpl.match([:hello]))
+# assert(tmpl.match([Symbol]))
+# assert(!tmpl.match(['Symbol']))
+#
+# tmpl = Rinda::Template.new({"message"=>String, "name"=>String})
+# assert_equal(2, tmpl.size)
+# assert(tmpl.match({"message"=>"Hello", "name"=>"Foo"}))
+# assert(!tmpl.match({"message"=>"Hello", "name"=>"Foo", "1"=>2}))
+# assert(!tmpl.match({"message"=>"Hi", "name"=>"Foo", "age"=>1}))
+# assert(!tmpl.match({"message"=>"Hello", "no_name"=>"Foo"}))
+#
+# assert_raise(Rinda::InvalidHashTupleKey) do
+# Rinda::Template.new({:message=>String, "name"=>String})
+# end
+# tmpl = Rinda::Template.new({"name"=>String})
+# assert_equal(1, tmpl.size)
+# assert(tmpl.match({"name"=>"Foo"}))
+# assert(!tmpl.match({"message"=>"Hello", "name"=>"Foo"}))
+# assert(!tmpl.match({"message"=>:symbol, "name"=>"Foo", "1"=>2}))
+# assert(!tmpl.match({"message"=>"Hi", "name"=>"Foo", "age"=>1}))
+# assert(!tmpl.match({"message"=>"Hello", "no_name"=>"Foo"}))
+#
+# tmpl = Rinda::Template.new({"message"=>String, "name"=>String})
+# assert_equal(2, tmpl.size)
+# assert(tmpl.match({"message"=>"Hello", "name"=>"Foo"}))
+# assert(!tmpl.match({"message"=>"Hello", "name"=>"Foo", "1"=>2}))
+# assert(!tmpl.match({"message"=>"Hi", "name"=>"Foo", "age"=>1}))
+# assert(!tmpl.match({"message"=>"Hello", "no_name"=>"Foo"}))
+#
+# tmpl = Rinda::Template.new({"message"=>String})
+# assert_equal(1, tmpl.size)
+# assert(tmpl.match({"message"=>"Hello"}))
+# assert(!tmpl.match({"message"=>"Hello", "name"=>"Foo"}))
+# assert(!tmpl.match({"message"=>"Hello", "name"=>"Foo", "1"=>2}))
+# assert(!tmpl.match({"message"=>"Hi", "name"=>"Foo", "age"=>1}))
+# assert(!tmpl.match({"message"=>"Hello", "no_name"=>"Foo"}))
+#
+# tmpl = Rinda::Template.new({"message"=>String, "name"=>nil})
+# assert_equal(2, tmpl.size)
+# assert(tmpl.match({"message"=>"Hello", "name"=>"Foo"}))
+# assert(!tmpl.match({"message"=>"Hello", "name"=>"Foo", "1"=>2}))
+# assert(!tmpl.match({"message"=>"Hi", "name"=>"Foo", "age"=>1}))
+# assert(!tmpl.match({"message"=>"Hello", "no_name"=>"Foo"}))
+#
+# assert_raise(Rinda::InvalidHashTupleKey) do
+# @ts.write({:message=>String, "name"=>String})
+# end
+#
+# @ts.write([1, 2, 3])
+# assert_equal([1, 2, 3], @ts.take([1, 2, 3]))
+#
+# @ts.write({'1'=>1, '2'=>2, '3'=>3})
+# assert_equal({'1'=>1, '2'=>2, '3'=>3}, @ts.take({'1'=>1, '2'=>2, '3'=>3}))
+#
+# entry = @ts.write(['1'=>1, '2'=>2, '3'=>3])
+# assert_raise(Rinda::RequestExpiredError) do
+# assert_equal({'1'=>1, '2'=>2, '3'=>3}, @ts.read({'1'=>1}, 0))
+# end
+# entry.cancel
+# end
+#
+# def test_00_DRbObject
+# ro = DRbObject.new(nil, "druby://host:1234")
+# tmpl = Rinda::DRbObjectTemplate.new
+# assert(tmpl === ro)
+#
+# tmpl = Rinda::DRbObjectTemplate.new("druby://host:1234")
+# assert(tmpl === ro)
+#
+# tmpl = Rinda::DRbObjectTemplate.new("druby://host:12345")
+# assert(!(tmpl === ro))
+#
+# tmpl = Rinda::DRbObjectTemplate.new(/^druby:\/\/host:/)
+# assert(tmpl === ro)
+#
+# ro = DRbObject.new_with(12345, 1234)
+# assert(!(tmpl === ro))
+#
+# ro = DRbObject.new_with("druby://foo:12345", 1234)
+# assert(!(tmpl === ro))
+#
+# tmpl = Rinda::DRbObjectTemplate.new(/^druby:\/\/(foo|bar):/)
+# assert(tmpl === ro)
+#
+# ro = DRbObject.new_with("druby://bar:12345", 1234)
+# assert(tmpl === ro)
+#
+# ro = DRbObject.new_with("druby://baz:12345", 1234)
+# assert(!(tmpl === ro))
+# end
+#
+# def test_inp_rdp
+# assert_raise(Rinda::RequestExpiredError) do
+# @ts.take([:empty], 0)
+# end
+#
+# assert_raise(Rinda::RequestExpiredError) do
+# @ts.read([:empty], 0)
+# end
+# end
+#
+# def test_ruby_talk_264062
+# th = Thread.new { @ts.take([:empty], 1) }
+# sleep(10)
+# assert_raise(Rinda::RequestExpiredError) do
+# thread_join(th)
+# end
+#
+# th = Thread.new { @ts.read([:empty], 1) }
+# sleep(10)
+# assert_raise(Rinda::RequestExpiredError) do
+# thread_join(th)
+# end
+# end
+#
+# def test_symbol_tuple
+# @ts.write([:symbol, :symbol])
+# @ts.write(['string', :string])
+# assert_equal([[:symbol, :symbol]], @ts.read_all([:symbol, nil]))
+# assert_equal([[:symbol, :symbol]], @ts.read_all([Symbol, nil]))
+# assert_equal([], @ts.read_all([:nil, nil]))
+# end
+#
+# def test_core_01
+# 5.times do
+# @ts.write([:req, 2])
+# end
+#
+# assert_equal([[:req, 2], [:req, 2], [:req, 2], [:req, 2], [:req, 2]],
+# @ts.read_all([nil, nil]))
+#
+# taker = Thread.new(5) do |count|
+# s = 0
+# count.times do
+# tuple = @ts.take([:req, Integer])
+# assert_equal(2, tuple[1])
+# s += tuple[1]
+# end
+# @ts.write([:ans, s])
+# s
+# end
+#
+# assert_equal(10, thread_join(taker))
+# assert_equal([:ans, 10], @ts.take([:ans, 10]))
+# assert_equal([], @ts.read_all([nil, nil]))
+# end
+#
+# def test_core_02
+# taker = Thread.new(5) do |count|
+# s = 0
+# count.times do
+# tuple = @ts.take([:req, Integer])
+# assert_equal(2, tuple[1])
+# s += tuple[1]
+# end
+# @ts.write([:ans, s])
+# s
+# end
+#
+# 5.times do
+# @ts.write([:req, 2])
+# end
+#
+# assert_equal(10, thread_join(taker))
+# assert_equal([:ans, 10], @ts.take([:ans, 10]))
+# assert_equal([], @ts.read_all([nil, nil]))
+# end
+#
+# def test_core_03_notify
+# notify1 = @ts.notify(nil, [:req, Integer])
+# notify2 = @ts.notify(nil, {"message"=>String, "name"=>String})
+#
+# 5.times do
+# @ts.write([:req, 2])
+# end
+#
+# 5.times do
+# tuple = @ts.take([:req, Integer])
+# assert_equal(2, tuple[1])
+# end
+#
+# 5.times do
+# assert_equal(['write', [:req, 2]], notify1.pop)
+# end
+# 5.times do
+# assert_equal(['take', [:req, 2]], notify1.pop)
+# end
+#
+# @ts.write({"message"=>"first", "name"=>"3"})
+# @ts.write({"message"=>"second", "name"=>"1"})
+# @ts.write({"message"=>"third", "name"=>"0"})
+# @ts.take({"message"=>"third", "name"=>"0"})
+# @ts.take({"message"=>"first", "name"=>"3"})
+#
+# assert_equal(["write", {"message"=>"first", "name"=>"3"}], notify2.pop)
+# assert_equal(["write", {"message"=>"second", "name"=>"1"}], notify2.pop)
+# assert_equal(["write", {"message"=>"third", "name"=>"0"}], notify2.pop)
+# assert_equal(["take", {"message"=>"third", "name"=>"0"}], notify2.pop)
+# assert_equal(["take", {"message"=>"first", "name"=>"3"}], notify2.pop)
+# end
+#
+# def test_cancel_01
+# entry = @ts.write([:removeme, 1])
+# assert_equal([[:removeme, 1]], @ts.read_all([nil, nil]))
+# entry.cancel
+# assert_equal([], @ts.read_all([nil, nil]))
+#
+# template = nil
+# taker = Thread.new do
+# @ts.take([:take, nil], 10) do |t|
+# template = t
+# Thread.new do
+# template.cancel
+# end
+# end
+# end
+#
+# sleep(2)
+#
+# assert_raise(Rinda::RequestCanceledError) do
+# assert_nil(thread_join(taker))
+# end
+#
+# assert(template.canceled?)
+#
+# @ts.write([:take, 1])
+#
+# assert_equal([[:take, 1]], @ts.read_all([nil, nil]))
+# end
+#
+# def test_cancel_02
+# entry = @ts.write([:removeme, 1])
+# assert_equal([[:removeme, 1]], @ts.read_all([nil, nil]))
+# entry.cancel
+# assert_equal([], @ts.read_all([nil, nil]))
+#
+# template = nil
+# reader = Thread.new do
+# @ts.read([:take, nil], 10) do |t|
+# template = t
+# Thread.new do
+# template.cancel
+# end
+# end
+# end
+#
+# sleep(2)
+#
+# assert_raise(Rinda::RequestCanceledError) do
+# assert_nil(thread_join(reader))
+# end
+#
+# assert(template.canceled?)
+#
+# @ts.write([:take, 1])
+#
+# assert_equal([[:take, 1]], @ts.read_all([nil, nil]))
+# end
+#
+# class SimpleRenewer
+# def initialize(sec, n = 1)
+# @sec = sec
+# @n = n
+# end
+#
+# def renew
+# return -1 if @n <= 0
+# @n -= 1
+# return @sec
+# end
+# end
+#
+# def test_00_renewer
+# tuple = Rinda::TupleEntry.new([1,2,3], true)
+# assert(!tuple.canceled?)
+# assert(tuple.expired?)
+# assert(!tuple.alive?)
+#
+# tuple = Rinda::TupleEntry.new([1,2,3], 1)
+# assert(!tuple.canceled?)
+# assert(!tuple.expired?)
+# assert(tuple.alive?)
+# sleep(2)
+# assert(tuple.expired?)
+# assert(!tuple.alive?)
+#
+# @renewer = SimpleRenewer.new(1,2)
+# tuple = Rinda::TupleEntry.new([1,2,3], @renewer)
+# assert(!tuple.canceled?)
+# assert(!tuple.expired?)
+# assert(tuple.alive?)
+# sleep(1)
+# assert(!tuple.canceled?)
+# assert(!tuple.expired?)
+# assert(tuple.alive?)
+# sleep(2)
+# assert(tuple.expired?)
+# assert(!tuple.alive?)
+# end
+#end
+#
+#class TupleSpaceTest < Test::Unit::TestCase
+# include TupleSpaceTestModule
+#
+# def setup
+# ThreadGroup.new.add(Thread.current)
+# @ts = Rinda::TupleSpace.new(1)
+# end
+# def teardown
+# # implementation-dependent
+# @ts.instance_eval{@keeper.kill if @keeper}
+# end
+#end
+#
+#class TupleSpaceProxyTest < Test::Unit::TestCase
+# include TupleSpaceTestModule
+#
+# def setup
+# ThreadGroup.new.add(Thread.current)
+# @ts_base = Rinda::TupleSpace.new(1)
+# @ts = Rinda::TupleSpaceProxy.new(@ts_base)
+# end
+# def teardown
+# # implementation-dependent
+# @ts_base.instance_eval{@keeper.kill if @keeper}
+# end
+#
+# def test_remote_array_and_hash
+# # Don't remove ary/hsh local variables.
+# # These are necessary to protect objects from GC.
+# ary = [1, 2, 3]
+# @ts.write(DRbObject.new(ary))
+# assert_equal([1, 2, 3], @ts.take([1, 2, 3], 0))
+# hsh = {'head' => 1, 'tail' => 2}
+# @ts.write(DRbObject.new(hsh))
+# assert_equal({'head' => 1, 'tail' => 2},
+# @ts.take({'head' => 1, 'tail' => 2}, 0))
+# end
+#
+# def test_take_bug_8215
+# service = DRb.start_service(nil, @ts_base)
+#
+# uri = service.uri
+#
+# take = fork do
+# DRb.start_service
+# ro = DRbObject.new_with_uri(uri)
+# ts = Rinda::TupleSpaceProxy.new(ro)
+# th = Thread.new do
+# ts.take([:test_take, nil])
+# end
+# Kernel.sleep(0.1)
+# th.raise(Interrupt) # causes loss of the taken tuple
+# ts.write([:barrier, :continue])
+# Kernel.sleep
+# end
+#
+# @ts_base.take([:barrier, :continue])
+#
+# write = fork do
+# DRb.start_service
+# ro = DRbObject.new_with_uri(uri)
+# ts = Rinda::TupleSpaceProxy.new(ro)
+# ts.write([:test_take, 42])
+# end
+#
+# status = Process.wait(write)
+#
+# assert_equal([[:test_take, 42]], @ts_base.read_all([:test_take, nil]),
+# '[bug:8215] tuple lost')
+# ensure
+# Process.kill("TERM", write) if write && status.nil?
+# Process.kill("TERM", take) if take
+# end
+#
+# @server = DRb.primary_server || DRb.start_service
+#end
+
+class TestRingServer < Test::Unit::TestCase
def setup
- ThreadGroup.new.add(Thread.current)
- @ts = Rinda::TupleSpace.new(1)
- end
- def teardown
- # implementation-dependent
- @ts.instance_eval{@keeper.kill if @keeper}
- end
-end
+ @port = Rinda::Ring_PORT
-class TupleSpaceProxyTest < Test::Unit::TestCase
- include TupleSpaceTestModule
-
- def setup
- ThreadGroup.new.add(Thread.current)
- @ts_base = Rinda::TupleSpace.new(1)
- @ts = Rinda::TupleSpaceProxy.new(@ts_base)
+ @ts = Rinda::TupleSpace.new
+ @rs = Rinda::RingServer.new(@ts, [], @port)
end
def teardown
# implementation-dependent
- @ts_base.instance_eval{@keeper.kill if @keeper}
- end
-
- def test_remote_array_and_hash
- # Don't remove ary/hsh local variables.
- # These are necessary to protect objects from GC.
- ary = [1, 2, 3]
- @ts.write(DRbObject.new(ary))
- assert_equal([1, 2, 3], @ts.take([1, 2, 3], 0))
- hsh = {'head' => 1, 'tail' => 2}
- @ts.write(DRbObject.new(hsh))
- assert_equal({'head' => 1, 'tail' => 2},
- @ts.take({'head' => 1, 'tail' => 2}, 0))
- end
-
- def test_take_bug_8215
- service = DRb.start_service(nil, @ts_base)
-
- uri = service.uri
-
- take = fork do
- DRb.start_service
- ro = DRbObject.new_with_uri(uri)
- ts = Rinda::TupleSpaceProxy.new(ro)
- th = Thread.new do
- ts.take([:test_take, nil])
- end
- Kernel.sleep(0.1)
- th.raise(Interrupt) # causes loss of the taken tuple
- ts.write([:barrier, :continue])
- Kernel.sleep
- end
-
- @ts_base.take([:barrier, :continue])
-
- write = fork do
- DRb.start_service
- ro = DRbObject.new_with_uri(uri)
- ts = Rinda::TupleSpaceProxy.new(ro)
- ts.write([:test_take, 42])
- end
-
- status = Process.wait(write)
-
- assert_equal([[:test_take, 42]], @ts_base.read_all([:test_take, nil]),
- '[bug:8215] tuple lost')
- ensure
- Process.kill("TERM", write) if write && status.nil?
- Process.kill("TERM", take) if take
+ @ts.instance_eval{@keeper.kill if @keeper}
+ @rs.shutdown
+ end
+
+ def test_make_socket_unicast
+ v4 = @rs.make_socket('127.0.0.1')
+
+ assert_equal('127.0.0.1', v4.local_address.ip_address)
+ assert_equal(@port, v4.local_address.ip_port)
+ end
+#
+# def test_make_socket_ipv4_multicast
+# v4mc = @rs.make_socket('239.0.0.1')
+#
+# if Socket.const_defined?(:SO_REUSEPORT) then
+# assert(v4mc.getsockopt(:SOCKET, :SO_REUSEPORT).bool)
+# else
+# assert(v4mc.getsockopt(:SOCKET, :SO_REUSEADDR).bool)
+# end
+#
+# assert_equal('239.0.0.1', v4mc.local_address.ip_address)
+# assert_equal(@port, v4mc.local_address.ip_port)
+# end
+#
+# def test_make_socket_ipv6_multicast
+# begin
+# v6mc = @rs.make_socket('ff02::1')
+# rescue Errno::EADDRNOTAVAIL
+# return # IPv6 address for multicast not available
+# end
+#
+# if Socket.const_defined?(:SO_REUSEPORT) then
+# assert v6mc.getsockopt(:SOCKET, :SO_REUSEPORT).bool
+# else
+# assert v6mc.getsockopt(:SOCKET, :SO_REUSEADDR).bool
+# end
+#
+# assert_equal('ff02::1', v6mc.local_address.ip_address)
+# assert_equal(@port, v6mc.local_address.ip_port)
+# end
+
+ def test_shutdown
+ @rs.shutdown
+
+ assert_nil(@rs.do_reply, 'otherwise should hang forever')
end
- @server = DRb.primary_server || DRb.start_service
end
+#class TestRingFinger < Test::Unit::TestCase
+#
+# def setup
+# @rf = Rinda::RingFinger.new
+# @rf.multicast_interface = 1
+# end
+#
+# def test_make_socket_unicast
+# v4 = @rf.make_socket('127.0.0.1')
+#
+# assert(v4.getsockopt(:SOL_SOCKET, :SO_BROADCAST).bool)
+# end
+#
+# def test_make_socket_ipv4_multicast
+# v4mc = @rf.make_socket('239.0.0.1')
+#
+# assert_equal(1, v4mc.getsockopt(:IPPROTO_IP, :IP_MULTICAST_LOOP).int)
+# assert_equal(1, v4mc.getsockopt(:IPPROTO_IP, :IP_MULTICAST_TTL).int)
+# end
+#
+# def test_make_socket_ipv6_multicast
+# v6mc = @rf.make_socket('ff02::1')
+#
+# assert_equal(1, v6mc.getsockopt(:IPPROTO_IPV6, :IPV6_MULTICAST_LOOP).int)
+# assert_equal(1, v6mc.getsockopt(:IPPROTO_IPV6, :IPV6_MULTICAST_HOPS).int)
+# end
+#
+# def test_make_socket_multicast_hops
+# @rf.multicast_hops = 2
+#
+# v4mc = @rf.make_socket('239.0.0.1')
+#
+# assert_equal(2, v4mc.getsockopt(:IPPROTO_IP, :IP_MULTICAST_TTL).int)
+#
+# v6mc = @rf.make_socket('ff02::1')
+#
+# assert_equal(2, v6mc.getsockopt(:IPPROTO_IPV6, :IPV6_MULTICAST_HOPS).int)
+# end
+#
+#end
+
end