blackstart 0.2.0 → 0.9.0

data/test/blackstart_test.rb

@@ -1,198 +1,42 @@
 # Sections that create local variables are in class definitions so that later
 # sections cannot accidentally reference those local variables.
 
+# Kernel#fail is an alias of Kernel#raise, so they do the same thing. However,
+# they are used differently in this file: Kernel#fail is used only for
+# assertions and Kernel#raise is used otherwise. Assertions always pass a
+# string argument so that a new RuntimeError is raised. Kernel#fail with no
+# arguments re-raises the current exception ($!) or, if there is none, raises a
+# new RuntimeError. This would be fine (that is, it would raise a new
+# RuntimeError) sometimes, but not always (not in a rescue clause, for
+# example). Always using Kernel#fail with a string argument makes assertions
+# consistent and avoids this subtle error.
+
+# Constant references in blocks are fully qualified because this program must
+# run correctly on a wide range of Ruby versions, including those in the 1.9.1
+# and 1.9.2 branches. Ruby 1.9.1 and 1.9.2 used constant-lookup rules in
+# certain situations that differed from those of earlier and later branches of
+# Ruby.
+
 require "blackstart"
 
 # Blackstart should be a module.
 fail "" unless Module.equal? Blackstart.class
 
-# Blackstart should say it responds to vet, add, and run.
-fail "" unless Blackstart.respond_to? :vet
-fail "" unless Blackstart.respond_to? :add
+# Blackstart should say it responds to run.
 fail "" unless Blackstart.respond_to? :run
 
-# Test Blackstart.vet:
-
-# Blackstart.vet should raise an exception if any non-block arguments are sent.
-begin
-  Blackstart.vet nil
-rescue ArgumentError
-else
-  fail ""
-end
-begin
-  Blackstart.vet(nil) {}
-rescue ArgumentError
-else
-  fail ""
-end
-
-# If sending call with no arguments to the block raises an error,
-# Blackstart.vet should return a new descriptive string.
-class ::Object
-  fail "" unless /\ANoMethodError: / =~ Blackstart.vet
-
-  e_class = Class.new StandardError
-  def e_class.to_s
-    "FakeError".freeze
-  end
-
-  e_nil = e_class.new "a".freeze
-  def e_nil.backtrace
-    nil
-  end
-  fail "" unless "FakeError: a" == Blackstart.vet { ::Kernel.raise e_nil }
-
-  e_empty = e_class.new "b".freeze
-  def e_empty.backtrace
-    [].freeze
-  end
-  fail "" unless "FakeError: b" == Blackstart.vet { ::Kernel.raise e_empty }
-
-  e_full = e_class.new "c".freeze
-  def e_full.backtrace
-    ["d".freeze, "e".freeze].freeze
-  end
-  fail "" unless "FakeError: c\nd\ne" ==
-    Blackstart.vet { ::Kernel.raise e_full }
-end
-
-# If sending call with no arguments to the block raises a non-StandardError
-# exception, Blackstart.vet should not rescue it.
-class ::Object
-  non_standard_error = Class.new Exception
-  begin
-    Blackstart.vet { ::Kernel.raise non_standard_error }
-  rescue non_standard_error
-  else
-    fail ""
-  end
-end
-
-# If sending call with no arguments to the block does not raise an exception,
-# Blackstart.vet should return nil.
-fail "" unless nil.equal? Blackstart.vet { nil }
-fail "" unless nil.equal? Blackstart.vet { true }
-
-# Test Blackstart.add:
-
-# When there is no block, Blackstart.add should raise an exception.
-begin
-  Blackstart.add
-rescue NoMethodError
-else
-  fail ""
-end
-begin
-  Blackstart.add []
-rescue NoMethodError
-else
-  fail ""
-end
-
-# Blackstart.add should raise an exception if superfluous arguments are sent.
-begin
-  Blackstart.add [], "invalid"
-rescue ArgumentError
-else
-  fail ""
-end
-begin
-  Blackstart.add([], "invalid") {}
-rescue ArgumentError
-else
-  fail ""
-end
-
-# When no collection is specified and the block does nothing, Blackstart.add
-# should return an empty array.
-fail "" unless [] == Blackstart.add {}
+# Test Blackstart::Scratchpad:
 
-# When a collection is specified and the block tries to add to the collection,
-# Blackstart.add should add corresponding procs or nil to the collection by
-# sending <<.
-class ::Object
-  sink = [42]
-  prc1 = proc {}
-  prc2 = proc {}
-  retval = Blackstart.add sink do |adder|
-    adder.call(&prc1)
-    adder.call(&prc2)
-    adder.call
-  end
-  fail "" unless sink.equal? retval
-  fail "" unless [42, prc1, prc2, nil] == sink
-end
+# Blackstart::Scratchpad.new should return an instance of
+# Blackstart::Scratchpad, which implies that Blackstart::Scratchpad should be a
+# class.
+fail "" unless Blackstart::Scratchpad.equal? Blackstart::Scratchpad.new.class
 
-# When the block sends call to the adder with arguments other than a block, it
-# should raise an exception and not add anything to the collection.
-class ::Object
-  sink = []
-  begin
-    Blackstart.add(sink) { |adder| adder.call("invalid") {} }
-  rescue ArgumentError
-  else
-    fail ""
-  end
-  begin
-    Blackstart.add(sink) { |adder| adder.call "invalid" }
-  rescue ArgumentError
-  else
-    fail ""
-  end
-  fail "" unless 0 == sink.length
-end
+# Blackstart::Scratchpad should not be frozen.
+fail "" if Blackstart::Scratchpad.frozen?
 
-# When Blackstart.add's block sends call to the adder and it returns, nil
-# should be the object it returns.
-class ::Object
-  retval_block = retval_no_block = true
-  Blackstart.add do |adder|
-    retval_block = adder.call {}
-    retval_no_block = adder.call
-  end
-  fail "" unless nil.equal? retval_block
-  fail "" unless nil.equal? retval_no_block
-end
-
-# In general, when there is a block that raises an exception, Blackstart.add
-# should not rescue it.
-class ::Object
-  e = StandardError.new
-  begin
-    Blackstart.add { ::Kernel.raise e }
-  rescue
-    fail "" unless e.equal? $!
-  else
-    fail ""
-  end
-end
-
-# When there is a block that tries to add to the collection and the collection
-# responds to the << message by raising an exception, Blackstart.add should not
-# rescue it.
-begin
-  Blackstart.add(nil) { |adder| adder.call {} }
-rescue NoMethodError
-else
-  fail ""
-end
-
-# When no collection is specified and the block tries to add to the collection,
-# Blackstart.add should append to a new array that gets returned.
-class ::Object
-  prc = proc {}
-  fail "" unless [prc] == Blackstart.add { |adder| adder.call(&prc) }
-end
-
-# Test Blackstart::Context:
-
-# Blackstart::Context.new should return an instance of Blackstart::Context,
-# which implies that Blackstart::Context should be a class.
-fail "" unless Blackstart::Context.equal? Blackstart::Context.new.class
-
-# A new context should have no instance variables.
-fail "" unless 0 == Blackstart::Context.new.instance_variables.length
+# A new scratchpad should have no instance variables.
+fail "" unless 0 == Blackstart::Scratchpad.new.instance_variables.length
 
 # Test Blackstart.run:
 
@@ -200,7 +44,7 @@ fail "" unless 0 == Blackstart::Context.new.instance_variables.length
 # return the appropriate object based on the behavior of the tests.
 class ::Object
   begin
-    # Set $stdout to a test spy and set it back in the ensure clause.
+    # Set $stdout to a test spy and restore it in the ensure clause.
     original_stdout = $stdout
     spy_stdout = $stdout.clone
     spy_stdout.instance_variable_set :@_test_calls, stdout_calls = []
@@ -210,155 +54,289 @@ class ::Object
     end
     $stdout = spy_stdout
 
-    # No tests.
-    source = [].freeze
-    fail "" unless true.equal? Blackstart.run(source, Object.new)
+    invalid_ostream = Object.new
+    def invalid_ostream.puts(*)
+      ::Kernel.raise ::NoMethodError
+    end
+
+    # When there are no tests, Blackstart.run should not notify the output
+    # stream of any failures.
+    source = []
+    fail "" unless true.equal? Blackstart.run(source, invalid_ostream)
     fail "" unless true.equal? Blackstart.run(source, spy_stdout)
     fail "" unless true.equal? Blackstart.run(source)
     fail "" unless 0 == stdout_calls.length
 
-    # Tests that do not raise exceptions.
-    source = [proc {}, proc { 42 }].freeze
-    fail "" unless true.equal? Blackstart.run(source, Object.new)
+    # When there are tests but none raise exceptions, Blackstart.run should not
+    # notify the output stream of any failures. The objects returned by the
+    # test procs shouldn't affect Blackstart.run's behavior.
+    source = [lambda {}, lambda { 42 }]
+    fail "" unless true.equal? Blackstart.run(source, invalid_ostream)
     fail "" unless true.equal? Blackstart.run(source, spy_stdout)
     fail "" unless true.equal? Blackstart.run(source)
     fail "" unless 0 == stdout_calls.length
 
-    # Define some example test objects.
-    e_class = Class.new StandardError
+    # Define some test objects. Freeze them, the strings to which they convert,
+    # some exception details, and the strings to which the exception classes
+    # convert to check that they don't get modified.
+    e_class = Class.new StandardError do
+      def backtrace
+        ["line1".freeze, "line2".freeze].freeze
+      end
+    end
     def e_class.to_s
-      "FakeError"
+      "FakeError".freeze
     end
-    fail_prc1 = proc { ::Kernel.raise e_class, "fake message 1" }
+    fail_prc1 = lambda { ::Kernel.raise e_class, "fake message 1".freeze }
     def fail_prc1.to_s
-      "to_s 1"
+      "to_s 1".freeze
     end
+    fail_prc1.freeze
+    pass_prc = lambda {}.freeze
     fail_prc2 = Object.new # Not a Proc instance, but converts to one.
     fail_prc2.instance_variable_set :@_test_e_class, e_class
     def fail_prc2.to_proc
       e_class = @_test_e_class
-      ::Proc.new { ::Kernel.raise e_class, "fake message 2" }
+      ::Kernel.lambda do
+        ::Kernel.raise e_class, "fake message 2".freeze
+      end.freeze
     end
     def fail_prc2.to_s
-      "to_s 2"
+      "to_s 2".freeze
     end
-    pass_prc = proc {}
-
-    # A mix of tests that raise errors and tests that return.
-    source = [fail_prc1, fail_prc2, pass_prc].freeze
-
-    # Output stream that does not conform to the expected interface. (And in
-    # general, the only exceptions Blackstart.run should rescue are
-    # StandardError exceptions raised by tests.)
-    begin
-      Blackstart.run source, Object.new
-    rescue NoMethodError
-    else
-      fail ""
+    fail_prc2.freeze
+    non_prc = Object.new # Does not convert to a proc.
+    def non_prc.to_proc
+      ::Kernel.raise ::NoMethodError
     end
-    fail "" unless 0 == stdout_calls.length
+    def non_prc.to_s
+      "to_s 3".freeze
+    end
+    non_prc.freeze
+    bad_prc = Object.new # Pretends to convert to a proc but doesn't.
+    def bad_prc.to_proc
+      0
+    end
+    def bad_prc.to_s
+      "to_s 4".freeze
+    end
+    bad_prc.freeze
+
+    # A mix of tests that raise errors and tests that return. Freeze the array
+    # to check that it's not being modified.
+    source = [fail_prc1, pass_prc, fail_prc2, non_prc, bad_prc].freeze
 
-    # Output stream that conforms to the expected interface.
+    # An output stream that conforms to the expected interface and does not
+    # raise an exception should receive all failure information.
     spy_ostream = Object.new
     spy_ostream.instance_variable_set :@_test_calls, calls = []
     def spy_ostream.puts *args
       @_test_calls << args
-      nil
+      # A real standard output stream would return nil here (and spy_stdout
+      # does that), but Blackstart.run's behavior should not be affected by the
+      # returned object. Returning this unusual object tests that.
+      ::Object.new
     end
+    # Freeze the output stream to check that it's not being modified.
+    spy_ostream.freeze
     fail "" unless false.equal? Blackstart.run(source, spy_ostream)
     fail "" unless 0 == stdout_calls.length
-    fail "" unless 2 == calls.length
-    fail "" unless 5 == calls[0].length
+    fail "" unless 4 == calls.length
+    fail "" unless 7 == calls[0].length
     fail "" unless "FAILED TEST:" == calls[0][0]
     fail "" unless "to_s 1" == calls[0][1]
     fail "" unless "...ERROR:" == calls[0][2]
-    fail "" unless /\AFakeError: fake message 1$/ =~ calls[0][3]
-    fail "" unless "" == calls[0][4]
-    fail "" unless 5 == calls[1].length
+    fail "" unless "FakeError" == calls[0][3]
+    fail "" unless "fake message 1" == calls[0][4]
+    fail "" unless ["line1", "line2"] == calls[0][5]
+    fail "" unless "" == calls[0][6]
+    fail "" unless 7 == calls[1].length
     fail "" unless "FAILED TEST:" == calls[1][0]
     fail "" unless "to_s 2" == calls[1][1]
     fail "" unless "...ERROR:" == calls[1][2]
-    fail "" unless /\AFakeError: fake message 2$/ =~ calls[1][3]
-    fail "" unless "" == calls[1][4]
-    spy_ostream = calls = nil
-
-    # Default output stream.
+    fail "" unless "FakeError" == calls[1][3]
+    fail "" unless "fake message 2" == calls[1][4]
+    fail "" unless ["line1", "line2"] == calls[1][5]
+    fail "" unless "" == calls[1][6]
+    fail "" unless 7 == calls[2].length
+    fail "" unless "FAILED TEST:" == calls[2][0]
+    fail "" unless "to_s 3" == calls[2][1]
+    fail "" unless "...ERROR:" == calls[2][2]
+    # (No need to check the error details.)
+    fail "" unless "" == calls[2][6]
+    fail "" unless 7 == calls[3].length
+    fail "" unless "FAILED TEST:" == calls[3][0]
+    fail "" unless "to_s 4" == calls[3][1]
+    fail "" unless "...ERROR:" == calls[3][2]
+    # (No need to check the error details.)
+    fail "" unless "" == calls[3][6]
+
+    # The faked standard output stream.
     stdout_calls.clear
     fail "" unless false.equal? Blackstart.run(source)
-    fail "" unless 2 == stdout_calls.length
-    fail "" unless 5 == stdout_calls[0].length
+    fail "" unless 4 == stdout_calls.length
+    fail "" unless 7 == stdout_calls[0].length
     fail "" unless "FAILED TEST:" == stdout_calls[0][0]
     fail "" unless "to_s 1" == stdout_calls[0][1]
     fail "" unless "...ERROR:" == stdout_calls[0][2]
-    fail "" unless /\AFakeError: fake message 1$/ =~ stdout_calls[0][3]
-    fail "" unless "" == stdout_calls[0][4]
-    fail "" unless 5 == stdout_calls[1].length
+    fail "" unless "FakeError" == stdout_calls[0][3]
+    fail "" unless "fake message 1" == stdout_calls[0][4]
+    fail "" unless ["line1", "line2"] == stdout_calls[0][5]
+    fail "" unless "" == stdout_calls[0][6]
+    fail "" unless 7 == stdout_calls[1].length
     fail "" unless "FAILED TEST:" == stdout_calls[1][0]
     fail "" unless "to_s 2" == stdout_calls[1][1]
     fail "" unless "...ERROR:" == stdout_calls[1][2]
-    fail "" unless /\AFakeError: fake message 2$/ =~ stdout_calls[1][3]
-    fail "" unless "" == stdout_calls[1][4]
+    fail "" unless "FakeError" == stdout_calls[1][3]
+    fail "" unless "fake message 2" == stdout_calls[1][4]
+    fail "" unless ["line1", "line2"] == stdout_calls[1][5]
+    fail "" unless "" == stdout_calls[1][6]
+    fail "" unless 7 == stdout_calls[2].length
+    fail "" unless "FAILED TEST:" == stdout_calls[2][0]
+    fail "" unless "to_s 3" == stdout_calls[2][1]
+    fail "" unless "...ERROR:" == stdout_calls[2][2]
+    # (No need to check the error details.)
+    fail "" unless "" == stdout_calls[2][6]
+    fail "" unless 7 == stdout_calls[3].length
+    fail "" unless "FAILED TEST:" == stdout_calls[3][0]
+    fail "" unless "to_s 4" == stdout_calls[3][1]
+    fail "" unless "...ERROR:" == stdout_calls[3][2]
+    # (No need to check the error details.)
+    fail "" unless "" == stdout_calls[3][6]
     stdout_calls.clear
 
-    # Test that raises a non-StandardError exception. (And in general, the only
-    # exceptions Blackstart.run should rescue are StandardError exceptions
-    # raised by tests.)
-    non_standard_error = Class.new Exception
-    source = [proc { ::Kernel.raise non_standard_error }]
+    # An output stream that raises an exception when notified of a failure
+    # should cause Blackstart.run to raise that exception and stop processing
+    # tests. (In general, the only exceptions Blackstart.run should rescue are
+    # StandardError exceptions raised by tests.)
+    second_test_run = false
+    source = [lambda { ::Kernel.raise "" }, lambda { second_test_run = true }]
     begin
-      Blackstart.run source, spy_stdout
-    rescue non_standard_error
+      Blackstart.run source, invalid_ostream
+    rescue NoMethodError
     else
       fail ""
     end
+    fail "" if second_test_run
     fail "" unless 0 == stdout_calls.length
 
-    # Test sequence that does not conform to the interface. (And in general,
-    # the only exceptions Blackstart.run should rescue are StandardError
-    # exceptions raised by tests.)
+    # When a test raises a non-StandardError exception, Blackstart.run should
+    # raise that exception and stop processing tests. (In general, the only
+    # exceptions Blackstart.run should rescue are StandardError exceptions
+    # raised by tests.)
+    second_test_run = false
+    non_standard_error = Class.new Exception
+    source = [lambda { ::Kernel.raise non_standard_error },
+      lambda { second_test_run = true }]
     begin
-      Blackstart.run nil, spy_stdout
-    rescue NoMethodError
+      Blackstart.run source, spy_stdout
+    rescue non_standard_error
     else
       fail ""
     end
+    fail "" if second_test_run
     fail "" unless 0 == stdout_calls.length
 
-    # Test sequences containing objects that do not convert to procs (and do
-    # not pretend to) and objects that pretend to convert to procs but do not.
-    # (And in general, the only exceptions Blackstart.run should rescue are
+    # When the test sequence does not conform to the interface and raises an
+    # exception during iteration, Blackstart.run should raise that exception.
+    # (In general, the only exceptions Blackstart.run should rescue are
     # StandardError exceptions raised by tests.)
-    source = [nil]
-    begin
-      Blackstart.run source, spy_stdout
-    rescue ArgumentError
-    else
-      fail ""
+    source = Object.new
+    def source.each(*)
+      ::Kernel.raise ::NoMethodError
     end
-    source = [0]
     begin
       Blackstart.run source, spy_stdout
-    rescue TypeError
+    rescue NoMethodError
     else
       fail ""
     end
-    bad_to_proc = Object.new
-    def bad_to_proc.to_proc
-      nil
+    fail "" unless 0 == stdout_calls.length
+
+    # When a test fails and converting the test object to a string raises an
+    # exception, Blackstart.run should raise that exception and stop processing
+    # tests. (In general, the only exceptions Blackstart.run should rescue are
+    # StandardError exceptions raised by tests.)
+    second_test_run = false
+    no_desc = lambda { ::Kernel.raise "" }
+    def no_desc.to_s
+      ::Kernel.raise ::NoMethodError
     end
-    source = [bad_to_proc]
+    source = [no_desc, lambda { second_test_run = true }]
     begin
       Blackstart.run source, spy_stdout
-    rescue TypeError
+    rescue NoMethodError
     else
       fail ""
     end
+    fail "" if second_test_run
     fail "" unless 0 == stdout_calls.length
   ensure
     $stdout = original_stdout
   end
 end
 
+# When a test fails with an error whose backtrace message returns nil,
+# Blackstart.run should send an empty array to the output stream in place of
+# the backtrace.
+class ::Object
+  e_class = Class.new StandardError
+  def e_class.to_s
+    "FakeError".freeze
+  end
+  e_no_bt = e_class.new "no backtrace".freeze
+  def e_no_bt.backtrace
+    nil
+  end
+
+  ostream = Object.new
+  ostream.instance_variable_set :@_test_calls, calls = []
+  def ostream.puts *args
+    @_test_calls << args
+    nil
+  end
+
+  result = Blackstart.run [lambda { ::Kernel.raise e_no_bt }], ostream
+  fail "" unless false.equal? result
+  fail "" unless 1 == calls.length
+  fail "" unless 7 == calls[0].length
+  fail "" unless "FAILED TEST:" == calls[0][0]
+  fail "" unless "...ERROR:" == calls[0][2]
+  fail "" unless "FakeError" == calls[0][3]
+  fail "" unless "no backtrace" == calls[0][4]
+  fail "" unless [] == calls[0][5]
+  fail "" unless "" == calls[0][6]
+end
+
+# When a test fails with an error that raises an exception when queried,
+# Blackstart.run should raise that exception and stop processing tests. (In
+# general, the only exceptions Blackstart.run should rescue are StandardError
+# exceptions raised by tests.)
+class ::Object
+  second_test_run = false
+  e2_class = Class.new StandardError
+  e1 = StandardError.new
+  e1.instance_variable_set :@next_exception_class, e2_class
+  def e1.to_s
+    ::Kernel.raise @next_exception_class
+  end
+  source = [lambda { ::Kernel.raise e1 }, lambda { second_test_run = true }]
+  begin
+    Blackstart.run source, nil
+  rescue e2_class
+  else
+    fail ""
+  end
+  fail "" if second_test_run
+end
+
+# Blackstart.run should run tests in order.
+class ::Object
+  data = []
+  Blackstart.run [lambda { data << 1 }, lambda { data << 2 }], nil
+  fail "" unless [1, 2] == data
+end
+
 # Blackstart.run should call each test proc with no arguments.
 class ::Object
   args = nil
@@ -369,14 +347,74 @@ class ::Object
   fail "" unless [] == args
 end
 
-# Blackstart.run should call each test proc in the context of a unique instance
-# of Blackstart::Context.
+# Blackstart.run should work with any source that responds to each. The object
+# returned in response to the each message should not affect Blackstart.run's
+# behavior.
 class ::Object
-  context1 = context2 = nil
-  Blackstart.run [proc { context1 = self }, proc { context2 = self }], nil
-  fail "" unless Blackstart::Context.equal? context1.class
-  fail "" unless Blackstart::Context.equal? context2.class
-  fail "" if context1.equal? context2
+  source = Object.new
+  def source.each
+    ran = false
+    yield lambda { ran = true }
+    @ran = ran
+    self
+  end
+  fail "" unless true.equal? Blackstart.run(source, nil)
+  fail "" unless source.instance_variable_get :@ran
+
+  source = Object.new
+  def source.each
+    yield lambda {}
+    nil
+  end
+  fail "" unless true.equal? Blackstart.run(source, nil)
+end
+
+# Blackstart.run should send exactly one each message to the source.
+class ::Object
+  source = Object.new
+  source.instance_variable_set :@count, 0
+  def source.each
+    @count += 1
+    self
+  end
+  Blackstart.run source, nil
+  fail "" unless 1 == source.instance_variable_get(:@count)
+end
+
+# The block that Blackstart.run sends with the each message should return nil
+# whether the test fails or succeeds, regardless of the objects returned by the
+# test and the output stream.
+class ::Object
+  ostream = Object.new
+  def ostream.puts(*)
+    ::Object.new
+  end
+  source = Object.new
+  def source.each
+    pass_result = yield lambda { 42 }
+    fail_result = yield lambda { ::Kernel.raise "" }
+    @results = [pass_result, fail_result]
+    self
+  end
+  fail "" unless false.equal? Blackstart.run(source, ostream)
+  fail "" unless [nil, nil] == source.instance_variable_get(:@results)
+end
+
+# When Blackstart.run calls a test proc, the self object should be a unique
+# instance of Blackstart::Scratchpad.
+class ::Object
+  sp1 = sp2 = nil
+  Blackstart.run [lambda { sp1 = self }, lambda { sp2 = self }], nil
+  fail "" unless Blackstart::Scratchpad.equal? sp1.class
+  fail "" unless Blackstart::Scratchpad.equal? sp2.class
+  fail "" if sp1.equal? sp2
+end
+
+# When Blackstart.run runs a test, the scratchpad should not be frozen.
+class ::Object
+  frozen = true
+  Blackstart.run [lambda { frozen = frozen? }], nil
+  fail "" if frozen
 end
 
 # Blackstart.run should raise an exception if too few or too many non-block
@@ -387,11 +425,59 @@ rescue ArgumentError
 else
   fail ""
 end
-begin
-  Blackstart.run [], nil, "invalid"
-rescue ArgumentError
-else
-  fail ""
+class ::Object
+  source = []
+  begin
+    Blackstart.run source, nil, nil
+  rescue ArgumentError
+  else
+    fail ""
+  end
+end
+
+# The following sections modify the state of the library, so they must be run
+# after all the ordinary tests.
+
+# Blackstart.run should run each test by sending instance_exec to a scratchpad.
+class Blackstart::Scratchpad
+  def foo
+    2
+  end
+
+  def instance_exec(*)
+    @ivar = 1
+    super
+  end
+end
+class ::Object
+  result = nil
+  Blackstart.run [lambda { result = [@ivar, foo()] }], nil
+  fail "" unless [1, 2] == result
+end
+
+# When creating a scratchpad raises an exception, Blackstart.run should raise
+# that exception and stop processing tests instead of treating it as a test
+# failure, even when the exception is a StandardError. (In general, the only
+# exceptions Blackstart.run should rescue are StandardError exceptions raised
+# by tests; this one is raised outside of a test.) This section makes creating
+# a scratchpad always raise an exception, so it must be the last section that
+# runs tests.
+class ::Object
+  second_test_run = false
+  e_class = Class.new StandardError
+  scratchpad_class = Blackstart::Scratchpad
+  scratchpad_class.instance_variable_set :@_test_e_class, e_class
+  def scratchpad_class.new(*)
+    ::Kernel.raise @_test_e_class
+  end
+  source = [lambda {}, lambda { second_test_run = true }]
+  begin
+    Blackstart.run source, nil
+  rescue e_class
+  else
+    fail ""
+  end
+  fail "" if second_test_run
 end
 
 # If this message doesn't get written, there was a problem.