aws-flow 1.0.0 → 1.0.1

data/aws-flow-core/test/aws/async_backtrace_spec.rb

@@ -1,41 +0,0 @@
-##
-# Copyright 2013 Amazon.com, Inc. or its affiliates. All Rights Reserved.
-#
-# Licensed under the Apache License, Version 2.0 (the "License").
-# You may not use this file except in compliance with the License.
-# A copy of the License is located at
-#
-#  http://aws.amazon.com/apache2.0
-#
-# or in the "license" file accompanying this file. This file is distributed
-# on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
-# express or implied. See the License for the specific language governing
-# permissions and limitations under the License.
-##
-
-def validate_stacktrace_content(method_to_call_on_async_backtrace, thing_to_look_for, should_it_be_there)
-    it "makes sure that any of #{thing_to_look_for.join", "} #{should_it_be_there} be printed when we call #{method_to_call_on_async_backtrace} on AsyncBacktrace" do
-    AsyncBacktrace.enable
-    AsyncBacktrace.send(method_to_call_on_async_backtrace)
-    scope = AsyncScope.new do
-    error_handler do |t|
-      t.begin { raise StandardError.new }
-      t.rescue(IOError) {}
-    end
-  end
-  begin
-    scope.eventLoop
-  rescue Exception => e
-    matching_lines = thing_to_look_for.select { |part| e.backtrace.to_s.include? part.to_s }
-
-    matching_lines.send(should_it_be_there, be_empty)
-    end
-  end
-end
-
-describe AsyncBacktrace do
-  validate_stacktrace_content(:enable, [:continuation], :should_not)
-  validate_stacktrace_content(:disable, [:continuation], :should)
-  validate_stacktrace_content(:enable_filtering, $RUBY_FLOW_FILES, :should)
-  validate_stacktrace_content(:disable_filtering, $RUBY_FLOW_FILES, :should_not)
-end

data/aws-flow-core/test/aws/async_scope_spec.rb

@@ -1,118 +0,0 @@
-##
-# Copyright 2013 Amazon.com, Inc. or its affiliates. All Rights Reserved.
-#
-# Licensed under the Apache License, Version 2.0 (the "License").
-# You may not use this file except in compliance with the License.
-# A copy of the License is located at
-#
-#  http://aws.amazon.com/apache2.0
-#
-# or in the "license" file accompanying this file. This file is distributed
-# on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
-# express or implied. See the License for the specific language governing
-# permissions and limitations under the License.
-##
-
-describe AsyncScope do
-
-  it "makes sure that basic AsyncScoping works" do
-    trace = []
-    this_scope = AsyncScope.new() do
-      task { trace << :inside_task}
-    end
-    trace.should == []
-    this_scope.eventLoop
-    trace.should == [:inside_task]
-  end
-
-  context "empty AsyncScope" do
-    let(:scope) { AsyncScope.new }
-    let(:trace) { [] }
-
-    it "adds tasks like a queue" do
-      scope << Task.new(scope.root_context) { trace << :task }
-      scope.eventLoop
-      trace.should == [:task]
-    end
-
-    it "adds a task if given one on construction" do
-      scope = AsyncScope.new { trace << :task }
-      scope.eventLoop
-      trace.should == [:task]
-    end
-
-
-    it "runs a task asynchronously" do
-      scope << Task.new(scope.root_context) { trace << :inner }
-      trace << :outer
-      scope.eventLoop
-      trace.should == [:outer, :inner]
-    end
-
-    it "runs multiple tasks in order" do
-      scope << Task.new(scope.root_context) { trace << :first_task }
-      scope << Task.new(scope.root_context) { trace << :second_task }
-      scope.eventLoop
-      trace.should == [:first_task, :second_task]
-    end
-
-    it "resumes tasks after a Future is ready" do
-      f = Future.new
-      scope = AsyncScope.new do
-        task do
-          trace << :first
-          f.get
-          trace << :fourth
-        end
-
-        task do
-          trace << :second
-          f.set(:foo)
-          trace << :third
-        end
-      end
-      scope.eventLoop
-      trace.should == [:first, :second, :third, :fourth]
-    end
-
-    it "tests to make sure that scopes complete after an event loop" do
-      scope = AsyncScope.new do
-        error_handler do |t|
-          t.begin do
-            x = Future.new
-            y = Future.new
-            error_handler do |t|
-              t.begin {}
-              t.ensure { x.set }
-            end
-            x.get
-            error_handler do |t|
-              t.begin {}
-              t.ensure { y.set }
-            end
-            y.get
-            error_handler do |t|
-              t.begin {}
-              t.ensure {}
-            end
-          end
-        end
-      end
-
-      completed = scope.eventLoop
-      completed.should == true
-    end
-    it "ensures you can cancel an async scope " do
-      condition = FiberConditionVariable.new
-      @task = nil
-      scope = AsyncScope.new do
-        task do
-          condition.wait
-        end
-      end
-      scope.eventLoop
-      scope.cancel(CancellationException.new)
-      expect { scope.eventLoop }.to raise_error CancellationException
-    end
-  end
-end

data/aws-flow-core/test/aws/begin_rescue_ensure_spec.rb

@@ -1,665 +0,0 @@
-##
-# Copyright 2013 Amazon.com, Inc. or its affiliates. All Rights Reserved.
-#
-# Licensed under the Apache License, Version 2.0 (the "License").
-# You may not use this file except in compliance with the License.
-# A copy of the License is located at
-#
-#  http://aws.amazon.com/apache2.0
-#
-# or in the "license" file accompanying this file. This file is distributed
-# on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
-# express or implied. See the License for the specific language governing
-# permissions and limitations under the License.
-##
-
-
-def change_test(options = {})
-  subject { this_bre }
-  its(:heirs) { options[:heirs] ? (should_not be_empty) : (should be_empty) }
-  its(:nonDaemonHeirsCount) { should == options[:nonDaemonHeirsCount] }
-end
-
-describe BeginRescueEnsure do
-  let(:condition) { FiberConditionVariable.new }
-  let(:flowfactory) { FlowFactory.new }
-
-  def make_trying_BRE(begin_tasks = [])
-    scope = AsyncScope.new do
-      @error_handler = error_handler do |t|
-        t.begin do
-          begin_tasks.each { |task| task.call}
-          condition.wait
-        end
-        t.rescue(IOError) {|x| condition.wait }
-        t.rescue(CancellationException) { |x| x }
-      end
-    end
-    scope.eventLoop
-    @error_handler
-  end
-
-  def make_catching_BRE(begin_tasks = [])
-    scope = AsyncScope.new do
-      @error_handler = error_handler do |t|
-        t.begin do
-          raise IOError
-        end
-        t.rescue(IOError) do |x|
-          begin_tasks.each { |task| task.call }
-          condition.wait
-        end
-      end
-    end
-    scope.eventLoop
-    @error_handler
-  end
-
-  let(:trying_BRE) do
-    make_trying_BRE
-  end
-
-  let(:catching_BRE) do
-    make_catching_BRE
-  end
-  context "BeginRescueEnsure in the :trying state" do
-    subject { trying_BRE }
-    its(:heirs) { should_not be_empty }
-    its(:nonDaemonHeirsCount) { should == 1 }
-
-    context "which adds a task," do
-      let(:trying_BRE_with_one_task) do
-        make_trying_BRE([lambda { task { condition.wait  } }])
-      end
-      let(:first_task) { trying_BRE_with_one_task.heirs.first }
-      subject { trying_BRE_with_one_task }
-      its(:heirs) { should_not be_empty }
-      its(:nonDaemonHeirsCount) { should == 2 }
-
-      context "and then has the task status changed," do
-        context "and cancel the BRE" do
-          let(:this_bre) { trying_BRE_with_one_task.cancel(StandardError.new);  trying_BRE_with_one_task }
-          # As a note: we trigger the rescue task, so we have a task in the heirs
-          change_test :heirs => true, :nonDaemonHeirsCount => 1
-        end
-
-        context "and fail the the task" do
-          let(:this_bre) { expect { trying_BRE_with_one_task.fail(first_task, StandardError.new) }.to raise_error StandardError; trying_BRE_with_one_task }
-          change_test :heirs => false, :nonDaemonHeirsCount => 0
-        end
-
-        context "and remove the task " do
-          let(:this_bre) { trying_BRE_with_one_task.remove(first_task); trying_BRE_with_one_task }
-          change_test :heirs => true, :nonDaemonHeirsCount => 1
-        end
-      end
-    end
-
-    context "which adds two tasks" do
-      let(:trying_BRE_with_two_tasks) do
-        make_trying_BRE([lambda { task { condition.wait }}, lambda { task { condition.wait }}])
-      end
-      let(:first_task) { trying_BRE_with_two_tasks.heirs.first }
-      subject { trying_BRE_with_two_tasks }
-      its(:heirs) { should_not be_empty }
-      its(:nonDaemonHeirsCount) { should == 3 }
-
-      context "And then we change the task status" do
-        context "and cancel the BRE" do
-          let(:this_bre) { trying_BRE_with_two_tasks.cancel(StandardError.new); trying_BRE_with_two_tasks }
-          change_test :heirs => true, :nonDaemonHeirsCount => 1
-        end
-
-        context "and fail the the task" do
-          let(:this_bre) { expect { trying_BRE_with_two_tasks.fail(first_task, StandardError.new) }.to raise_error StandardError; trying_BRE_with_two_tasks }
-          change_test :heirs => false, :nonDaemonHeirsCount => 0
-        end
-
-        context "and remove the task " do
-          let(:this_bre) { trying_BRE_with_two_tasks.remove(first_task); trying_BRE_with_two_tasks }
-          change_test :heirs => true, :nonDaemonHeirsCount => 2
-        end
-      end
-    end
-  end
-
-  context "BeginRescueEnsure in the :catching state" do
-    subject { catching_BRE}
-    its(:heirs) { should_not be_empty }
-    its(:nonDaemonHeirsCount) { should == 1 }
-
-    context "which adds a task," do
-      let(:catching_BRE_with_one_task) do
-        make_catching_BRE([lambda { task { condition.wait } }])
-      end
-      let(:first_task) { catching_BRE_with_one_task.heirs.first }
-      subject { catching_BRE_with_one_task }
-      its(:heirs) { should_not be_empty }
-      its(:nonDaemonHeirsCount) { should == 2 }
-
-      context "and then has the task status changed," do
-        context "and cancel the BRE" do
-          let(:this_bre) { catching_BRE_with_one_task.cancel(StandardError.new); catching_BRE_with_one_task }
-          change_test :heirs => true, :nonDaemonHeirsCount => 2
-        end
-
-        context "and fail the the task" do
-          let(:this_bre) { expect { catching_BRE_with_one_task.fail(first_task, StandardError.new) }.to raise_error StandardError; catching_BRE_with_one_task }
-          change_test :heirs => false, :nonDaemonHeirsCount => 0
-        end
-
-        context "and remove the task " do
-          let(:this_bre) { catching_BRE_with_one_task.remove(first_task); catching_BRE_with_one_task }
-          change_test :heirs => true, :nonDaemonHeirsCount => 1
-        end
-      end
-    end
-
-    context "which adds two tasks" do
-      let(:catching_BRE_with_two_tasks) do
-        make_catching_BRE([lambda { task { condition.wait } },lambda { task { condition.wait } } ])
-      end
-      let(:first_task) { catching_BRE_with_two_tasks.heirs.first }
-      subject { catching_BRE_with_two_tasks }
-      its(:heirs) { should_not be_empty }
-      its(:nonDaemonHeirsCount) { should == 3 }
-
-      context "And then we change the task status" do
-        context "and cancel the BRE" do
-          let(:this_bre) { catching_BRE_with_two_tasks.cancel(StandardError.new); catching_BRE_with_two_tasks }
-          change_test :heirs => true, :nonDaemonHeirsCount => 3
-        end
-
-        context "and fail the the task" do
-          let(:this_bre) { expect { catching_BRE_with_two_tasks.fail(first_task, StandardError.new) }.to raise_error StandardError; catching_BRE_with_two_tasks }
-          change_test :heirs => false, :nonDaemonHeirsCount => 0
-        end
-
-        context "and remove the task " do
-          let(:this_bre) { catching_BRE_with_two_tasks.remove(first_task); catching_BRE_with_two_tasks }
-          change_test :heirs => true, :nonDaemonHeirsCount => 2
-        end
-      end
-
-    end
-  end
-
-  before(:each) { class RescueTestingError < StandardError; end }
-  let(:trace) { [] }
-  let(:flowfactory) { FlowFactory.new }
-  let(:scope) { flowfactory.generate_scope }
-
-  it "makes sure that error handling without resuming does nothing" do
-
-    scope = AsyncScope.new do
-      _error_handler do |t|
-        t.begin { trace << :in_the_begin }
-      end
-    end
-    trace.should == []
-  end
-
-  {:Task => lambda { |&x| task(&x) }, :DaemonTask => lambda { |&x| daemon_task(&x) }}.each_pair do |name, task_creation|
-
-    # TODO: Reinstate this test, if it is easy enough
-    #
-    # it "makes sure that error handling with a #{name} free floating raises" do
-    #   scope = AsyncScope.new do
-    #     error_handler do |t|
-    #       t.begin { trace << :in_the_begin }
-    #       t.rescue(RescueTestingError) {}
-    #       task_creation.call { trace << :in_the_daemon }
-    #     end
-    #   end
-    #   expect { scope.eventLoop }.to raise_error NoContextException, /You have not scoped this task correctly!/
-    # end
-
-    it "make sure that #{name} in a BRE runs correctly, and that the BRE supports signal " do
-      condition = FiberConditionVariable.new
-      scope = AsyncScope.new do
-        error_handler do |t|
-          t.begin do
-            trace << :in_the_begin
-            task_creation.call { trace << :in_the_daemon; condition.signal }
-            condition.wait
-          end
-          t.rescue(RescueTestingError) {}
-        end
-      end
-      scope.eventLoop
-      trace.should == [:in_the_begin, :in_the_daemon]
-    end
-  end
-
-  it "makes sure that a BRE can finish with a daemon task still alive" do
-    condition = FiberConditionVariable.new
-    scope = AsyncScope.new do
-      error_handler do |t|
-        t.begin do
-          trace << :in_the_begin
-          @daemon_task = daemon_task { condition.wait; :should_never_be_hit }
-        end
-        t.rescue(RescueTestingError) {}
-      end
-    end
-    scope.eventLoop
-    trace.should == [:in_the_begin]
-  end
-
-  # TODO Reinstate this test, after fixing it so it doesn't add to BRE directly
-  # it "makes sure that a daemon task can cancel a BRE" do
-  #   flowfactory = FlowFactory.new
-  #   condition = FiberConditionVariable.new
-  #   scope = flowfactory.generate_scope
-  #   bre = flowfactory.generate_BRE(:begin => lambda { condition.wait })
-  #   daemon_task = DaemonTask.new(bre) { condition.wait }
-  #   task = Task.new(bre) { condition.wait }
-  #   bre << task
-  #   bre << daemon_task
-  #   scope.eventLoop
-  #   bre.remove(task)
-  #   scope.eventLoop
-  #   trace.should == []
-  # end
-
-
-  # TODO Reinstate this test, after fixing it so it doesn't add to BRE directly
-  # it "makes sure that a daemon task cancelling does not override other fails" do
-  #   flowfactory = FlowFactory.new
-  #   condition = FiberConditionVariable.new
-  #   scope = flowfactory.generate_scope
-  #   bre = flowfactory.generate_BRE(:begin => lambda { condition.wait })
-  #   daemon_task = DaemonTask.new(bre) { condition.wait }
-  #   task = Task.new(bre) { condition.wait }
-  #   bre << daemon_task
-  #   bre << task
-  #   scope.eventLoop
-  #   daemon_task.cancel(StandardError)
-  #   bre.fail(task, RescueTestingError)
-  #   expect { debugger; scope.eventLoop }.to raise_error RescueTestingError
-  #   trace.should == []
-  # end
-
-  # TODO Fix these up with the FlowFactory
-  it "makes sure that creating a task in the rescue block will run it" do
-    scope = AsyncScope.new do
-      error_handler do |t|
-        t.begin { raise RescueTestingError}
-
-        t.rescue(RescueTestingError) do
-          trace << :in_the_rescue
-          task { trace << :in_the_task }
-        end
-      end
-      scope.eventLoop
-      trace.should == [:in_the_beginning, :in_the_task]
-    end
-  end
-
-  it "makes sure that creating a task inside a BRE block will run it" do
-    scope = AsyncScope.new do
-      error_handler do |t|
-        t.begin do
-          trace << :in_the_beginning
-          task { trace << :in_the_task }
-        end
-        t.rescue(StandardError) {|x| }
-      end
-    end
-    scope.eventLoop
-    trace.should == [:in_the_beginning, :in_the_task]
-  end
-
-  it "ensures you can have error handling without ensure" do
-    scope = AsyncScope.new do
-      error_handler do |t|
-        t.begin { trace << :in_the_begin }
-        t.rescue(StandardError) { trace << :in_the_rescue }
-      end
-    end
-    scope.eventLoop
-    trace.should == [:in_the_begin]
-  end
-
-  it "ensures that rescue picks the first matching rescue block" do
-    scope = AsyncScope.new do
-      @error_handler = _error_handler do |t|
-        t.begin do
-          trace << :in_the_begin
-          raise RescueTestingError
-        end
-        t.rescue(RescueTestingError) { trace << :in_the_rescue }
-        t.rescue(StandardError) { trace << :in_the_bad_rescue }
-      end
-    end
-    scope.eventLoop
-    trace.should == [:in_the_begin, :in_the_rescue]
-  end
-
-  it "ensures that rescue blocks trickle to the first applicable block" do
-    scope = AsyncScope.new do
-      error_handler do |t|
-        t.begin do
-          trace << :in_the_begin
-          raise RescueTestingError
-        end
-        t.rescue(IOError) { trace << :bad_rescue }
-        t.rescue(RescueTestingError) { trace << :in_the_rescue }
-      end
-    end
-    scope.eventLoop
-    trace.should == [:in_the_begin, :in_the_rescue]
-  end
-
-  it "ensures that the same rescue exception twice causes an exception" do
-    scope = AsyncScope.new do
-      error_handler do |t|
-        t.begin {}
-        t.rescue(RescueTestingError) {}
-        t.rescue(RescueTestingError) {}
-      end
-    end
-    # TODO Make rescue give a specific error in this case
-
-    expect { scope.eventLoop }.to raise_error /You have already registered RescueTestingError/
-  end
-
-  it "ensures that stack traces work properly" do
-    scope = AsyncScope.new do
-      error_handler do |t|
-        t.begin { raise "simulated" }
-        t.rescue(Exception) do |e|
-          e.backtrace.should include "------ continuation ------"
-          e.message.should == "simulated"
-        end
-      end
-    end
-    scope.eventLoop
-  end
-
-  it "makes sure an error is raised if none of the rescue blocks apply to it" do
-    scope = AsyncScope.new  do
-      error_handler do |t|
-        t.begin { raise RescueTestingError }
-        t.rescue(IOError) { p "nothing doing here" }
-      end
-    end
-    expect { scope.eventLoop }.to raise_error RescueTestingError
-  end
-
-  it "ensures that the ensure block is called with a rescue path" do
-    scope = AsyncScope.new do
-      error_handler do |t|
-        t.begin do
-          trace << :in_the_begin
-          raise RescueTestingError
-        end
-        t.rescue(RescueTestingError) { trace << :in_the_rescue }
-        t.ensure { trace << :in_the_ensure }
-      end
-    end
-     scope.eventLoop
-    trace.should == [:in_the_begin, :in_the_rescue, :in_the_ensure]
-  end
-
-  it "calls ensure after subtask ensure" do
-    scope = AsyncScope.new do
-      error_handler do |t|
-        t.begin do
-          trace << :in_the_top_begin
-          error_handler do |h|
-            h.begin { trace << :in_the_inner_begin }
-            h.rescue(StandardError) { }
-            h.ensure { trace << :in_the_inner_ensure }
-          end
-          t.rescue(StandardError) {  }
-          t.ensure { trace << :in_the_outer_ensure}
-        end
-      end
-      scope.eventLoop
-      trace.should == [:in_the_top_begin, :in_the_inner_begin, :in_the_inner_ensure, :in_the_outer_ensure]
-    end
-  end
-
-  it "ensures that an ensure block will be called when an exception is raised" do
-    scope = AsyncScope.new do
-      error_handler do |t|
-        t.begin do
-          trace << :in_the_begin
-          raise StandardError
-        end
-        t.rescue(RescueTestingError) { trace << :this_is_not_okay }
-        t.ensure { trace << :in_the_ensure }
-      end
-    end
-    expect { scope.eventLoop }.to raise_error StandardError
-    trace.should == [:in_the_begin, :in_the_ensure]
-  end
-
-  it "ensures that the ensure block is called without an applicable rescue case
-  passes the error up" do
-    scope = AsyncScope.new do
-      error_handler do |t|
-        t.begin do
-          trace << :in_the_begin
-          raise RescueTestingError
-        end
-        t.rescue(IOError) { trace << :in_the_rescue }
-        t.ensure { trace << :in_the_ensure }
-        expect { scope.eventLoop }.to raise_error RescueTestingError
-        trace.should == [:in_the_begin, :in_the_ensure]
-      end
-    end
-  end
-
-  it "ensures that two begins raise an error" do
-    scope = AsyncScope.new do
-      error_handler do |t|
-        t.begin { trace << :yay }
-        t.begin { trace << :oh_no }
-        t.rescue(StandardError) { trace << :should_never_be_hit }
-      end
-    end
-    expect { scope.eventLoop }.to raise_error RuntimeError, /Duplicated begin/
-  end
-
-  it "ensures that two ensure statements raise an error" do
-    scope = AsyncScope.new do
-      error_handler do |t|
-        t.begin { trace << :yay }
-        t.rescue(StandardError) { trace << :should_never_be_hit }
-        t.ensure { trace << :this_is_okay }
-        t.ensure { trace << :but_this_is_not }
-      end
-    end
-    expect { scope.eventLoop }.to raise_error /Duplicated ensure/
-  end
-  # TODO: Reinstate this test
-  # it "ensures that you can't call resume inside the error handler" do
-  #   scope = AsyncScope.new do
-  #     error_handler do |t|
-  #       t.begin { trace << :in_the_begin }
-  #       t.rescue(StandardError) { trace << :in_the_rescue }
-  #       t.ensure { trace << :in_the_ensure }
-  #       t.resume
-  #     end
-  #   end
-  #   expect { scope.eventLoop }.to raise_error NoMethodError
-  # end
-
-  it "ensures that you can't access the private variables of a BeginRescueEnsure block" do
-    scope = AsyncScope.new do
-      error_handler do |t|
-        t.begin { "This is the begin" }
-        t.rescue(StandardError) { "This is the rescue" }
-        t.ensure { trace << t.begin_task }
-      end
-    end
-    expect { scope.eventLoop }.to raise_error
-    trace.should == []
-  end
-
-  describe "BRE's  closed behavior" do
-    before (:each) do
-      @scope = AsyncScope.new do
-        @error_handler = error_handler do |t|
-          t.begin do
-            "this is the beginning"
-          end
-          t.rescue StandardError do
-            "this is the rescue"
-          end
-        end
-      end
-    end
-
-    it "ensures that BRE's end at closed" do
-      @scope.eventLoop
-      @error_handler.current_state.should == :closed
-    end
-
-  end
-  context "Cancelling a BRE in the created state" do
-    scope = AsyncScope.new
-    condition = FiberConditionVariable.new
-    error_handler = BeginRescueEnsure.new(:parent => scope.root_context)
-    scope << error_handler
-    error_handler.begin lambda { raise StandardError; condition.wait }
-    error_handler.rescue(IOError, lambda { "this is the rescue" })
-    error_handler.cancel(StandardError)
-    subject { error_handler }
-    its(:current_state) { should == :closed }
-  end
-
-  it "makes sure that get_heirs works" do
-    flowfactory = FlowFactory.new
-    condition = FiberConditionVariable.new
-    scope = flowfactory.generate_scope
-    bre = flowfactory.generate_BRE(:begin => lambda { task { condition.wait; trace << :yay} })
-    scope.eventLoop
-    bre.get_heirs.length.should > 1
-    trace.should == []
-  end
-  #TODO this test shouldn't be needed, but it's a good comparison for flowfactory being borked
-  it "makes sure that get_heirs works" do
-    condition = FiberConditionVariable.new
-    scope = AsyncScope.new do
-      error_handler do |t|
-        t.begin { task { condition.wait; trace << :yay }}
-        t.rescue(StandardError) {}
-      end
-    end
-    scope.eventLoop
-    trace.should == []
-  end
-
-  it "makes sure that you can have a schedule in the middle of a BRE" do
-    future = Future.new
-    scope = AsyncScope.new do
-      error_handler do |t|
-        t.begin { task { future.get }}
-      end
-    end
-    scope.eventLoop
-    future.set(nil)
-    completed = scope.eventLoop
-    completed.should == true
-  end
-  # it "makes sure that failing a begin task will cause the other tasks to not get run" do
-  #   trace = []
-  #   scope = AsyncScope.new do
-  #     error_handler do |t|
-  #       t.begin do
-  #         condition = FiberConditionVariable.new
-  #         error_handler do |first_t|
-  #           first_t.begin do
-  #             task do
-  #               trace << "in the error"
-  #               condition.signal
-  #               raise "simulated error"
-  #             end
-  #             debugger
-  #             condition.wait
-  #             other_future = task do
-  #               trace << "This should not be"
-  #             end
-  #           end
-  #           first_t.rescue(StandardError) do |error|
-  #             raise error
-  #           end
-  #           first_t.ensure {condition.signal}
-  #         end
-
-  #         error_handler do |second_t|
-  #           second_t.begin do
-  #             other_future = task do
-  #               trace << "This should not be"
-  #             end
-  #           end
-  #           second_t.rescue(StandardError) do |error|
-  #             raise error
-  #           end
-  #           second_t.ensure {}
-  #         end
-  #         t.rescue(StandardError) {|error| raise error}
-  #         t.ensure {}
-  #       end
-  #     end
-  #   end
-  #   debugger
-  #   expect { scope.eventLoop }.to raise_error StandardError
-  #   trace.should == []
-  # end
-
-
-end
-
-describe "BRE#alive?" do
-  context "checking different types of BREs" do
-    let(:flowfactory) { FlowFactory.new }
-    let(:scope) { flowfactory.generate_scope }
-    before(:each) do
-     @regular_bre = flowfactory.generate_BRE
-      @rescue_bre = flowfactory.generate_BRE(:begin => lambda { raise StandardError })
-    end
-    context "regular bre" do
-      subject { @regular_bre }
-      it { should be_alive }
-      context "and then we run the scope" do
-        let(:run_bre) { scope.eventLoop; @regular_bre }
-        subject { run_bre }
-        it { should_not be_alive }
-      end
-    end
-    context "rescue bre" do
-      subject { @rescue_bre }
-      it { should be_alive }
-      context "and then we run the scope" do
-        let(:run_bre) { scope.eventLoop; @rescue_bre }
-        subject { run_bre }
-        it { should_not be_alive }
-      end
-    end
-  end
-end
-describe "Misc" do
-  it "makes sure that the return value of a BRE is the begin" do
-    scope = AsyncScope.new do
-      @x = _error_handler do |t|
-        t.begin { 5 }
-      end
-    end
-    scope.eventLoop
-    @x.get.should == 5
-  end
-  it "meakes sure that if there is a failure, the result is the rescue value" do
-    scope = AsyncScope.new do
-      @x = _error_handler do |t|
-        t.begin { raise StandardError }
-        t.rescue(StandardError) { 6 }
-      end
-    end
-    scope.eventLoop
-    @x.get.should == 6
-  end
-end