Increase max waiting time in ReentrantReadWriteLock specs to avoid transients

Author: eregon

spec/concurrent/atomic/reentrant_read_write_lock_spec.rb

@@ -242,14 +242,14 @@ def wait_up_to(secs, &condition)
 in_thread{lock.acquire_read_lock;latch1.count_down;latch2.wait;lock.release_read_lock},
 in_thread{latch1.wait;lock.acquire_write_lock;good.value=true}
 ]
-wait_up_to(0.2){threads[3].status == 'sleep'}
+wait_up_to(0.5){threads[3].status == 'sleep'}
 # The last thread should be waiting to acquire a write lock now...
 expect(threads[3].status).toeql"sleep"
 expect(threads[3]).not_tohold(lock).for_write
 expect(good.value).tobefalse
 # Throw latch2 and the 3 readers will wake up and all release their read locks...
 latch2.count_down
-wait_up_to(0.2){good.value}
+wait_up_to(0.5){good.value}
 expect(threads[3]).tohold(lock).for_write
 expect(good.value).tobetrue
 end
@@ -265,7 +265,7 @@ def wait_up_to(secs, &condition)
 expect{Timeout.timeout(1){threads[0].join}}.not_toraise_error
 expect(threads[0]).tohold(lock).for_write
 expect(threads[1]).not_tohold(lock).for_write
-wait_up_to(0.2){threads[1].status == 'sleep'}
+wait_up_to(0.5){threads[1].status == 'sleep'}
 expect(threads[1].status).toeql"sleep"
 end
 
@@ -278,7 +278,7 @@ def wait_up_to(secs, &condition)
 expect{Timeout.timeout(1){threads[0].join}}.not_toraise_error
 expect(threads[0]).tohold(lock).for_read
 expect(threads[1]).not_tohold(lock).for_write
-wait_up_to(0.2){threads[1].status == 'sleep'}
+wait_up_to(0.5){threads[1].status == 'sleep'}
 expect(threads[1].status).toeql"sleep"
 end
 
@@ -341,15 +341,15 @@ def wait_up_to(secs, &condition)
 in_thread{latch1.wait;lock.acquire_read_lock;good.update{ |n| n+1}},
 in_thread{latch1.wait;lock.acquire_read_lock;good.update{ |n| n+1}}
 ]
-wait_up_to(0.2){threads[3].status == 'sleep'}
+wait_up_to(0.5){threads[3].status == 'sleep'}
 # The last 3 threads should be waiting to acquire read locks now...
 unlessConcurrent.on_jruby?# flaky on JRuby
 (1..3).each{ |n| expect(threads[n].status).toeql"sleep"}
 end
 (1..3).each{ |n| expect(threads[n]).not_tohold(lock).for_read}
 # Throw latch2 and the writer will wake up and release its write lock...
 latch2.count_down
-wait_up_to(0.2){good.value == 3}
+wait_up_to(0.5){good.value == 3}
 (1..3).each{ |n| expect(threads[n]).tohold(lock).for_read}
 end
 
@@ -360,15 +360,15 @@ def wait_up_to(secs, &condition)
 in_thread{lock.acquire_write_lock;latch1.count_down;latch2.wait;lock.release_write_lock},
 in_thread{latch1.wait;lock.acquire_write_lock;good.value=true},
 ]
-wait_up_to(0.2){threads[1].status == 'sleep'}
+wait_up_to(0.5){threads[1].status == 'sleep'}
 # The last thread should be waiting to acquire a write lock now...
 unlessConcurrent.on_jruby?# flaky on JRuby
 expect(threads[1].status).toeql"sleep"
 end
 expect(threads[1]).not_tohold(lock).for_write
 # Throw latch2 and the writer will wake up and release its write lock...
 latch2.count_down
-wait_up_to(0.2){good.value}
+wait_up_to(0.5){good.value}
 expect(threads[1]).tohold(lock).for_write
 end
 end