Update to ruby/spec@7de852d

3 files changed, 104 insertions, 119 deletions

diff --git a/spec/ruby/core/fiber/new_spec.rb b/spec/ruby/core/fiber/new_spec.rb
index 734db0682e..c2175cb612 100644
--- a/spec/ruby/core/fiber/new_spec.rb
+++ b/spec/ruby/core/fiber/new_spec.rb
@@ -1,41 +1,39 @@
 require_relative '../../spec_helper'
 
-with_feature :fiber do
-  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)
-    end
+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)
+  end
 
-    it "creates a fiber from a subclass" do
-      class MyFiber < Fiber
-      end
-      fiber = MyFiber.new {}
-      fiber.resume
-      fiber.should be_an_instance_of(MyFiber)
+  it "creates a fiber from a subclass" do
+    class MyFiber < Fiber
     end
+    fiber = MyFiber.new {}
+    fiber.resume
+    fiber.should be_an_instance_of(MyFiber)
+  end
 
-    it "raises an ArgumentError if called without a block" do
-      lambda { Fiber.new }.should raise_error(ArgumentError)
-    end
+  it "raises an ArgumentError if called without a block" do
+    lambda { Fiber.new }.should raise_error(ArgumentError)
+  end
 
-    it "does not invoke the block" do
-      invoked = false
-      fiber = Fiber.new { invoked = true }
-      invoked.should be_false
-      fiber.resume
-    end
+  it "does not invoke the block" do
+    invoked = false
+    fiber = Fiber.new { invoked = true }
+    invoked.should be_false
+    fiber.resume
+  end
 
-    it "closes over lexical environments" do
-      o = Object.new
-      def o.f
-        a = 1
-        f = Fiber.new { a = 2 }
-        f.resume
-        a
-      end
-      o.f.should == 2
+  it "closes over lexical environments" do
+    o = Object.new
+    def o.f
+      a = 1
+      f = Fiber.new { a = 2 }
+      f.resume
+      a
     end
+    o.f.should == 2
   end
 end
diff --git a/spec/ruby/core/fiber/resume_spec.rb b/spec/ruby/core/fiber/resume_spec.rb
index d05e62c455..97495c5059 100644
--- a/spec/ruby/core/fiber/resume_spec.rb
+++ b/spec/ruby/core/fiber/resume_spec.rb
@@ -1,59 +1,48 @@
 require_relative '../../spec_helper'
 require_relative '../../shared/fiber/resume'
 
-with_feature :fiber do
-  describe "Fiber#resume" do
-    it_behaves_like :fiber_resume, :resume
+describe "Fiber#resume" do
+  it_behaves_like :fiber_resume, :resume
+end
+
+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, /double resume/)
+  end
+
+  it "returns control to the calling Fiber if called from one" do
+    fiber1 = Fiber.new { :fiber1 }
+    fiber2 = Fiber.new { fiber1.resume; :fiber2 }
+    fiber2.resume.should == :fiber2
   end
 
-  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, /double resume/)
-    end
-
-    it "returns control to the calling Fiber if called from one" do
-      fiber1 = Fiber.new { :fiber1 }
-      fiber2 = Fiber.new { fiber1.resume; :fiber2 }
-      fiber2.resume.should == :fiber2
-    end
-
-    with_feature :fork do
-      # Redmine #595
-      it "executes the ensure clause" do
-        rd, wr = IO.pipe
-
-        pid = Kernel::fork do
-          rd.close
-          f = Fiber.new do
-            begin
-              Fiber.yield
-            ensure
-              wr.write "executed"
-            end
-          end
-
-          # The apparent issue is that when Fiber.yield executes, control
-          # "leaves" the "ensure block" and so the ensure clause should run. But
-          # control really does NOT leave the ensure block when Fiber.yield
-          # executes. It merely pauses there. To require ensure to run when a
-          # Fiber is suspended then makes ensure-in-a-Fiber-context different
-          # than ensure-in-a-Thread-context and this would be very confusing.
-          f.resume
-
-          # When we execute the second #resume call, the ensure block DOES exit,
-          # the ensure clause runs.
-          f.resume
-
-          exit 0
+  # Redmine #595
+  it "executes the ensure clause" do
+    code = <<-RUBY
+      f = Fiber.new do
+        begin
+          Fiber.yield
+        ensure
+          puts "ensure executed"
         end
+      end
 
-        wr.close
-        Process.waitpid pid
+      # The apparent issue is that when Fiber.yield executes, control
+      # "leaves" the "ensure block" and so the ensure clause should run. But
+      # control really does NOT leave the ensure block when Fiber.yield
+      # executes. It merely pauses there. To require ensure to run when a
+      # Fiber is suspended then makes ensure-in-a-Fiber-context different
+      # than ensure-in-a-Thread-context and this would be very confusing.
+      f.resume
 
-        rd.read.should == "executed"
-        rd.close
-      end
-    end
+      # When we execute the second #resume call, the ensure block DOES exit,
+      # the ensure clause runs.
+      f.resume
+
+      exit 0
+    RUBY
+
+    ruby_exe(code).should == "ensure executed\n"
   end
 end
diff --git a/spec/ruby/core/fiber/yield_spec.rb b/spec/ruby/core/fiber/yield_spec.rb
index d002b29cf6..4e241d5921 100644
--- a/spec/ruby/core/fiber/yield_spec.rb
+++ b/spec/ruby/core/fiber/yield_spec.rb
@@ -1,51 +1,49 @@
 require_relative '../../spec_helper'
 
-with_feature :fiber do
-  describe "Fiber.yield" do
-    it "passes control to the Fiber's caller" do
-      step = 0
-      fiber = Fiber.new { step = 1; Fiber.yield; step = 2; Fiber.yield; step = 3 }
-      fiber.resume
-      step.should == 1
-      fiber.resume
-      step.should == 2
-    end
-
-    it "returns its arguments to the caller" do
-      fiber = Fiber.new { true; Fiber.yield :glark; true }
-      fiber.resume.should == :glark
-      fiber.resume
-    end
+describe "Fiber.yield" do
+  it "passes control to the Fiber's caller" do
+    step = 0
+    fiber = Fiber.new { step = 1; Fiber.yield; step = 2; Fiber.yield; step = 3 }
+    fiber.resume
+    step.should == 1
+    fiber.resume
+    step.should == 2
+  end
 
-    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
-    end
+  it "returns its arguments to the caller" do
+    fiber = Fiber.new { true; Fiber.yield :glark; true }
+    fiber.resume.should == :glark
+    fiber.resume
+  end
 
-    it "returns to the Fiber the value of the #resume call that invoked it" do
-      fiber = Fiber.new { Fiber.yield.should == :caller }
-      fiber.resume
-      fiber.resume :caller
-    end
+  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
+  end
 
-    it "does not propagate or reraise a rescued exception" do
-      fiber = Fiber.new do
-        begin
-          raise "an error in a Fiber"
-        rescue
-          Fiber.yield :first
-        end
+  it "returns to the Fiber the value of the #resume call that invoked it" do
+    fiber = Fiber.new { Fiber.yield.should == :caller }
+    fiber.resume
+    fiber.resume :caller
+  end
 
-        :second
+  it "does not propagate or reraise a rescued exception" do
+    fiber = Fiber.new do
+      begin
+        raise "an error in a Fiber"
+      rescue
+        Fiber.yield :first
       end
 
-      fiber.resume.should == :first
-      fiber.resume.should == :second
+      :second
     end
 
-    it "raises a FiberError if called from the root Fiber" do
-      lambda{ Fiber.yield }.should raise_error(FiberError)
-    end
+    fiber.resume.should == :first
+    fiber.resume.should == :second
+  end
+
+  it "raises a FiberError if called from the root Fiber" do
+    lambda{ Fiber.yield }.should raise_error(FiberError)
   end
 end