fiber_scheduler_spec 0.9.0 → 0.10.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: bea63eb7f423a7ef93c852d5ffce145a2d05af9a6001a9e361c1c9e2cb28f3f2
-  data.tar.gz: 4f798d9b7d7957581589fb2548391bff36c036f9724b8f2a0a086c19398a0314
+  metadata.gz: ebf711718c86a2f4372dec616ab5e44b3c9c4bb6af812de8fec46b24ee640f11
+  data.tar.gz: 544329b6f114df44a59b6b385dec14a6e3d4ccf5f431027dcee14ada4d7a6357
 SHA512:
-  metadata.gz: f254954f399c78bcc69d8635de1c0df05d8e9ab953feb4667965b86a5e4d3b5be38dc4e33ab451cb2b730e403fe8f163e50af07eaa5f4789b2903e5fe3d035cd
-  data.tar.gz: 7545ee8ddc87eeb12677ea46f4cc8e788ad4392b5acdd5c51a854bfcce680cd2294fc3ef4b84a95bb2026a2936d7e517f9babf7e8ad2296a800194bed09b7eba
+  metadata.gz: 6b59f23041b1032595604310bd50689b16587d45c6710bb42639c2c2ffadab68dbf3222116732d4a0d995c651560213df2fc99c23d1d0aceec3e138546864f04
+  data.tar.gz: 5e58e1e3b7417d9a95b4b31f84a2cde308238dab9d9e28613e332fd5911501c1c9daaaa3cb1ec82dd25db78ef077d2b1d6d29ba753242566a2b8bae8d451972e

data/lib/fiber_scheduler_spec/address_resolve.rb

@@ -8,40 +8,42 @@ module FiberSchedulerSpec
 end
 
 RSpec.shared_examples FiberSchedulerSpec::AddressResolve do
-  include_context FiberSchedulerSpec::Context
-
-  context "Addrinfo.getaddrinfo" do
-    let(:order) { [] }
-
-    def operations
-      Fiber.schedule do
-        order << 1
-        Addrinfo.getaddrinfo("example.com", 80, :AF_INET, :STREAM)
-        order << 5
+  describe "#address_resolve" do
+    include_context FiberSchedulerSpec::Context
+
+    context "Addrinfo.getaddrinfo" do
+      let(:order) { [] }
+
+      def operations
+        Fiber.schedule do
+          order << 1
+          Addrinfo.getaddrinfo("example.com", 80, :AF_INET, :STREAM)
+          order << 5
+        end
+
+        order << 2
+
+        Fiber.schedule do
+          order << 3
+          Addrinfo.getaddrinfo("example.com", 80, :AF_INET, :STREAM)
+          order << 5
+        end
+        order << 4
       end
 
-      order << 2
+      it "calls #address_resolve" do
+        expect_any_instance_of(scheduler_class)
+          .to receive(:address_resolve).exactly(2).times
+          .and_call_original
 
-      Fiber.schedule do
-        order << 3
-        Addrinfo.getaddrinfo("example.com", 80, :AF_INET, :STREAM)
-        order << 5
+        setup
       end
-      order << 4
-    end
 
-    it "calls #address_resolve" do
-      expect_any_instance_of(scheduler_class)
-        .to receive(:address_resolve).exactly(2).times
-        .and_call_original
+      it "behaves async" do
+        setup
 
-      setup
-    end
-
-    it "behaves async" do
-      setup
-
-      expect(order).to eq [1, 2, 3, 4, 5, 5]
+        expect(order).to eq [1, 2, 3, 4, 5, 5]
+      end
     end
   end
 end

data/lib/fiber_scheduler_spec/block_unblock.rb

@@ -6,48 +6,50 @@ module FiberSchedulerSpec
 end
 
 RSpec.shared_examples FiberSchedulerSpec::BlockUnblock do
-  include_context FiberSchedulerSpec::Context
-
-  context "Addrinfo.getaddrinfo" do
-    let(:order) { [] }
-    let(:queue) { Thread::Queue.new }
-    let(:item) { "item" }
-    let(:popped_items) { [] }
-
-    def operations
-      Fiber.schedule do
-        order << 1
-        popped_items << queue.pop
-        order << 6
+  describe "#block #unblock" do
+    include_context FiberSchedulerSpec::Context
+
+    context "Addrinfo.getaddrinfo" do
+      let(:order) { [] }
+      let(:queue) { Thread::Queue.new }
+      let(:item) { "item" }
+      let(:popped_items) { [] }
+
+      def operations
+        Fiber.schedule do
+          order << 1
+          popped_items << queue.pop
+          order << 6
+        end
+
+        order << 2
+
+        Fiber.schedule do
+          order << 3
+          queue.push(item)
+          order << 4
+        end
+
+        order << 5
       end
 
-      order << 2
+      it "calls #block and #unblock" do
+        expect_any_instance_of(scheduler_class)
+          .to receive(:block).once
+          .and_call_original
+        expect_any_instance_of(scheduler_class)
+          .to receive(:unblock).once
+          .and_call_original
 
-      Fiber.schedule do
-        order << 3
-        queue.push(item)
-        order << 4
+        setup
       end
 
-      order << 5
-    end
-
-    it "calls #block and #unblock" do
-      expect_any_instance_of(scheduler_class)
-        .to receive(:block).once
-        .and_call_original
-      expect_any_instance_of(scheduler_class)
-        .to receive(:unblock).once
-        .and_call_original
-
-      setup
-    end
-
-    it "behaves async" do
-      setup
+      it "behaves async" do
+        setup
 
-      expect(popped_items).to contain_exactly(item)
-      expect(order).to eq (1..6).to_a
+        expect(popped_items).to contain_exactly(item)
+        expect(order).to eq (1..6).to_a
+      end
     end
   end
 end

data/lib/fiber_scheduler_spec/close.rb

@@ -7,22 +7,62 @@ module FiberSchedulerSpec
 end
 
 RSpec.shared_examples FiberSchedulerSpec::Close do
-  include_context FiberSchedulerSpec::Context
+  describe "#close" do
+    include_context FiberSchedulerSpec::Context
+
+    # TODO: should closing a scheduler also set Fiber.scheduler to nil?
+    context "without #run" do
+      let(:order) { [] }
+
+      def operations
+        Fiber.schedule do
+          order << 2
+        end
+        order << 1
+      end
+
+      # NOTE: this example does not use 'setup', #run should not be invoked
+      if method_defined?(:default_setup)
+        # skipping if user overrode setup
+        it "calls #close" do
+          expect(scheduler)
+            .to receive(:close).once
+            .and_call_original
 
-  # TODO: should closing a scheduler also set Fiber.scheduler to nil?
-  context "without #run" do
-    let(:order) { [] }
+          Thread.new do
+            Fiber.set_scheduler(scheduler)
 
-    def operations
-      Fiber.schedule do
-        order << 2
+            operations
+          end.join
+        end
+      end
+
+      it "behaves async" do
+        setup
+
+        expect(order).to contain_exactly(1, 2)
       end
-      order << 1
     end
 
-    # NOTE: this example does not use 'setup', #run should not be invoked
-    if method_defined?(:default_setup)
-      # skipping if user overrode setup
+    context "with #run" do
+      let(:order) { [] }
+
+      def operations
+        Fiber.schedule do
+          order << 2
+        end
+
+        order << 1
+        Fiber.scheduler.run
+        order << 3
+
+        Fiber.schedule do
+          order << 4
+        end
+
+        order << 5
+      end
+
       it "calls #close" do
         expect(scheduler)
           .to receive(:close).once
@@ -30,54 +70,16 @@ RSpec.shared_examples FiberSchedulerSpec::Close do
 
         Thread.new do
           Fiber.set_scheduler(scheduler)
-
           operations
+          scheduler.run
         end.join
       end
-    end
 
-    it "behaves async" do
-      setup
+      it "behaves async" do
+        setup
 
-      expect(order).to contain_exactly(1, 2)
-    end
-  end
-
-  context "with #run" do
-    let(:order) { [] }
-
-    def operations
-      Fiber.schedule do
-        order << 2
+        expect(order).to contain_exactly(1, 2, 3, 4, 5)
       end
-
-      order << 1
-      Fiber.scheduler.run
-      order << 3
-
-      Fiber.schedule do
-        order << 4
-      end
-
-      order << 5
-    end
-
-    it "calls #close" do
-      expect(scheduler)
-        .to receive(:close).once
-        .and_call_original
-
-      Thread.new do
-        Fiber.set_scheduler(scheduler)
-        operations
-        scheduler.run
-      end.join
-    end
-
-    it "behaves async" do
-      setup
-
-      expect(order).to contain_exactly(1, 2, 3, 4, 5)
     end
   end
 end

data/lib/fiber_scheduler_spec/fiber.rb

@@ -6,63 +6,65 @@ module FiberSchedulerSpec
 end
 
 RSpec.shared_examples FiberSchedulerSpec::Fiber do
-  include_context FiberSchedulerSpec::Context
+  describe "#fiber" do
+    include_context FiberSchedulerSpec::Context
 
-  shared_examples :examples do
-    let(:fibers) { [] }
-    let(:fiber) { fibers.first }
+    shared_examples :examples do
+      let(:fibers) { [] }
+      let(:fiber) { fibers.first }
 
-    it "calls #fiber" do
-      expect_any_instance_of(scheduler_class)
-        .to receive(:fiber).once
-        .and_call_original
+      it "calls #fiber" do
+        expect_any_instance_of(scheduler_class)
+          .to receive(:fiber).once
+          .and_call_original
 
-      setup
-    end
+        setup
+      end
 
-    it "creates a fiber" do
-      # Prevent GC running inbetween two ObjectSpace calls.
-      GC.disable
+      it "creates a fiber" do
+        # Prevent GC running inbetween two ObjectSpace calls.
+        GC.disable
 
-      before = ObjectSpace.each_object(Fiber).count
-      setup
-      after = ObjectSpace.each_object(Fiber).count
+        before = ObjectSpace.each_object(Fiber).count
+        setup
+        after = ObjectSpace.each_object(Fiber).count
 
-      # The 'after - before' is > 1 with some selectors.
-      expect(after - before).to be >= 1
-    ensure
-      GC.enable
-    end
+        # The 'after - before' is > 1 with some selectors.
+        expect(after - before).to be >= 1
+      ensure
+        GC.enable
+      end
 
-    it "creates a non-blocking fiber" do
-      setup
+      it "creates a non-blocking fiber" do
+        setup
 
-      expect(fiber).to be_a Fiber
-      expect(fiber).not_to be_blocking
+        expect(fiber).to be_a Fiber
+        expect(fiber).not_to be_blocking
+      end
     end
-  end
 
-  context "Fiber.schedule with an empty block" do
-    def operations
-      fibers << Fiber.schedule {}
+    context "Fiber.schedule with an empty block" do
+      def operations
+        fibers << Fiber.schedule {}
+      end
+
+      include_examples :examples
     end
 
-    include_examples :examples
-  end
+    context "Fiber.schedule with a non-blocking operation" do
+      def operations
+        fibers << Fiber.schedule { sleep 0 }
+      end
 
-  context "Fiber.schedule with a non-blocking operation" do
-    def operations
-      fibers << Fiber.schedule { sleep 0 }
+      include_examples :examples
     end
 
-    include_examples :examples
-  end
+    context "Fiber.schedule with a blocking operation" do
+      def operations
+        fibers << Fiber.schedule { "." }
+      end
 
-  context "Fiber.schedule with a blocking operation" do
-    def operations
-      fibers << Fiber.schedule { "." }
+      include_examples :examples
     end
-
-    include_examples :examples
   end
 end

data/lib/fiber_scheduler_spec/io_wait.rb

@@ -6,76 +6,78 @@ module FiberSchedulerSpec
 end
 
 RSpec.shared_examples FiberSchedulerSpec::IOWait do
-  include_context FiberSchedulerSpec::Context
-
-  context "UNIXSocket#wait_readable" do
-    context "without a timeout" do
-      let(:order) { [] }
-      let(:pair) { UNIXSocket.pair }
-      let(:reader) { pair.first }
-      let(:writer) { pair.last }
-
-      def operations
-        Fiber.schedule do
-          order << 1
-          reader.wait_readable
-          reader.close
-          order << 6
+  describe "#io_wait" do
+    include_context FiberSchedulerSpec::Context
+
+    context "UNIXSocket#wait_readable" do
+      context "without a timeout" do
+        let(:order) { [] }
+        let(:pair) { UNIXSocket.pair }
+        let(:reader) { pair.first }
+        let(:writer) { pair.last }
+
+        def operations
+          Fiber.schedule do
+            order << 1
+            reader.wait_readable
+            reader.close
+            order << 6
+          end
+
+          order << 2
+
+          Fiber.schedule do
+            order << 3
+            writer.write(".")
+            writer.close
+            order << 4
+          end
+          order << 5
         end
 
-        order << 2
+        it "behaves async" do
+          setup
 
-        Fiber.schedule do
-          order << 3
-          writer.write(".")
-          writer.close
-          order << 4
+          expect(order).to eq (1..6).to_a
         end
-        order << 5
-      end
-
-      it "behaves async" do
-        setup
 
-        expect(order).to eq (1..6).to_a
-      end
+        it "calls #io_wait" do
+          expect_any_instance_of(scheduler_class)
+            .to receive(:io_wait).once
+            .and_call_original
 
-      it "calls #io_wait" do
-        expect_any_instance_of(scheduler_class)
-          .to receive(:io_wait).once
-          .and_call_original
-
-        setup
+          setup
+        end
       end
-    end
 
-    context "with a timeout" do
-      let(:order) { [] }
-      let(:pair) { UNIXSocket.pair }
-      let(:reader) { pair.first }
-      let(:writer) { pair.last }
-
-      def operations
-        Fiber.schedule do
-          order << 1
-          reader.wait_readable(0.001)
-          order << 3
+      context "with a timeout" do
+        let(:order) { [] }
+        let(:pair) { UNIXSocket.pair }
+        let(:reader) { pair.first }
+        let(:writer) { pair.last }
+
+        def operations
+          Fiber.schedule do
+            order << 1
+            reader.wait_readable(0.001)
+            order << 3
+          end
+          order << 2
         end
-        order << 2
-      end
 
-      it "behaves async" do
-        setup
+        it "behaves async" do
+          setup
 
-        expect(order).to eq (1..3).to_a
-      end
+          expect(order).to eq (1..3).to_a
+        end
 
-      it "calls #io_wait" do
-        expect_any_instance_of(scheduler_class)
-          .to receive(:io_wait).once
-          .and_call_original
+        it "calls #io_wait" do
+          expect_any_instance_of(scheduler_class)
+            .to receive(:io_wait).once
+            .and_call_original
 
-        setup
+          setup
+        end
       end
     end
   end

data/lib/fiber_scheduler_spec/kernel_sleep.rb

@@ -6,91 +6,93 @@ module FiberSchedulerSpec
 end
 
 RSpec.shared_examples FiberSchedulerSpec::KernelSleep do
-  include_context FiberSchedulerSpec::Context
+  describe "#kernel_sleep" do
+    include_context FiberSchedulerSpec::Context
 
-  context "Kernel.sleep" do
-    let(:order) { [] }
-    let(:times) { [] }
-    let(:duration) { times[1] - times[0] }
+    context "Kernel.sleep" do
+      let(:order) { [] }
+      let(:times) { [] }
+      let(:duration) { times[1] - times[0] }
 
-    context "multiple sleep operations" do
-      let(:interval) { 0.1 }
+      context "multiple sleep operations" do
+        let(:interval) { 0.1 }
 
-      def operations
-        times << Process.clock_gettime(Process::CLOCK_MONOTONIC)
+        def operations
+          times << Process.clock_gettime(Process::CLOCK_MONOTONIC)
 
-        Fiber.schedule do
-          order << 1
-          sleep interval
-          order << 5
-        end
+          Fiber.schedule do
+            order << 1
+            sleep interval
+            order << 5
+          end
 
-        order << 2
+          order << 2
 
-        Fiber.schedule do
-          order << 3
-          sleep interval
-          order << 6
-        end
+          Fiber.schedule do
+            order << 3
+            sleep interval
+            order << 6
+          end
 
-        order << 4
-      end
+          order << 4
+        end
 
-      it "calls #kernel_sleep" do
-        expect_any_instance_of(scheduler_class)
-          .to receive(:kernel_sleep).exactly(2).times
-          .and_call_original
+        it "calls #kernel_sleep" do
+          expect_any_instance_of(scheduler_class)
+            .to receive(:kernel_sleep).exactly(2).times
+            .and_call_original
 
-        setup
-      end
+          setup
+        end
 
-      it "behaves async" do
-        setup
+        it "behaves async" do
+          setup
 
-        expect(order).to eq (1..6).to_a
-      end
+          expect(order).to eq (1..6).to_a
+        end
 
-      it "runs operations in parallel" do
-        setup
-        times << Process.clock_gettime(Process::CLOCK_MONOTONIC)
+        it "runs operations in parallel" do
+          setup
+          times << Process.clock_gettime(Process::CLOCK_MONOTONIC)
 
-        expect(duration).to be >= interval
-        expect(duration).to be < (interval * 1.2)
+          expect(duration).to be >= interval
+          expect(duration).to be < (interval * 1.2)
+        end
       end
-    end
-
-    context "sleep 0" do
-      def operations
-        times << Process.clock_gettime(Process::CLOCK_MONOTONIC)
 
-        Fiber.schedule do
-          order << 1
-          sleep 0
+      context "sleep 0" do
+        def operations
           times << Process.clock_gettime(Process::CLOCK_MONOTONIC)
-          order << 3
+
+          Fiber.schedule do
+            order << 1
+            sleep 0
+            times << Process.clock_gettime(Process::CLOCK_MONOTONIC)
+            order << 3
+          end
+          order << 2
         end
-        order << 2
-      end
 
-      it "calls #kernel_sleep" do
-        expect_any_instance_of(scheduler_class)
-          .to receive(:kernel_sleep).once
-          .and_call_original
+        it "calls #kernel_sleep" do
+          expect_any_instance_of(scheduler_class)
+            .to receive(:kernel_sleep).once
+            .and_call_original
 
-        setup
-      end
+          setup
+        end
 
-      it "behaves async" do
-        setup
+        it "behaves async" do
+          setup
 
-        expect(order).to eq (1..3).to_a
-      end
+          expect(order).to eq (1..3).to_a
+        end
 
-      it "runs the operation in no time" do
-        setup
+        it "runs the operation in no time" do
+          setup
 
-        # No sleeping was performed at all.
-        expect(duration).to be < 0.0005
+          # No sleeping was performed at all.
+          expect(duration).to be < 0.0005
+        end
       end
     end
   end

data/lib/fiber_scheduler_spec/nested_fiber_schedule.rb

@@ -0,0 +1,59 @@
+require_relative "context"
+
+module FiberSchedulerSpec
+  module NestedFiberSchedule
+  end
+end
+
+RSpec.shared_examples FiberSchedulerSpec::NestedFiberSchedule do
+  describe "nested Fiber.schedule" do
+    include_context FiberSchedulerSpec::Context
+
+    let(:order) { [] }
+
+    context "with blocking operations" do
+      context "Kernel.sleep" do
+        def operations
+          Fiber.schedule do
+            order << 1
+            sleep 0
+            order << 3
+
+            Fiber.schedule do
+              order << 4
+              sleep 0
+              order << 6
+            end
+            order << 5
+          end
+
+          order << 2
+        end
+
+        it "completes all scheduled fibers" do
+          setup
+
+          expect(order).to eq (1..6).to_a
+        end
+      end
+    end
+
+    context "without blocking operations" do
+      def operations
+        Fiber.schedule do
+          order << 1
+          Fiber.schedule do
+            order << 2
+          end
+          order << 3
+        end
+      end
+
+      it "completes all scheduled fibers" do
+        setup
+
+        expect(order).to eq (1..3).to_a
+      end
+    end
+  end
+end

data/lib/fiber_scheduler_spec/process_wait.rb

@@ -6,56 +6,58 @@ module FiberSchedulerSpec
 end
 
 RSpec.shared_examples FiberSchedulerSpec::ProcessWait do
-  include_context FiberSchedulerSpec::Context
-
-  context "Process.wait" do
-    let(:interval_short) { 0.09 }
-    let(:interval) { 0.1 }
-    let(:order) { [] }
-    let(:times) { [] }
-    let(:duration) { times[1] - times[0] }
-    def operations
-      times << Process.clock_gettime(Process::CLOCK_MONOTONIC)
-
-      Fiber.schedule do
-        order << 1
-        # This interval is shorter so we're certain it will finish before the
-        # other fiber.
-        Process.wait(spawn("sleep #{interval_short}"))
-        order << 5
+  describe "#process_wait" do
+    include_context FiberSchedulerSpec::Context
+
+    context "Process.wait" do
+      let(:interval_short) { 0.09 }
+      let(:interval) { 0.1 }
+      let(:order) { [] }
+      let(:times) { [] }
+      let(:duration) { times[1] - times[0] }
+      def operations
+        times << Process.clock_gettime(Process::CLOCK_MONOTONIC)
+
+        Fiber.schedule do
+          order << 1
+          # This interval is shorter so we're certain it will finish before the
+          # other fiber.
+          Process.wait(spawn("sleep #{interval_short}"))
+          order << 5
+        end
+
+        order << 2
+
+        Fiber.schedule do
+          order << 3
+          Process.wait(spawn("sleep #{interval}"))
+          order << 6
+        end
+
+        order << 4
       end
 
-      order << 2
+      it "calls #process_wait" do
+        expect_any_instance_of(scheduler_class)
+          .to receive(:process_wait).exactly(2).times
+          .and_call_original
 
-      Fiber.schedule do
-        order << 3
-        Process.wait(spawn("sleep #{interval}"))
-        order << 6
+        setup
       end
 
-      order << 4
-    end
-
-    it "calls #process_wait" do
-      expect_any_instance_of(scheduler_class)
-        .to receive(:process_wait).exactly(2).times
-        .and_call_original
-
-      setup
-    end
+      it "behaves async" do
+        setup
 
-    it "behaves async" do
-      setup
-
-      expect(order).to eq (1..6).to_a
-    end
+        expect(order).to eq (1..6).to_a
+      end
 
-    it "runs operations in parallel" do
-      setup
-      times << Process.clock_gettime(Process::CLOCK_MONOTONIC)
+      it "runs operations in parallel" do
+        setup
+        times << Process.clock_gettime(Process::CLOCK_MONOTONIC)
 
-      expect(duration).to be >= interval
-      expect(duration).to be < (interval * 1.5)
+        expect(duration).to be >= interval
+        expect(duration).to be < (interval * 1.5)
+      end
     end
   end
 end

data/lib/fiber_scheduler_spec/socket_io.rb

@@ -6,57 +6,59 @@ module FiberSchedulerSpec
 end
 
 RSpec.shared_examples FiberSchedulerSpec::SocketIO do
-  include_context FiberSchedulerSpec::Context
-
-  context "UNIXSocket.pair" do
-    let(:order) { [] }
-    let(:pair) { UNIXSocket.pair }
-    let(:reader) { pair.first }
-    let(:writer) { pair.last }
-    let(:messages) { [] }
-    let(:sent) { "ruby" }
-    let(:received) { messages.first }
-
-    def operations
-      Fiber.schedule do
-        order << 1
-        messages << reader.read(sent.size)
-        reader.close
-        order << 6
-      end
+  describe "socket #io_read #io_write" do
+    include_context FiberSchedulerSpec::Context
+
+    context "UNIXSocket.pair" do
+      let(:order) { [] }
+      let(:pair) { UNIXSocket.pair }
+      let(:reader) { pair.first }
+      let(:writer) { pair.last }
+      let(:messages) { [] }
+      let(:sent) { "ruby" }
+      let(:received) { messages.first }
+
+      def operations
+        Fiber.schedule do
+          order << 1
+          messages << reader.read(sent.size)
+          reader.close
+          order << 6
+        end
 
-      order << 2
+        order << 2
 
-      Fiber.schedule do
-        order << 3
-        writer.write(sent)
-        writer.close
-        order << 4
+        Fiber.schedule do
+          order << 3
+          writer.write(sent)
+          writer.close
+          order << 4
+        end
+        order << 5
       end
-      order << 5
-    end
 
-    it "calls #io_read and #io_write" do
-      expect_any_instance_of(scheduler_class)
-        .to receive(:io_read).once
-        .and_call_original
-      expect_any_instance_of(scheduler_class)
-        .to receive(:io_write).once
-        .and_call_original
+      it "calls #io_read and #io_write" do
+        expect_any_instance_of(scheduler_class)
+          .to receive(:io_read).once
+          .and_call_original
+        expect_any_instance_of(scheduler_class)
+          .to receive(:io_write).once
+          .and_call_original
 
-      setup
-    end
+        setup
+      end
 
-    it "writes and reads a message" do
-      setup
+      it "writes and reads a message" do
+        setup
 
-      expect(received).to eq sent
-    end
+        expect(received).to eq sent
+      end
 
-    it "behaves async" do
-      setup
+      it "behaves async" do
+        setup
 
-      expect(order).to eq (1..6).to_a
+        expect(order).to eq (1..6).to_a
+      end
     end
   end
 end

data/lib/fiber_scheduler_spec/timeout_after.rb

@@ -7,80 +7,82 @@ module FiberSchedulerSpec
 end
 
 RSpec.shared_examples FiberSchedulerSpec::TimeoutAfter do
-  include_context FiberSchedulerSpec::Context
-
-  context "Timeout.timeout" do
-    let(:order) { [] }
-    let(:times) { [] }
-    let(:duration) { times[1] - times[0] }
-    let(:sleep_duration) { 0.01 }
-
-    def operations
-      times << Process.clock_gettime(Process::CLOCK_MONOTONIC)
-      Fiber.schedule do
-        begin
-          order << 1
-          Timeout.timeout(timeout) do
-            order << 2
-            sleep sleep_duration
-            order << 4
+  describe "#timeout_after" do
+    include_context FiberSchedulerSpec::Context
+
+    context "Timeout.timeout" do
+      let(:order) { [] }
+      let(:times) { [] }
+      let(:duration) { times[1] - times[0] }
+      let(:sleep_duration) { 0.01 }
+
+      def operations
+        times << Process.clock_gettime(Process::CLOCK_MONOTONIC)
+        Fiber.schedule do
+          begin
+            order << 1
+            Timeout.timeout(timeout) do
+              order << 2
+              sleep sleep_duration
+              order << 4
+            end
+            order << 5
+          rescue Timeout::Error
+            order << 6
           end
-          order << 5
-        rescue Timeout::Error
-          order << 6
+          times << Process.clock_gettime(Process::CLOCK_MONOTONIC)
         end
-        times << Process.clock_gettime(Process::CLOCK_MONOTONIC)
+        order << 3
       end
-      order << 3
-    end
 
-    context "when the operation times out" do
-      let(:timeout) { 0.001 }
+      context "when the operation times out" do
+        let(:timeout) { 0.001 }
 
-      it "calls #timeout_after" do
-        expect_any_instance_of(scheduler_class)
-          .to receive(:timeout_after)
-          .and_call_original
+        it "calls #timeout_after" do
+          expect_any_instance_of(scheduler_class)
+            .to receive(:timeout_after)
+            .and_call_original
 
-        setup
-      end
+          setup
+        end
 
-      it "behaves async" do
-        setup
+        it "behaves async" do
+          setup
 
-        expect(order).to eq [1, 2, 3, 6]
-      end
+          expect(order).to eq [1, 2, 3, 6]
+        end
 
-      it "times out early" do
-        setup
+        it "times out early" do
+          setup
 
-        expect(duration).to be >= timeout
-        expect(duration).to be < (timeout * 10)
+          expect(duration).to be >= timeout
+          expect(duration).to be < (timeout * 10)
+        end
       end
-    end
 
-    context "when the operation doesn't time out" do
-      let(:timeout) { 0.1 }
+      context "when the operation doesn't time out" do
+        let(:timeout) { 0.1 }
 
-      it "calls #timeout_after" do
-        expect_any_instance_of(scheduler_class)
-          .to receive(:timeout_after)
-          .and_call_original
+        it "calls #timeout_after" do
+          expect_any_instance_of(scheduler_class)
+            .to receive(:timeout_after)
+            .and_call_original
 
-        setup
-      end
+          setup
+        end
 
-      it "behaves async" do
-        setup
+        it "behaves async" do
+          setup
 
-        expect(order).to eq (1..5).to_a
-      end
+          expect(order).to eq (1..5).to_a
+        end
 
-      it "finishes the operation" do
-        setup
+        it "finishes the operation" do
+          setup
 
-        expect(duration).to be >= sleep_duration
-        expect(duration).to be < (sleep_duration * 1.5)
+          expect(duration).to be >= sleep_duration
+          expect(duration).to be < (sleep_duration * 1.5)
+        end
       end
     end
   end

data/lib/fiber_scheduler_spec/version.rb

@@ -1,3 +1,3 @@
 module FiberSchedulerSpec
-  VERSION = "0.9.0"
+  VERSION = "0.10.0"
 end

data/lib/fiber_scheduler_spec.rb

@@ -4,6 +4,7 @@ require_relative "fiber_scheduler_spec/close"
 require_relative "fiber_scheduler_spec/fiber"
 require_relative "fiber_scheduler_spec/io_wait"
 require_relative "fiber_scheduler_spec/kernel_sleep"
+require_relative "fiber_scheduler_spec/nested_fiber_schedule"
 require_relative "fiber_scheduler_spec/process_wait"
 require_relative "fiber_scheduler_spec/socket_io"
 require_relative "fiber_scheduler_spec/timeout_after"
@@ -15,6 +16,7 @@ RSpec.shared_examples FiberSchedulerSpec do
   include_examples FiberSchedulerSpec::Fiber
   include_examples FiberSchedulerSpec::IOWait
   include_examples FiberSchedulerSpec::KernelSleep
+  include_examples FiberSchedulerSpec::NestedFiberSchedule
   include_examples FiberSchedulerSpec::ProcessWait
   include_examples FiberSchedulerSpec::SocketIO
   include_examples FiberSchedulerSpec::TimeoutAfter

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: fiber_scheduler_spec
 version: !ruby/object:Gem::Version
-  version: 0.9.0
+  version: 0.10.0
 platform: ruby
 authors:
 - Bruno Sutic
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-02-12 00:00:00.000000000 Z
+date: 2022-02-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec
@@ -66,6 +66,7 @@ files:
 - lib/fiber_scheduler_spec/fiber.rb
 - lib/fiber_scheduler_spec/io_wait.rb
 - lib/fiber_scheduler_spec/kernel_sleep.rb
+- lib/fiber_scheduler_spec/nested_fiber_schedule.rb
 - lib/fiber_scheduler_spec/process_wait.rb
 - lib/fiber_scheduler_spec/socket_io.rb
 - lib/fiber_scheduler_spec/timeout_after.rb