test/rinda/test_rinda.rb

   1 require 'test/unit'
   2
   3 require 'drb/drb'
   4 require 'drb/eq'
   5 require 'rinda/tuplespace'
   6
   7 require 'singleton'
   8
   9 module Rinda
  10
  11 class MockClock
  12   include Singleton
  13
  14   class MyTS < Rinda::TupleSpace
  15     def keeper_thread
  16       nil
  17     end
  18   end
  19
  20   def initialize
  21     @now = 2
  22     @reso = 1
  23     @ts = MyTS.new
  24     @ts.write([2, :now])
  25     @inf = 2**31 - 1
  26   end
  27
  28   def now
  29     @now.to_f
  30   end
  31
  32   def at(n)
  33     n
  34   end
  35
  36   def _forward(n=nil)
  37     now ,= @ts.take([nil, :now])
  38     @now = now + n
  39     n = @reso if n.nil?
  40     @ts.write([@now, :now])
  41   end
  42
  43   def forward(n)
  44     while n > 0
  45       _forward(@reso)
  46       n -= @reso
  47       Thread.pass
  48     end
  49   end
  50
  51   def rewind
  52     now ,= @ts.take([nil, :now])
  53     @ts.write([@inf, :now])
  54     @ts.take([nil, :now])
  55     @now = 2
  56     @ts.write([2, :now])
  57   end
  58
  59   def sleep(n=nil)
  60     now ,= @ts.read([nil, :now])
  61     @ts.read([(now + n)..@inf, :now])
  62     0
  63   end
  64 end
  65
  66 module Time
  67   def sleep(n)
  68     @m.sleep(n)
  69   end
  70   module_function :sleep
  71
  72   def at(n)
  73     n
  74   end
  75   module_function :at
  76
  77   def now
  78     @m ? @m.now : 2
  79   end
  80   module_function :now
  81
  82   def rewind
  83     @m.rewind
  84   end
  85   module_function :rewind
  86
  87   def forward(n)
  88     @m.forward(n)
  89   end
  90   module_function :forward
  91
  92   @m = MockClock.instance
  93 end
  94
  95 class TupleSpace
  96   def sleep(n)
  97     Time.sleep(n)
  98   end
  99 end
 100
 101 module TupleSpaceTestModule
 102   def sleep(n)
 103     if Thread.current == Thread.main
 104       Time.forward(n)
 105     else
 106       Time.sleep(n)
 107     end
 108   end
 109
 110   def thread_join(th)
 111     while th.alive?
 112       Kernel.sleep(0.1)
 113       sleep(1)
 114     end
 115     th.value
 116   end
 117
 118   def test_00_tuple
 119     tuple = Rinda::TupleEntry.new([1,2,3])
 120     assert(!tuple.canceled?)
 121     assert(!tuple.expired?)
 122     assert(tuple.alive?)
 123   end
 124
 125   def test_00_template
 126     tmpl = Rinda::Template.new([1,2,3])
 127     assert_equal(3, tmpl.size)
 128     assert_equal(3, tmpl[2])
 129     assert(tmpl.match([1,2,3]))
 130     assert(!tmpl.match([1,nil,3]))
 131
 132     tmpl = Rinda::Template.new([/^rinda/i, nil, :hello])
 133     assert_equal(3, tmpl.size)
 134     assert(tmpl.match(['Rinda', 2, :hello]))
 135     assert(!tmpl.match(['Rinda', 2, Symbol]))
 136     assert(!tmpl.match([1, 2, :hello]))
 137     assert(tmpl.match([/^rinda/i, 2, :hello]))
 138
 139     tmpl = Rinda::Template.new([Symbol])
 140     assert_equal(1, tmpl.size)
 141     assert(tmpl.match([:hello]))
 142     assert(tmpl.match([Symbol]))
 143     assert(!tmpl.match(['Symbol']))
 144
 145     tmpl = Rinda::Template.new({"message"=>String, "name"=>String})
 146     assert_equal(2, tmpl.size)
 147     assert(tmpl.match({"message"=>"Hello", "name"=>"Foo"}))
 148     assert(!tmpl.match({"message"=>"Hello", "name"=>"Foo", "1"=>2}))
 149     assert(!tmpl.match({"message"=>"Hi", "name"=>"Foo", "age"=>1}))
 150     assert(!tmpl.match({"message"=>"Hello", "no_name"=>"Foo"}))
 151
 152     assert_raises(Rinda::InvalidHashTupleKey) do
 153       tmpl = Rinda::Template.new({:message=>String, "name"=>String})
 154     end
 155     tmpl = Rinda::Template.new({"name"=>String})
 156     assert_equal(1, tmpl.size)
 157     assert(tmpl.match({"name"=>"Foo"}))
 158     assert(!tmpl.match({"message"=>"Hello", "name"=>"Foo"}))
 159     assert(!tmpl.match({"message"=>:symbol, "name"=>"Foo", "1"=>2}))
 160     assert(!tmpl.match({"message"=>"Hi", "name"=>"Foo", "age"=>1}))
 161     assert(!tmpl.match({"message"=>"Hello", "no_name"=>"Foo"}))
 162
 163     tmpl = Rinda::Template.new({"message"=>String, "name"=>String})
 164     assert_equal(2, tmpl.size)
 165     assert(tmpl.match({"message"=>"Hello", "name"=>"Foo"}))
 166     assert(!tmpl.match({"message"=>"Hello", "name"=>"Foo", "1"=>2}))
 167     assert(!tmpl.match({"message"=>"Hi", "name"=>"Foo", "age"=>1}))
 168     assert(!tmpl.match({"message"=>"Hello", "no_name"=>"Foo"}))
 169
 170     tmpl = Rinda::Template.new({"message"=>String})
 171     assert_equal(1, tmpl.size)
 172     assert(tmpl.match({"message"=>"Hello"}))
 173     assert(!tmpl.match({"message"=>"Hello", "name"=>"Foo"}))
 174     assert(!tmpl.match({"message"=>"Hello", "name"=>"Foo", "1"=>2}))
 175     assert(!tmpl.match({"message"=>"Hi", "name"=>"Foo", "age"=>1}))
 176     assert(!tmpl.match({"message"=>"Hello", "no_name"=>"Foo"}))
 177
 178     tmpl = Rinda::Template.new({"message"=>String, "name"=>nil})
 179     assert_equal(2, tmpl.size)
 180     assert(tmpl.match({"message"=>"Hello", "name"=>"Foo"}))
 181     assert(!tmpl.match({"message"=>"Hello", "name"=>"Foo", "1"=>2}))
 182     assert(!tmpl.match({"message"=>"Hi", "name"=>"Foo", "age"=>1}))
 183     assert(!tmpl.match({"message"=>"Hello", "no_name"=>"Foo"}))
 184
 185     assert_raises(Rinda::InvalidHashTupleKey) do
 186       @ts.write({:message=>String, "name"=>String})
 187     end
 188
 189     @ts.write([1, 2, 3])
 190     assert_equal([1, 2, 3], @ts.take([1, 2, 3]))
 191
 192     @ts.write({'1'=>1, '2'=>2, '3'=>3})
 193     assert_equal({'1'=>1, '2'=>2, '3'=>3}, @ts.take({'1'=>1, '2'=>2, '3'=>3}))
 194
 195     entry = @ts.write(['1'=>1, '2'=>2, '3'=>3])
 196     assert_raises(Rinda::RequestExpiredError) do
 197       assert_equal({'1'=>1, '2'=>2, '3'=>3}, @ts.read({'1'=>1}, 0))
 198     end
 199     entry.cancel
 200   end
 201
 202   def test_00_DRbObject
 203     ro = DRbObject.new(nil, "druby://host:1234")
 204     tmpl = Rinda::DRbObjectTemplate.new
 205     assert(tmpl === ro)
 206
 207     tmpl = Rinda::DRbObjectTemplate.new("druby://host:1234")
 208     assert(tmpl === ro)
 209
 210     tmpl = Rinda::DRbObjectTemplate.new("druby://host:12345")
 211     assert(!(tmpl === ro))
 212
 213     tmpl = Rinda::DRbObjectTemplate.new(/^druby:\/\/host:/)
 214     assert(tmpl === ro)
 215
 216     ro = DRbObject.new_with(12345, 1234)
 217     assert(!(tmpl === ro))
 218
 219     ro = DRbObject.new_with("druby://foo:12345", 1234)
 220     assert(!(tmpl === ro))
 221
 222     tmpl = Rinda::DRbObjectTemplate.new(/^druby:\/\/(foo|bar):/)
 223     assert(tmpl === ro)
 224
 225     ro = DRbObject.new_with("druby://bar:12345", 1234)
 226     assert(tmpl === ro)
 227
 228     ro = DRbObject.new_with("druby://baz:12345", 1234)
 229     assert(!(tmpl === ro))
 230   end
 231
 232   def test_inp_rdp
 233     assert_raises(Rinda::RequestExpiredError) do
 234       @ts.take([:empty], 0)
 235     end
 236
 237     assert_raises(Rinda::RequestExpiredError) do
 238       @ts.read([:empty], 0)
 239     end
 240   end
 241
 242   def test_ruby_talk_264062
 243     th = Thread.new { @ts.take([:empty], 1) }
 244     sleep(10)
 245     assert_raises(Rinda::RequestExpiredError) do
 246       thread_join(th)
 247     end
 248
 249     th = Thread.new { @ts.read([:empty], 1) }
 250     sleep(10)
 251     assert_raises(Rinda::RequestExpiredError) do
 252       thread_join(th)
 253     end
 254   end
 255
 256   def test_symbol_tuple
 257     @ts.write([:symbol, :symbol])
 258     @ts.write(['string', :string])
 259     assert_equal([[:symbol, :symbol]], @ts.read_all([:symbol, nil]))
 260     assert_equal([[:symbol, :symbol]], @ts.read_all([Symbol, nil]))
 261     assert_equal([], @ts.read_all([:nil, nil]))
 262   end
 263
 264   def test_core_01
 265     5.times do |n|
 266       @ts.write([:req, 2])
 267     end
 268
 269     assert_equal([[:req, 2], [:req, 2], [:req, 2], [:req, 2], [:req, 2]],
 270                  @ts.read_all([nil, nil]))
 271
 272     taker = Thread.new do
 273       s = 0
 274       while true
 275         begin
 276           tuple = @ts.take([:req, Integer], 1)
 277           assert_equal(2, tuple[1])
 278           s += tuple[1]
 279         rescue Rinda::RequestExpiredError
 280           break
 281         end
 282       end
 283       @ts.write([:ans, s])
 284       s
 285     end
 286
 287     assert_equal(10, thread_join(taker))
 288     tuple = @ts.take([:ans, nil])
 289     assert_equal(10, tuple[1])
 290   end
 291
 292   def test_core_02
 293     taker = Thread.new do
 294       s = 0
 295       while true
 296         begin
 297           tuple = @ts.take([:req, Integer], 1)
 298           assert_equal(2, tuple[1])
 299           s += tuple[1]
 300         rescue Rinda::RequestExpiredError
 301           break
 302         end
 303       end
 304       @ts.write([:ans, s])
 305       s
 306     end
 307
 308     5.times do |n|
 309       @ts.write([:req, 2])
 310     end
 311
 312     assert_equal(10, thread_join(taker))
 313     tuple = @ts.take([:ans, nil])
 314     assert_equal(10, tuple[1])
 315     assert_equal([], @ts.read_all([nil, nil]))
 316   end
 317
 318   def test_core_03_notify
 319     notify1 = @ts.notify(nil, [:req, Integer])
 320     notify2 = @ts.notify(nil, [:ans, Integer], 5)
 321     notify3 = @ts.notify(nil, {"message"=>String, "name"=>String}, 5)
 322
 323     @ts.write({"message"=>"first", "name"=>"3"}, 3)
 324     @ts.write({"message"=>"second", "name"=>"1"}, 1)
 325     @ts.write({"message"=>"third", "name"=>"0"})
 326     @ts.take({"message"=>"third", "name"=>"0"})
 327
 328     listener1 = Thread.new do
 329       lv = 0
 330       n = 0
 331       notify1.each  do |ev, tuple|
 332         n += 1
 333         if ev == 'write'
 334           lv = lv + 1
 335         elsif ev == 'take'
 336           lv = lv - 1
 337         else
 338           break
 339         end
 340         assert(lv >= 0)
 341         assert_equal([:req, 2], tuple)
 342       end
 343       [lv, n]
 344     end
 345
 346     listener2 = Thread.new do
 347       result = nil
 348       lv = 0
 349       n = 0
 350       notify2.each  do |ev|
 351         n += 1
 352         if ev[0] == 'write'
 353           lv = lv + 1
 354         elsif ev[0] == 'take'
 355           lv = lv - 1
 356         elsif ev[0] == 'close'
 357           result = [lv, n]
 358         else
 359           break
 360         end
 361         assert(lv >= 0)
 362         assert_equal([:ans, 10], ev[1])
 363       end
 364       result
 365     end
 366
 367     taker = Thread.new do
 368       s = 0
 369       while true
 370         begin
 371           tuple = @ts.take([:req, Integer], 1)
 372           s += tuple[1]
 373         rescue Rinda::RequestExpiredError
 374           break
 375         end
 376       end
 377       @ts.write([:ans, s])
 378       s
 379     end
 380
 381     5.times do |n|
 382       @ts.write([:req, 2])
 383     end
 384
 385     @ts.take({"message"=>"first", "name"=>"3"})
 386
 387     sleep(4)
 388     assert_equal(10, thread_join(taker))
 389     tuple = @ts.take([:ans, nil])
 390     assert_equal(10, tuple[1])
 391     assert_equal([], @ts.read_all([nil, nil]))
 392
 393     notify1.cancel
 394     sleep(3) # notify2 expired
 395
 396     assert_equal([0, 11], thread_join(listener1))
 397     assert_equal([0, 3], thread_join(listener2))
 398
 399     ary = []
 400     ary.push(["write", {"message"=>"first", "name"=>"3"}])
 401     ary.push(["write", {"message"=>"second", "name"=>"1"}])
 402     ary.push(["write", {"message"=>"third", "name"=>"0"}])
 403     ary.push(["take", {"message"=>"third", "name"=>"0"}])
 404     ary.push(["take", {"message"=>"first", "name"=>"3"}])
 405     ary.push(["delete", {"message"=>"second", "name"=>"1"}])
 406     ary.push(["close"])
 407
 408     notify3.each do |ev|
 409       assert_equal(ary.shift, ev)
 410     end
 411     assert_equal([], ary)
 412   end
 413
 414   def test_cancel_01
 415     entry = @ts.write([:removeme, 1])
 416     assert_equal([[:removeme, 1]], @ts.read_all([nil, nil]))
 417     entry.cancel
 418     assert_equal([], @ts.read_all([nil, nil]))
 419
 420     template = nil
 421     taker = Thread.new do
 422       @ts.take([:take, nil], 10) do |t|
 423         template = t
 424         Thread.new do
 425           template.cancel
 426         end
 427       end
 428     end
 429
 430     sleep(2)
 431
 432     assert_raises(Rinda::RequestCanceledError) do
 433       assert_nil(thread_join(taker))
 434     end
 435
 436     assert(template.canceled?)
 437
 438     @ts.write([:take, 1])
 439
 440     assert_equal([[:take, 1]], @ts.read_all([nil, nil]))
 441   end
 442
 443   def test_cancel_02
 444     entry = @ts.write([:removeme, 1])
 445     assert_equal([[:removeme, 1]], @ts.read_all([nil, nil]))
 446     entry.cancel
 447     assert_equal([], @ts.read_all([nil, nil]))
 448
 449     template = nil
 450     reader = Thread.new do
 451       @ts.read([:take, nil], 10) do |t|
 452         template = t
 453         Thread.new do
 454           template.cancel
 455         end
 456       end
 457     end
 458
 459     sleep(2)
 460
 461     assert_raises(Rinda::RequestCanceledError) do
 462       assert_nil(thread_join(reader))
 463     end
 464
 465     assert(template.canceled?)
 466
 467     @ts.write([:take, 1])
 468
 469     assert_equal([[:take, 1]], @ts.read_all([nil, nil]))
 470   end
 471
 472   class SimpleRenewer
 473     def initialize(sec, n = 1)
 474       @sec = sec
 475       @n = n
 476     end
 477
 478     def renew
 479       return -1 if @n <= 0
 480       @n -= 1
 481       return @sec
 482     end
 483   end
 484
 485   def test_00_renewer
 486     tuple = Rinda::TupleEntry.new([1,2,3], true)
 487     assert(!tuple.canceled?)
 488     assert(tuple.expired?)
 489     assert(!tuple.alive?)
 490
 491     tuple = Rinda::TupleEntry.new([1,2,3], 1)
 492     assert(!tuple.canceled?)
 493     assert(!tuple.expired?)
 494     assert(tuple.alive?)
 495     sleep(2)
 496     assert(tuple.expired?)
 497     assert(!tuple.alive?)
 498
 499     @renewer = SimpleRenewer.new(1,2)
 500     tuple = Rinda::TupleEntry.new([1,2,3], @renewer)
 501     assert(!tuple.canceled?)
 502     assert(!tuple.expired?)
 503     assert(tuple.alive?)
 504     sleep(1)
 505     assert(!tuple.canceled?)
 506     assert(!tuple.expired?)
 507     assert(tuple.alive?)
 508     sleep(2)
 509     assert(tuple.expired?)
 510     assert(!tuple.alive?)
 511   end
 512 end
 513
 514 class TupleSpaceTest < Test::Unit::TestCase
 515   include TupleSpaceTestModule
 516
 517   def setup
 518     ThreadGroup.new.add(Thread.current)
 519     @ts = Rinda::TupleSpace.new(1)
 520   end
 521 end
 522
 523 class TupleSpaceProxyTest < Test::Unit::TestCase
 524   include TupleSpaceTestModule
 525
 526   def setup
 527     ThreadGroup.new.add(Thread.current)
 528     @ts_base = Rinda::TupleSpace.new(1)
 529     @ts = Rinda::TupleSpaceProxy.new(@ts_base)
 530   end
 531
 532   def test_remote_array_and_hash
 533     @ts.write(DRbObject.new([1, 2, 3]))
 534     assert_equal([1, 2, 3], @ts.take([1, 2, 3], 0))
 535     @ts.write(DRbObject.new({'head' => 1, 'tail' => 2}))
 536     assert_equal({'head' => 1, 'tail' => 2},
 537                  @ts.take({'head' => 1, 'tail' => 2}, 0))
 538   end
 539
 540   @server = DRb.primary_server || DRb.start_service
 541 end
 542
 543 end
 544