13 files changed, 238 insertions, 147 deletions

diff --git a/spec/ruby/core/fiber/alive_spec.rb b/spec/ruby/core/fiber/alive_spec.rb
index a1df582435..6fb1229d95 100644
--- a/spec/ruby/core/fiber/alive_spec.rb
+++ b/spec/ruby/core/fiber/alive_spec.rb
@@ -3,18 +3,18 @@ require_relative '../../spec_helper'
 describe "Fiber#alive?" do
   it "returns true for a Fiber that hasn't had #resume called" do
     fiber = Fiber.new { true }
-    fiber.alive?.should be_true
+    fiber.alive?.should == true
   end
 
   # FIXME: Better description?
   it "returns true for a Fiber that's yielded to the caller" do
     fiber = Fiber.new { Fiber.yield }
     fiber.resume
-    fiber.alive?.should be_true
+    fiber.alive?.should == true
   end
 
   it "returns true when called from its Fiber" do
-    fiber = Fiber.new { fiber.alive?.should be_true }
+    fiber = Fiber.new { fiber.alive?.should == true }
     fiber.resume
   end
 
@@ -28,17 +28,17 @@ describe "Fiber#alive?" do
   it "returns false for a Fiber that's dead" do
     fiber = Fiber.new { true }
     fiber.resume
-    -> { fiber.resume }.should raise_error(FiberError)
-    fiber.alive?.should be_false
+    -> { fiber.resume }.should.raise(FiberError)
+    fiber.alive?.should == false
   end
 
   it "always returns false for a dead Fiber" do
     fiber = Fiber.new { true }
     fiber.resume
-    -> { fiber.resume }.should raise_error(FiberError)
-    fiber.alive?.should be_false
-    -> { fiber.resume }.should raise_error(FiberError)
-    fiber.alive?.should be_false
-    fiber.alive?.should be_false
+    -> { fiber.resume }.should.raise(FiberError)
+    fiber.alive?.should == false
+    -> { fiber.resume }.should.raise(FiberError)
+    fiber.alive?.should == false
+    fiber.alive?.should == false
   end
 end
diff --git a/spec/ruby/core/fiber/current_spec.rb b/spec/ruby/core/fiber/current_spec.rb
index b93df77a89..cc5c9117b6 100644
--- a/spec/ruby/core/fiber/current_spec.rb
+++ b/spec/ruby/core/fiber/current_spec.rb
@@ -3,20 +3,20 @@ require_relative '../../spec_helper'
 describe "Fiber.current" do
   it "returns the root Fiber when called outside of a Fiber" do
     root = Fiber.current
-    root.should be_an_instance_of(Fiber)
+    root.should.instance_of?(Fiber)
     # We can always transfer to the root Fiber; it will never die
     5.times do
-      root.transfer.should be_nil
-      root.alive?.should be_true
+      root.transfer.should == nil
+      root.alive?.should == true
     end
   end
 
   it "returns the current Fiber when called from a Fiber" do
     fiber = Fiber.new do
       this = Fiber.current
-      this.should be_an_instance_of(Fiber)
+      this.should.instance_of?(Fiber)
       this.should == fiber
-      this.alive?.should be_true
+      this.alive?.should == true
     end
     fiber.resume
   end
@@ -26,9 +26,9 @@ describe "Fiber.current" do
     fiber = Fiber.new do
       states << :fiber
       this = Fiber.current
-      this.should be_an_instance_of(Fiber)
+      this.should.instance_of?(Fiber)
       this.should == fiber
-      this.alive?.should be_true
+      this.alive?.should == true
     end
 
     fiber2 = Fiber.new do
diff --git a/spec/ruby/core/fiber/fixtures/scheduler.rb b/spec/ruby/core/fiber/fixtures/scheduler.rb
new file mode 100644
index 0000000000..16bd2f6b44
--- /dev/null
+++ b/spec/ruby/core/fiber/fixtures/scheduler.rb
@@ -0,0 +1,35 @@
+module FiberSpecs
+
+  class LoggingScheduler
+    attr_reader :events
+    def initialize
+      @events = []
+    end
+
+    def block(*args)
+      @events << { event: :block, fiber: Fiber.current, args: args }
+      Fiber.yield
+    end
+
+    def io_wait(*args)
+      @events << { event: :io_wait, fiber: Fiber.current, args: args }
+      Fiber.yield
+    end
+
+    def kernel_sleep(*args)
+      @events << { event: :kernel_sleep, fiber: Fiber.current, args: args }
+      Fiber.yield
+    end
+
+    def unblock(*args)
+      @events << { event: :unblock, fiber: Fiber.current, args: args }
+      Fiber.yield
+    end
+
+    def fiber_interrupt(*args)
+      @events << { event: :fiber_interrupt, fiber: Fiber.current, args: args }
+      Fiber.yield
+    end
+  end
+
+end
diff --git a/spec/ruby/core/fiber/kill_spec.rb b/spec/ruby/core/fiber/kill_spec.rb
index 2f4c499280..abf23ff176 100644
--- a/spec/ruby/core/fiber/kill_spec.rb
+++ b/spec/ruby/core/fiber/kill_spec.rb
@@ -2,89 +2,87 @@ require_relative '../../spec_helper'
 require_relative 'fixtures/classes'
 require_relative '../../shared/kernel/raise'
 
-ruby_version_is "3.3" do
-  describe "Fiber#kill" do
-    it "kills a non-resumed fiber" do
-      fiber = Fiber.new{}
+describe "Fiber#kill" do
+  it "kills a non-resumed fiber" do
+    fiber = Fiber.new{}
 
-      fiber.alive?.should == true
+    fiber.alive?.should == true
 
-      fiber.kill
-      fiber.alive?.should == false
-    end
-
-    it "kills a resumed fiber" do
-      fiber = Fiber.new{while true; Fiber.yield; end}
-      fiber.resume
-
-      fiber.alive?.should == true
+    fiber.kill
+    fiber.alive?.should == false
+  end
 
-      fiber.kill
-      fiber.alive?.should == false
-    end
+  it "kills a resumed fiber" do
+    fiber = Fiber.new{while true; Fiber.yield; end}
+    fiber.resume
 
-    it "can kill itself" do
-      fiber = Fiber.new do
-        Fiber.current.kill
-      end
+    fiber.alive?.should == true
 
-      fiber.alive?.should == true
+    fiber.kill
+    fiber.alive?.should == false
+  end
 
-      fiber.resume
-      fiber.alive?.should == false
+  it "can kill itself" do
+    fiber = Fiber.new do
+      Fiber.current.kill
     end
 
-    it "kills a resumed fiber from a child" do
-      parent = Fiber.new do
-        child = Fiber.new do
-          parent.kill
-          parent.alive?.should == true
-        end
+    fiber.alive?.should == true
+
+    fiber.resume
+    fiber.alive?.should == false
+  end
 
-        child.resume
+  it "kills a resumed fiber from a child" do
+    parent = Fiber.new do
+      child = Fiber.new do
+        parent.kill
+        parent.alive?.should == true
       end
 
-      parent.resume
-      parent.alive?.should == false
+      child.resume
     end
 
-    it "executes the ensure block" do
-      ensure_executed = false
+    parent.resume
+    parent.alive?.should == false
+  end
 
-      fiber = Fiber.new do
-        while true; Fiber.yield; end
-      ensure
-        ensure_executed = true
-      end
+  it "executes the ensure block" do
+    ensure_executed = false
 
-      fiber.resume
-      fiber.kill
-      ensure_executed.should == true
+    fiber = Fiber.new do
+      while true; Fiber.yield; end
+    ensure
+      ensure_executed = true
     end
 
-    it "does not execute rescue block" do
-      rescue_executed = false
+    fiber.resume
+    fiber.kill
+    ensure_executed.should == true
+  end
 
-      fiber = Fiber.new do
-        while true; Fiber.yield; end
-      rescue Exception
-        rescue_executed = true
-      end
+  it "does not execute rescue block" do
+    rescue_executed = false
 
-      fiber.resume
-      fiber.kill
-      rescue_executed.should == false
+    fiber = Fiber.new do
+      while true; Fiber.yield; end
+    rescue Exception
+      rescue_executed = true
     end
 
-    it "repeatedly kills a fiber" do
-      fiber = Fiber.new do
-        while true; Fiber.yield; end
-      ensure
-        while true; Fiber.yield; end
-      end
+    fiber.resume
+    fiber.kill
+    rescue_executed.should == false
+  end
 
-      fiber.kill
-      fiber.alive?.should == false
+  it "repeatedly kills a fiber" do
+    fiber = Fiber.new do
+      while true; Fiber.yield; end
+    ensure
+      while true; Fiber.yield; end
     end
+
+    fiber.kill
+    fiber.alive?.should == false
   end
 end
diff --git a/spec/ruby/core/fiber/new_spec.rb b/spec/ruby/core/fiber/new_spec.rb
index b43c1386be..d31167496d 100644
--- a/spec/ruby/core/fiber/new_spec.rb
+++ b/spec/ruby/core/fiber/new_spec.rb
@@ -4,7 +4,7 @@ describe "Fiber.new" do
   it "creates a fiber from the given block" do
     fiber = Fiber.new {}
     fiber.resume
-    fiber.should be_an_instance_of(Fiber)
+    fiber.should.instance_of?(Fiber)
   end
 
   it "creates a fiber from a subclass" do
@@ -12,17 +12,17 @@ describe "Fiber.new" do
     end
     fiber = MyFiber.new {}
     fiber.resume
-    fiber.should be_an_instance_of(MyFiber)
+    fiber.should.instance_of?(MyFiber)
   end
 
   it "raises an ArgumentError if called without a block" do
-    -> { Fiber.new }.should raise_error(ArgumentError)
+    -> { Fiber.new }.should.raise(ArgumentError)
   end
 
   it "does not invoke the block" do
     invoked = false
     fiber = Fiber.new { invoked = true }
-    invoked.should be_false
+    invoked.should == false
     fiber.resume
   end
 
diff --git a/spec/ruby/core/fiber/raise_spec.rb b/spec/ruby/core/fiber/raise_spec.rb
index 896f760290..107e5bd4ce 100644
--- a/spec/ruby/core/fiber/raise_spec.rb
+++ b/spec/ruby/core/fiber/raise_spec.rb
@@ -3,57 +3,62 @@ require_relative 'fixtures/classes'
 require_relative '../../shared/kernel/raise'
 
 describe "Fiber#raise" do
+  it "is a public method" do
+    Fiber.public_instance_methods.should.include?(:raise)
+  end
+
   it_behaves_like :kernel_raise, :raise, FiberSpecs::NewFiberToRaise
   it_behaves_like :kernel_raise_across_contexts, :raise, FiberSpecs::NewFiberToRaise
-end
+  ruby_version_is "4.0" do
+    it_behaves_like :kernel_raise_with_cause, :raise, FiberSpecs::NewFiberToRaise
+  end
 
-describe "Fiber#raise" do
   it 'raises RuntimeError by default' do
-    -> { FiberSpecs::NewFiberToRaise.raise }.should raise_error(RuntimeError)
+    -> { FiberSpecs::NewFiberToRaise.raise }.should.raise(RuntimeError)
   end
 
   it "raises FiberError if Fiber is not born" do
     fiber = Fiber.new { true }
-    -> { fiber.raise }.should raise_error(FiberError, "cannot raise exception on unborn fiber")
+    -> { fiber.raise }.should.raise(FiberError, "cannot raise exception on unborn fiber")
   end
 
   it "raises FiberError if Fiber is dead" do
     fiber = Fiber.new { true }
     fiber.resume
-    -> { fiber.raise }.should raise_error(FiberError, /dead fiber called|attempt to resume a terminated fiber/)
+    -> { fiber.raise }.should.raise(FiberError, /dead fiber called|attempt to resume a terminated fiber/)
   end
 
   it 'accepts error class' do
-    -> { FiberSpecs::NewFiberToRaise.raise FiberSpecs::CustomError }.should raise_error(FiberSpecs::CustomError)
+    -> { FiberSpecs::NewFiberToRaise.raise FiberSpecs::CustomError }.should.raise(FiberSpecs::CustomError)
   end
 
   it 'accepts error message' do
-    -> { FiberSpecs::NewFiberToRaise.raise "error message" }.should raise_error(RuntimeError, "error message")
+    -> { FiberSpecs::NewFiberToRaise.raise "error message" }.should.raise(RuntimeError, "error message")
   end
 
   it 'does not accept array of backtrace information only' do
-    -> { FiberSpecs::NewFiberToRaise.raise ['foo'] }.should raise_error(TypeError)
+    -> { FiberSpecs::NewFiberToRaise.raise ['foo'] }.should.raise(TypeError)
   end
 
   it 'does not accept integer' do
-    -> { FiberSpecs::NewFiberToRaise.raise 100 }.should raise_error(TypeError)
+    -> { FiberSpecs::NewFiberToRaise.raise 100 }.should.raise(TypeError)
   end
 
   it 'accepts error class with error message' do
-    -> { FiberSpecs::NewFiberToRaise.raise FiberSpecs::CustomError, 'test error' }.should raise_error(FiberSpecs::CustomError, 'test error')
+    -> { FiberSpecs::NewFiberToRaise.raise FiberSpecs::CustomError, 'test error' }.should.raise(FiberSpecs::CustomError, 'test error')
   end
 
   it 'accepts error class with error message and backtrace information' do
     -> {
       FiberSpecs::NewFiberToRaise.raise FiberSpecs::CustomError, 'test error', ['foo', 'boo']
-    }.should raise_error(FiberSpecs::CustomError) { |e|
+    }.should.raise(FiberSpecs::CustomError) { |e|
       e.message.should == 'test error'
       e.backtrace.should == ['foo', 'boo']
     }
   end
 
   it 'does not accept only error message and backtrace information' do
-    -> { FiberSpecs::NewFiberToRaise.raise 'test error', ['foo', 'boo'] }.should raise_error(TypeError)
+    -> { FiberSpecs::NewFiberToRaise.raise 'test error', ['foo', 'boo'] }.should.raise(TypeError)
   end
 
   it "raises a FiberError if invoked from a different Thread" do
@@ -62,15 +67,15 @@ describe "Fiber#raise" do
     Thread.new do
       -> {
         fiber.raise
-      }.should raise_error(FiberError, "fiber called across threads")
+      }.should.raise(FiberError, "fiber called across threads")
     end.join
   end
 
   it "kills Fiber" do
     fiber = Fiber.new { Fiber.yield :first; :second }
     fiber.resume
-    -> { fiber.raise }.should raise_error
-    -> { fiber.resume }.should raise_error(FiberError, /dead fiber called|attempt to resume a terminated fiber/)
+    -> { fiber.raise }.should.raise
+    -> { fiber.resume }.should.raise(FiberError, /dead fiber called|attempt to resume a terminated fiber/)
   end
 
   it "returns to calling fiber after raise" do
@@ -102,13 +107,13 @@ describe "Fiber#raise" do
 
       -> do
         f2.raise(RuntimeError, "Expected error")
-      end.should raise_error(RuntimeError, "Expected error")
+      end.should.raise(RuntimeError, "Expected error")
     end
 
     it "raises on itself" do
       -> do
         Fiber.current.raise(RuntimeError, "Expected error")
-      end.should raise_error(RuntimeError, "Expected error")
+      end.should.raise(RuntimeError, "Expected error")
     end
 
     it "should raise on parent fiber" do
@@ -123,17 +128,14 @@ describe "Fiber#raise" do
 
       -> do
         f2.resume
-      end.should raise_error(RuntimeError, "Expected error")
+      end.should.raise(RuntimeError, "Expected error")
     end
   end
-end
 
-
-describe "Fiber#raise" do
   it "transfers and raises on a transferring fiber" do
     root = Fiber.current
     fiber = Fiber.new { root.transfer }
     fiber.transfer
-    -> { fiber.raise "msg" }.should raise_error(RuntimeError, "msg")
+    -> { fiber.raise "msg" }.should.raise(RuntimeError, "msg")
   end
 end
diff --git a/spec/ruby/core/fiber/resume_spec.rb b/spec/ruby/core/fiber/resume_spec.rb
index 4b20f4b4bf..e183cc10d9 100644
--- a/spec/ruby/core/fiber/resume_spec.rb
+++ b/spec/ruby/core/fiber/resume_spec.rb
@@ -30,7 +30,7 @@ describe "Fiber#resume" do
 
   it "raises a FiberError if the Fiber tries to resume itself" do
     fiber = Fiber.new { fiber.resume }
-    -> { fiber.resume }.should raise_error(FiberError, /current fiber/)
+    -> { fiber.resume }.should.raise(FiberError, /current fiber/)
   end
 
   it "returns control to the calling Fiber if called from one" do
@@ -78,6 +78,6 @@ describe "Fiber#resume" do
   it "raises a FiberError if the Fiber attempts to resume a resuming fiber" do
     root_fiber = Fiber.current
     fiber1 = Fiber.new { root_fiber.resume }
-    -> { fiber1.resume }.should raise_error(FiberError, /attempt to resume a resuming fiber/)
+    -> { fiber1.resume }.should.raise(FiberError, /attempt to resume a resuming fiber/)
   end
 end
diff --git a/spec/ruby/core/fiber/scheduler_spec.rb b/spec/ruby/core/fiber/scheduler_spec.rb
new file mode 100644
index 0000000000..2a517ba93b
--- /dev/null
+++ b/spec/ruby/core/fiber/scheduler_spec.rb
@@ -0,0 +1,5 @@
+require_relative '../../spec_helper'
+
+describe "Fiber.scheduler" do
+  it "is already tested in Fiber.set_scheduler"
+end
diff --git a/spec/ruby/core/fiber/set_scheduler_spec.rb b/spec/ruby/core/fiber/set_scheduler_spec.rb
new file mode 100644
index 0000000000..b34aff8734
--- /dev/null
+++ b/spec/ruby/core/fiber/set_scheduler_spec.rb
@@ -0,0 +1,55 @@
+require_relative '../../spec_helper'
+
+require "fiber"
+
+describe "Fiber.scheduler" do
+  it "validates the scheduler for required methods" do
+    required_methods = [:block, :unblock, :kernel_sleep, :io_wait]
+    required_methods.each do |missing_method|
+      scheduler = Object.new
+      required_methods.difference([missing_method]).each do |method|
+        scheduler.define_singleton_method(method) {}
+      end
+      -> {
+        suppress_warning { Fiber.set_scheduler(scheduler) }
+      }.should.raise(ArgumentError, /Scheduler must implement ##{missing_method}/)
+    end
+  end
+
+  it "can set and get the scheduler" do
+    required_methods = [:block, :unblock, :kernel_sleep, :io_wait]
+    scheduler = Object.new
+    required_methods.each do |method|
+      scheduler.define_singleton_method(method) {}
+    end
+    suppress_warning { Fiber.set_scheduler(scheduler) }
+    Fiber.scheduler.should == scheduler
+  end
+
+  it "returns the scheduler after setting it" do
+    required_methods = [:block, :unblock, :kernel_sleep, :io_wait]
+    scheduler = Object.new
+    required_methods.each do |method|
+      scheduler.define_singleton_method(method) {}
+    end
+    result = suppress_warning { Fiber.set_scheduler(scheduler) }
+    result.should == scheduler
+  end
+
+  it "can remove the scheduler" do
+    required_methods = [:block, :unblock, :kernel_sleep, :io_wait]
+    scheduler = Object.new
+    required_methods.each do |method|
+      scheduler.define_singleton_method(method) {}
+    end
+    suppress_warning { Fiber.set_scheduler(scheduler) }
+    Fiber.set_scheduler(nil)
+    Fiber.scheduler.should == nil
+  end
+
+  it "can assign a nil scheduler multiple times" do
+    Fiber.set_scheduler(nil)
+    Fiber.set_scheduler(nil)
+    Fiber.scheduler.should == nil
+  end
+end
diff --git a/spec/ruby/core/fiber/shared/resume.rb b/spec/ruby/core/fiber/shared/resume.rb
index 5ee27d1d24..ff4bb72c73 100644
--- a/spec/ruby/core/fiber/shared/resume.rb
+++ b/spec/ruby/core/fiber/shared/resume.rb
@@ -9,7 +9,7 @@ describe :fiber_resume, shared: true do
     Thread.new do
       -> {
         fiber.send(@method)
-      }.should raise_error(FiberError)
+      }.should.raise(FiberError)
     end.join
 
     # Check the Fiber can still be used
@@ -20,12 +20,12 @@ describe :fiber_resume, shared: true do
     invoked = false
     fiber = Fiber.new { invoked = true }
     fiber.send(@method)
-    invoked.should be_true
+    invoked.should == true
   end
 
   it "returns the last value encountered on first invocation" do
     fiber = Fiber.new { 1+1; true }
-    fiber.send(@method).should be_true
+    fiber.send(@method).should == true
   end
 
   it "runs until the end of the block" do
@@ -37,22 +37,22 @@ describe :fiber_resume, shared: true do
 
   it "accepts any number of arguments" do
     fiber = Fiber.new { |a| }
-    -> { fiber.send(@method, *(1..10).to_a) }.should_not raise_error
+    -> { fiber.send(@method, *(1..10).to_a) }.should_not.raise
   end
 
   it "raises a FiberError if the Fiber is dead" do
     fiber = Fiber.new { true }
     fiber.send(@method)
-    -> { fiber.send(@method) }.should raise_error(FiberError)
+    -> { fiber.send(@method) }.should.raise(FiberError)
   end
 
   it "raises a LocalJumpError if the block includes a return statement" do
     fiber = Fiber.new { return; }
-    -> { fiber.send(@method) }.should raise_error(LocalJumpError)
+    -> { fiber.send(@method) }.should.raise(LocalJumpError)
   end
 
   it "raises a LocalJumpError if the block includes a break statement" do
     fiber = Fiber.new { break; }
-    -> { fiber.send(@method) }.should raise_error(LocalJumpError)
+    -> { fiber.send(@method) }.should.raise(LocalJumpError)
   end
 end
diff --git a/spec/ruby/core/fiber/storage_spec.rb b/spec/ruby/core/fiber/storage_spec.rb
index 015caaf3bb..a3f6bf9cad 100644
--- a/spec/ruby/core/fiber/storage_spec.rb
+++ b/spec/ruby/core/fiber/storage_spec.rb
@@ -19,15 +19,15 @@ describe "Fiber.new(storage:)" do
   end
 
   it "cannot create a fiber with non-hash storage" do
-    -> { Fiber.new(storage: 42) {} }.should raise_error(TypeError)
+    -> { Fiber.new(storage: 42) {} }.should.raise(TypeError)
   end
 
   it "cannot create a fiber with a frozen hash as storage" do
-    -> { Fiber.new(storage: {life: 43}.freeze) {} }.should raise_error(FrozenError)
+    -> { Fiber.new(storage: {life: 43}.freeze) {} }.should.raise(FrozenError)
   end
 
   it "cannot create a fiber with a storage hash with non-symbol keys" do
-    -> { Fiber.new(storage: {life: 43, Object.new => 44}) {} }.should raise_error(TypeError)
+    -> { Fiber.new(storage: {life: 43, Object.new => 44}) {} }.should.raise(TypeError)
   end
 end
 
@@ -36,7 +36,7 @@ describe "Fiber#storage" do
     f = Fiber.new(storage: {life: 42}) { nil }
     -> {
       f.storage
-    }.should raise_error(ArgumentError, /Fiber storage can only be accessed from the Fiber it belongs to/)
+    }.should.raise(ArgumentError, /Fiber storage can only be accessed from the Fiber it belongs to/)
   end
 end
 
@@ -59,15 +59,15 @@ describe "Fiber#storage=" do
   end
 
   it "can't set the storage of the fiber to non-hash" do
-    -> { Fiber.current.storage = 42 }.should raise_error(TypeError)
+    -> { Fiber.current.storage = 42 }.should.raise(TypeError)
   end
 
   it "can't set the storage of the fiber to a frozen hash" do
-    -> { Fiber.current.storage = {life: 43}.freeze }.should raise_error(FrozenError)
+    -> { Fiber.current.storage = {life: 43}.freeze }.should.raise(FrozenError)
   end
 
   it "can't set the storage of the fiber to a hash with non-symbol keys" do
-    -> { Fiber.current.storage = {life: 43, Object.new => 44} }.should raise_error(TypeError)
+    -> { Fiber.current.storage = {life: 43, Object.new => 44} }.should.raise(TypeError)
   end
 end
 
@@ -77,24 +77,22 @@ describe "Fiber.[]" do
   end
 
   it "returns nil if the key is not present in the storage of the current fiber" do
-    Fiber.new(storage: {life: 42}) { Fiber[:death] }.resume.should be_nil
+    Fiber.new(storage: {life: 42}) { Fiber[:death] }.resume.should == nil
   end
 
   it "returns nil if the current fiber has no storage" do
-    Fiber.new { Fiber[:life] }.resume.should be_nil
+    Fiber.new { Fiber[:life] }.resume.should == nil
   end
 
-  ruby_version_is "3.2.3" do
-    it "can use dynamically defined keys" do
-      key = :"#{self.class.name}#.#{self.object_id}"
-      Fiber.new { Fiber[key] = 42; Fiber[key] }.resume.should == 42
-    end
+  it "can use dynamically defined keys" do
+    key = :"#{self.class.name}#.#{self.object_id}"
+    Fiber.new { Fiber[key] = 42; Fiber[key] }.resume.should == 42
+  end
 
-    it "can't use invalid keys" do
-      invalid_keys = [Object.new, 12]
-      invalid_keys.each do |key|
-        -> { Fiber[key] }.should raise_error(TypeError)
-      end
+  it "can't use invalid keys" do
+    invalid_keys = [Object.new, 12]
+    invalid_keys.each do |key|
+      -> { Fiber[key] }.should.raise(TypeError)
     end
   end
 
@@ -120,7 +118,7 @@ describe "Fiber.[]" do
   it "does not call #to_sym on the key" do
     key = mock("key")
     key.should_not_receive(:to_sym)
-    -> { Fiber[key] }.should raise_error(TypeError)
+    -> { Fiber[key] }.should.raise(TypeError)
   end
 
   it "can access the storage of the parent fiber" do
@@ -131,7 +129,7 @@ describe "Fiber.[]" do
   end
 
   it "can't access the storage of the fiber with non-symbol keys" do
-    -> { Fiber[Object.new] }.should raise_error(TypeError)
+    -> { Fiber[Object.new] }.should.raise(TypeError)
   end
 end
 
@@ -158,16 +156,14 @@ describe "Fiber.[]=" do
   end
 
   it "can't access the storage of the fiber with non-symbol keys" do
-    -> { Fiber[Object.new] = 44 }.should raise_error(TypeError)
+    -> { Fiber[Object.new] = 44 }.should.raise(TypeError)
   end
 
-  ruby_version_is "3.3" do
-    it "deletes the fiber storage key when assigning nil" do
-      Fiber.new(storage: {life: 42}) {
-        Fiber[:life] = nil
-        Fiber.current.storage
-      }.resume.should == {}
-    end
+  it "deletes the fiber storage key when assigning nil" do
+    Fiber.new(storage: {life: 42}) {
+      Fiber[:life] = nil
+      Fiber.current.storage
+    }.resume.should == {}
   end
 end
 
diff --git a/spec/ruby/core/fiber/transfer_spec.rb b/spec/ruby/core/fiber/transfer_spec.rb
index 238721475d..d8737aeeb3 100644
--- a/spec/ruby/core/fiber/transfer_spec.rb
+++ b/spec/ruby/core/fiber/transfer_spec.rb
@@ -37,12 +37,12 @@ describe "Fiber#transfer" do
     fiber1 = Fiber.new { states << :fiber1 }
     fiber2 = Fiber.new { states << :fiber2_start; Fiber.yield fiber1.transfer; states << :fiber2_end}
     fiber2.resume.should == [:fiber2_start, :fiber1]
-    -> { fiber2.transfer }.should raise_error(FiberError)
+    -> { fiber2.transfer }.should.raise(FiberError)
   end
 
   it "raises a FiberError when transferring to a Fiber which resumes itself" do
     fiber = Fiber.new { fiber.resume }
-    -> { fiber.transfer }.should raise_error(FiberError)
+    -> { fiber.transfer }.should.raise(FiberError)
   end
 
   it "works if Fibers in different Threads each transfer to a Fiber in the same Thread" do
@@ -58,7 +58,7 @@ describe "Fiber#transfer" do
         end
         io_fiber.transfer(Fiber.current)
         value = Object.new
-        io_fiber.transfer(value).should equal value
+        io_fiber.transfer(value).should.equal? value
       end.join
     end
   end
diff --git a/spec/ruby/core/fiber/yield_spec.rb b/spec/ruby/core/fiber/yield_spec.rb
index b010912c87..12ec6ebcef 100644
--- a/spec/ruby/core/fiber/yield_spec.rb
+++ b/spec/ruby/core/fiber/yield_spec.rb
@@ -18,7 +18,7 @@ describe "Fiber.yield" do
 
   it "returns nil to the caller if given no arguments" do
     fiber = Fiber.new { true; Fiber.yield; true }
-    fiber.resume.should be_nil
+    fiber.resume.should == nil
     fiber.resume
   end
 
@@ -44,6 +44,6 @@ describe "Fiber.yield" do
   end
 
   it "raises a FiberError if called from the root Fiber" do
-    ->{ Fiber.yield }.should raise_error(FiberError)
+    ->{ Fiber.yield }.should.raise(FiberError)
   end
 end