seeing_is_believing 3.0.0.beta.7 → 3.0.0

data/lib/seeing_is_believing/event_stream/producer.rb

@@ -1,38 +1,29 @@
 require 'seeing_is_believing/event_stream/events'
+require 'seeing_is_believing/safe'
 require 'thread'
 
 class SeeingIsBelieving
   module EventStream
     class Producer
-
       module NullQueue
         extend self
         def <<(*)   end
         def shift() end
+        # TODO: this one doesn't have clear, but we can call that on the real one.
+        # find a way to test this situation?
       end
 
       attr_accessor :max_line_captures, :filename
 
       def initialize(resultstream)
+        resultstream           = Safe::Stream[resultstream]
         self.filename          = nil
         self.max_line_captures = Float::INFINITY
         self.recorded_results  = []
-        self.queue             = Queue.new
-        self.producer_thread   = Thread.new do
-          begin
-            resultstream.sync = true
-            loop do
-              to_publish = queue.shift
-              break if to_publish == :break
-              resultstream << (to_publish << "\n")
-            end
-          rescue IOError, Errno::EPIPE
-            queue.clear
-          ensure
-            self.queue = NullQueue
-            resultstream.flush rescue nil
-          end
-        end
+        self.queue             = Safe::Queue[Queue.new]
+        self.producer_thread   = Safe::Thread[
+          build_producer_thread(resultstream)
+        ]
       end
 
       attr_reader :version
@@ -54,7 +45,7 @@ class SeeingIsBelieving
       StackErrors = [SystemStackError]
       StackErrors << Java::JavaLang::StackOverflowError if defined?(RUBY_PLATFORM) && RUBY_PLATFORM == 'java'
       def record_result(type, line_number, value)
-        counts = recorded_results[line_number] ||= Hash.new(0)
+        counts = recorded_results[line_number] ||= Safe::Hash.new(0)
         count  = counts[type]
         recorded_results[line_number][type] = count.next
         if count < max_line_captures
@@ -82,21 +73,24 @@ class SeeingIsBelieving
 
       # records the exception, returns the exitstatus for that exception
       def record_exception(line_number, exception)
-        return exception.status if exception.kind_of? SystemExit
+        return exception.status if SystemExit === exception
+        exception = Safe::Exception[exception]
         if !line_number && filename
           begin line_number = exception.backtrace.grep(/#{filename}/).first[/:\d+/][1..-1].to_i
           rescue NoMethodError
           end
         end
         line_number ||= -1
-        queue << [
+        queue << Safe::Array[[
           "exception",
-          line_number,
+          Safe::Fixnum[line_number],
           to_string_token(exception.class.name),
           to_string_token(exception.message),
-          exception.backtrace.size,
-          *exception.backtrace.map { |line| to_string_token line }
-        ].join(" ")
+          Safe::Fixnum[
+            Safe::Array[exception.backtrace].size
+          ],
+          *Safe::Array[exception.backtrace].map { |line| to_string_token line }
+        ]].join(" ")
         1 # exit status
       end
 
@@ -124,8 +118,40 @@ class SeeingIsBelieving
 
       # for a consideration of many different ways of doing this, see 5633064
       def to_string_token(string)
-        [Marshal.dump(string.to_s)].pack('m0')
+        Safe::Array[[Safe::Marshal.dump(Safe::String[string].to_s)]].pack('m0')
+      end
+
+      def build_producer_thread(resultstream)
+        ::Thread.new {
+          Safe::Thread.current.abort_on_exception = true
+          begin
+            resultstream.sync = true
+            loop do
+              to_publish = queue.shift
+              break if Safe::Symbol[:break] == to_publish
+              resultstream << (to_publish << "\n")
+            end
+          rescue IOError, Errno::EPIPE
+            queue.clear
+          ensure
+            self.queue = NullQueue
+            resultstream.flush rescue nil
+          end
+        }
       end
+
+      def forking_occurred_and_you_are_the_child(resultstream)
+        # clear the queue b/c we don't want to report the same lines 2x,
+        # parent process can report them
+        queue << :fork
+        loop { break if queue.shift == :fork }
+
+        # recreate the thread since forking in Ruby kills threads
+        @producer_thread = Safe::Thread[
+          build_producer_thread(resultstream)
+        ]
+      end
+
     end
   end
 end

data/lib/seeing_is_believing/hard_core_ensure.rb

@@ -33,8 +33,8 @@ class SeeingIsBelieving
 
     def invoke_ensure
       return if ensure_invoked
-      trap 'INT', old_handler
       self.ensure_invoked = true
+      trap 'INT', old_handler
       options[:ensure].call
     end
 

data/lib/seeing_is_believing/safe.rb

@@ -0,0 +1,43 @@
+class SeeingIsBelieving
+  module Safe
+    def self.build(klass, *method_names)
+      options = {}
+      options = method_names.pop if method_names.last.kind_of? ::Hash
+
+      Class.new do
+        class << self
+          alias [] new
+        end
+
+        define_method :initialize do |instance|
+          @_instance = instance
+        end
+
+        methods = method_names.map { |name| [name, klass.instance_method(name)] }
+        methods.each do |name, method|
+          define_method(name) do |*args, &block|
+            method.bind(@_instance).call(*args, &block)
+          end
+        end
+
+        singleton_methods = options.fetch(:class, []).map { |name| [name, klass.method(name)] }
+        singleton_methods.each do |name, method|
+          define_singleton_method name do |*args, &block|
+            method.call(*args, &block)
+          end
+        end
+      end
+    end
+
+    Queue     = build ::Queue, :<<, :shift, :clear
+    Stream    = build ::IO, :sync=, :<<, :flush, :close
+    Symbol    = build ::Symbol, :==, class: [:define_method]
+    String    = build ::String, :to_s
+    Fixnum    = build ::Fixnum, :to_s
+    Array     = build ::Array, :pack, :map, :size, :join
+    Hash      = build ::Hash, :[], :[]=, class: [:new]
+    Marshal   = build ::Marshal, class: [:dump]
+    Exception = build ::Exception, :message, :backtrace, :class, class: [:define_method]
+    Thread    = build ::Thread, :join, class: [:current]
+  end
+end

data/lib/seeing_is_believing/the_matrix.rb

@@ -1,4 +1,5 @@
 require_relative 'version'
+require_relative 'safe'
 require_relative 'event_stream/producer'
 
 sib_vars     = Marshal.load ENV["SIB_VARIABLES.MARSHAL.B64"].unpack('m0').first
@@ -11,16 +12,25 @@ $SiB.record_num_lines         sib_vars.fetch(:num_lines)
 $SiB.record_max_line_captures sib_vars.fetch(:max_line_captures)
 
 STDOUT.sync = true
-stdout, stderr = STDOUT, STDERR
+stdout = SeeingIsBelieving::Safe::Stream[STDOUT]
+stderr = SeeingIsBelieving::Safe::Stream[STDERR]
+
 finish = lambda do
   $SiB.finish!
-  event_stream.close
+  SeeingIsBelieving::Safe::Stream[event_stream].close
   stdout.flush
   stderr.flush
 end
 
 real_exec      = method :exec
+real_fork      = method :fork
 real_exit_bang = method :exit!
+fork_defn      = lambda do |*args|
+  result = real_fork.call(*args)
+  $SiB.send :forking_occurred_and_you_are_the_child, event_stream unless result
+  result
+end
+
 Kernel.module_eval do
   private
 
@@ -38,9 +48,24 @@ Kernel.module_eval do
     finish.call
     real_exit_bang.call(status)
   end
+
+  define_method :fork, &fork_defn
 end
 
+Kernel.define_singleton_method  :fork, &fork_defn
+Process.define_singleton_method :fork, &fork_defn
+
+
+# Some things need to just be recorded and readded as they are called from Ruby C code
+symbol_to_s         = Symbol.instance_method(:to_s)
+exception_message   = Exception.instance_method(:message)
+# exception_backtrace = Exception.instance_method(:backtrace)
+
 at_exit do
+  # SeeingIsBelieving::Safe::Exception.define_method :backtrace, exception_backtrace
+  SeeingIsBelieving::Safe::Exception.define_method :message,   exception_message
+  SeeingIsBelieving::Safe::Symbol.define_method    :to_s,      symbol_to_s
+
   exitstatus = ($! ? $SiB.record_exception(nil, $!) : 0)
   finish.call
   real_exit_bang.call(exitstatus) # clears exceptions so they don't print to stderr and change the processes actual exit status (we recorded what it should be)

data/lib/seeing_is_believing/version.rb

@@ -1,3 +1,3 @@
 class SeeingIsBelieving
-  VERSION = '3.0.0.beta.7'
+  VERSION = '3.0.0'
 end

data/seeing_is_believing.gemspec

@@ -21,13 +21,12 @@ Gem::Specification.new do |s|
 
   s.add_dependency             "parser",   ">= 2.3.0.7", "< 3.0"
 
-  s.add_development_dependency "what_weve_got_here_is_an_error_to_communicate"
   s.add_development_dependency "haiti",    ">= 0.1", "< 0.3"
-  s.add_development_dependency "rake",     "~> 10.0"
-  s.add_development_dependency "mrspec",   "~>  0.3.0"
-  s.add_development_dependency "rspec",    "~>  3.2"
-  s.add_development_dependency "cucumber", "~>  1.2"
-  s.add_development_dependency "ichannel", "~>  5.1"
+  s.add_development_dependency "rake",     "~> 11.2.2"
+  s.add_development_dependency "mrspec",   "~>  0.3.1"
+  s.add_development_dependency "rspec",    "~>  3.5"
+  s.add_development_dependency "cucumber", "~>  2.4"
+  s.add_development_dependency "ichannel", "~>  8.1"
 
   s.post_install_message = <<'Omg, frogs <3'.gsub(/(gg+)/) { |capture| "\e[32m#{capture.gsub 'g', '.'}\e[0m" }.gsub("brown", "\e[33m").gsub("off", "\e[0m")
               .7

data/spec/binary/config_spec.rb

@@ -447,14 +447,26 @@ RSpec.describe SeeingIsBelieving::Binary::Config do
       end
     end
 
-    describe 'debug?' do
-      specify 'debug? defaults to a false' do
+    describe '-g and --debug' do
+      specify 'set debug to true' do
+        expect(parse([])[:debug]).to          eq false
+        expect(parse([]).debug?).to           eq false
+        expect(parse(['-g'])[:debug]).to      eq true
+        expect(parse(['-g']).debug?).to       eq true
+        expect(parse(['--debug'])[:debug]).to eq true
+        expect(parse(['--debug']).debug?).to  eq true
+      end
+    end
+
+    describe '--debug-to FILE' do
+      specify 'sets debug to FILE' do
         expect(parse([])[:debug]).to eq false
+        expect(parse(['--debug-to', 'somefile'])[:debug]).to eq 'somefile'
       end
 
-      specify '-g and --debug set debug? to true' do
-        expect(parse(['-g']).debug?).to eq true
-        expect(parse(['--debug']).debug?).to eq true
+      specify 'sets an error if not given a next arg for the filename' do
+        expect(parse(['--debug-to', 'somefile'])).to_not have_error /--debug-to/
+        expect(parse(['--debug-to'])).to have_error /--debug-to/
       end
     end
 
@@ -555,7 +567,7 @@ RSpec.describe SeeingIsBelieving::Binary::Config do
     let(:stdin_data) { 'stdin data' }
     let(:stdin)      { object_double $stdin, read: stdin_data }
     let(:stdout)     { object_double $stdout }
-    let(:stderr)     { object_double $stderr }
+    let(:stderr)     { object_double $stderr, :tty? => true }
 
     let(:file_class)           { class_double File }
     let(:nonexisting_filename) { 'badfilename'    }
@@ -663,11 +675,52 @@ RSpec.describe SeeingIsBelieving::Binary::Config do
         expect(handler.lib_options.debugger).to_not be_enabled
       end
 
-      specify 'are set to debug to stderr when debug? is true' do
-        handler = call debug: true
-        expect(handler.debugger).to be_enabled
-        expect(handler.debugger.stream).to eq stderr
-        expect(handler.lib_options.debugger).to equal handler.debugger
+      context 'when debug? is true' do
+        specify 'are the same debugger' do
+          handler = call debug: true
+          expect(handler.lib_options.debugger).to equal handler.debugger
+        end
+
+        specify 'print their output to stderr' do
+          handler = call debug: true
+          expect(handler.debugger).to be_enabled
+          expect(handler.debugger.stream).to eq stderr
+        end
+
+        specify 'turn colour on if stderr is a tty' do
+          handler = call debug: true
+          expect(handler.debugger).to be_coloured
+        end
+
+        specify 'turn colour off if stderr isn\'t a tty' do
+          allow(stderr).to receive(:tty?).and_return(false)
+          handler = call debug: true
+          expect(handler.debugger).to_not be_coloured
+        end
+      end
+
+      context 'when debug? is a string' do
+        let(:proving_grounds_dir) { File.expand_path '../../../proving_grounds', __FILE__  }
+        let(:path)                { File.join proving_grounds_dir, 'test.log' }
+        before                    { Dir.mkdir proving_grounds_dir unless Dir.exist? proving_grounds_dir }
+
+        specify 'are the same debugger' do
+          handler = call debug: path
+          expect(handler.lib_options.debugger).to equal handler.debugger
+        end
+
+        specify 'consider the string to be a filename, appending to it' do
+          File.write path, "pre"
+          debugger = call(debug: path).debugger
+          expect(debugger.stream.path).to eq path
+          debugger.context("test")
+          expect(File.read path).to match /pretest/
+        end
+
+        specify 'do not turn colour on' do
+          handler = call debug: path
+          expect(handler.debugger).to_not be_coloured
+        end
       end
     end
   end

data/spec/binary/marker_spec.rb

@@ -47,9 +47,9 @@ RSpec.describe SeeingIsBelieving::Binary::Marker do
 
   it 'requires prefix and a regex' do
     described_class.new prefix: '', regex: //
-    expect { described_class.new }.to raise_error
-    expect { described_class.new prefix: ''  }.to raise_error
-    expect { described_class.new regex:  // }.to raise_error
+    expect { described_class.new }.to raise_error ArgumentError
+    expect { described_class.new prefix: ''  }.to raise_error ArgumentError
+    expect { described_class.new regex:  // }.to raise_error ArgumentError
   end
 
   it 'stores the prefix and a regex' do

data/spec/evaluate_by_moving_files_spec.rb

@@ -142,9 +142,9 @@ RSpec.describe SeeingIsBelieving::EvaluateByMovingFiles do
     expect(seen.last).to eq SeeingIsBelieving::EventStream::Events::Finished.new
   end
 
-  it 'can set a timeout, which KILL interrupts the process and then waits for the events to finish' do
+  it 'can set a timeout, which interrupts the process group and then waits for the events to finish' do
     expect(Timeout).to receive(:timeout).with(123).and_raise(Timeout::Error)
-    expect(Process).to receive(:kill).with("KILL", an_instance_of(Fixnum))
+    expect(Process).to receive(:kill).with("-INT", an_instance_of(Fixnum))
     result = invoke 'p gets', timeout_seconds: 123
     expect(result.timeout?).to eq true
     expect(result.timeout_seconds).to eq 123

data/spec/hard_core_ensure_spec.rb

@@ -43,7 +43,7 @@ RSpec.describe SeeingIsBelieving::HardCoreEnsure do
 
   it 'invokes the code even if an interrupt is sent and there is a default handler' do
     test = lambda do
-      channel = IChannel.new Marshal
+      channel = IChannel.unix
       pid = fork do
         old_handler = trap('INT') { channel.put "old handler invoked" }
         call code: -> { sleep 0.1 }, ensure: -> { channel.put "ensure invoked" }
@@ -66,7 +66,7 @@ RSpec.describe SeeingIsBelieving::HardCoreEnsure do
 
   it 'invokes the code even if an interrupt is sent and interrupts are set to ignore' do
     test = lambda do
-      channel = IChannel.new Marshal
+      channel = IChannel.unix
       pid = fork do
         old_handler = trap 'INT', 'IGNORE'
         result = call code: -> { sleep 0.1; 'code result' }, ensure: -> { channel.put "ensure invoked" }

data/spec/seeing_is_believing_spec.rb

@@ -1,7 +1,10 @@
 # -*- coding: utf-8 -*-
+
+
 require 'spec_helper'
 require 'stringio'
 require 'seeing_is_believing'
+require 'ichannel'
 
 RSpec.describe SeeingIsBelieving do
   def method_result(name)
@@ -507,6 +510,32 @@ RSpec.describe SeeingIsBelieving do
     expect(values_for 'o = BasicObject.new; def o.inspect; "some obj"; end; o').to eq [['some obj']]
   end
 
+  it 'respects timeout, even when children do semi-ridiculous things, it cleans up children rather than orphaning them' do
+    # https://github.com/JoshCheek/seeing_is_believing/issues/53
+    result = invoke <<-RUBY, timeout_seconds: 0.1
+      read, write = IO.pipe
+      fork               # child makes a grandchild
+      puts Process.pid   # print current pid
+      read.read          # block child and grandchild
+    RUBY
+    result.stdout.lines.map(&:to_i).each do |pid|
+      expect { Process.kill 0, pid }.to raise_error(Errno::ESRCH)
+    end
+  end
+
+  it 'does not kill parent processes' do
+    channel = IChannel.unix
+    fork do
+      # it's basically undocumented, but I think 0 makes it choose a new group id
+      # this is so that we don't kill the test if it gets messed up
+      Process.setpgid(Process.pid, 0)
+      channel.put invoke("1"                          ).timeout_seconds
+      channel.put invoke("sleep", timeout_seconds: 0.1).timeout_seconds
+    end
+    expect(channel.get).to eq nil # child exited normally
+    expect(channel.get).to eq 0.1 # child timed out
+  end
+
   context 'when given a debugger' do
     let(:stream)   { StringIO.new }
     let(:debugger) { SeeingIsBelieving::Debugger.new stream: stream }
@@ -529,6 +558,76 @@ RSpec.describe SeeingIsBelieving do
     end
   end
 
+  describe 'fork' do
+    it 'records results from both parent and child, without double reporting items that may have been left in the queue at the time of forking' do
+      n = 10000
+      result = invoke <<-RUBY
+        n  = #{n}
+        as = '0' * n; 0
+        bs = '1' * n; 1
+
+        $$
+        if fork
+          $$
+          print as
+        else
+          $$
+          print bs
+        end
+        $$
+      RUBY
+
+      expect(result[1]).to eq [n.to_s]
+      expect(result[2]).to eq ['0']
+      expect(result[3]).to eq ['1']
+      expect(result[4]).to eq []
+      ppid = result[5][0]
+      pid, null = result[6].sort
+      expect(null).to eq 'nil'
+
+      expect(result[ 7]).to eq [ppid]
+      expect(result[10]).to eq [pid]
+      expect(result[13].sort).to eq [pid, ppid].sort
+
+      zeros, ones = result.stdout.split(/01|10/).sort
+      expect(zeros).to eq ("0"*(n-1)) # spent one on the split
+      expect(ones).to  eq ("1"*(n-1))
+    end
+
+    it 'works for Kernel#fork, Kernel.fork, Process.fork' do
+      result = invoke <<-RUBY
+        $$
+        if fork
+          $$
+        elsif Kernel.fork
+          $$
+        elsif Process.fork
+          $$
+        else
+          $$
+        end
+        $$
+      RUBY
+
+      pid_main = result[1][0]
+
+      pid_private, null = result[2].sort
+      expect(result[3]).to eq [pid_main]
+      expect(null).to eq 'nil'
+
+      pid_kernel,  null = result[4].sort
+      expect(result[5]).to eq [pid_private]
+      expect(null).to eq 'nil'
+
+      pid_process, null = result[6].sort
+      expect(result[7]).to eq [pid_kernel]
+      expect(null).to eq 'nil'
+
+      expect(result[9]).to eq [pid_process]
+      expect(result[11].sort).to eq [pid_main, pid_private, pid_kernel, pid_process].sort
+    end
+  end
+
   describe 'exec' do
     it 'passes stdin, stdout, stderr, and actually does exec the process' do
       result = invoke \
@@ -565,18 +664,209 @@ RSpec.describe SeeingIsBelieving do
   # this is a list of things to check that it can work without.
   # based on this issue: https://github.com/JoshCheek/seeing_is_believing/issues/55
   describe 'it works even in hostile environments' do
-    specify 'when IO does not have sync, <<, and flush'
-    specify 'when Queue does not have <<, shift, and clear'
-    specify 'when Symbol does not have ==, to_s, inspect'
-    specify 'when String does not have ==, to_s, inspect, to_i'
-    specify 'when Fixnum does not have <, next, =='
-    specify 'when Hash does not have [], []='
-    specify 'when Array does not have pack, <<, to_ary, grep, first, [], []='
-    specify 'when Marshal does not have dump'
-    specify 'when Kernel does not have defined?, kind_of?'
-    specify 'when SystemExit does not have status'
-    specify 'when Enumerable does not have map'
-    specify 'when Exception does not have status'
-    specify 'when Thread does not have new, join'
+    specify 'when IO does not have sync=, <<, flush, puts, close' do
+      expect(invoke('class IO
+                       undef sync
+                       undef <<
+                       undef flush
+                       undef puts
+                       undef close
+                     end').stderr).to eq ''
+    end
+
+    specify 'when File does not have sync=, <<, flush, puts, close' do
+      expect(invoke('class File
+                       undef sync
+                       undef <<
+                       undef flush
+                       undef puts
+                       undef close
+                     end').stderr).to eq ''
+    end
+
+    specify 'when Queue does not have <<, shift, and clear' do
+      expect(invoke('class Queue
+                       undef <<
+                       undef shift
+                       undef clear
+                     end').stderr).to eq ''
+    end
+
+    specify 'when Symbol does not have ==, to_s, inspect' do
+      expect(invoke('class Symbol
+                       undef ==
+                       undef to_s
+                       undef inspect
+                     end').stderr).to eq ''
+    end
+
+    specify 'when String does not have ==, to_s, inspect, to_i' do
+      expect(invoke('class String
+                       undef ==
+                       undef to_s
+                       undef to_str
+                       undef inspect
+                       undef to_i
+                     end').stderr).to eq ''
+    end
+
+    specify 'when Fixnum does not have <, <<, next, ==, inspect, to_s' do
+      expect(invoke('class Fixnum
+                       undef <
+                       undef <<
+                       undef ==
+                       undef next
+                       undef to_s
+                       undef inspect
+                     end').stderr).to eq ''
+    end
+
+    specify 'when Hash does not have [], []=, fetch' do
+      RUBY_VERSION == '2.0.0' and
+        skip '2.0.0 implements all the thread stuff in Ruby, with no obvious way to override its attempt to call removed methods'
+      expect(invoke('class Hash
+                       undef []
+                       undef []=
+                       undef fetch
+                     end').stderr).to eq ''
+    end
+
+    specify 'when Array does not have pack, <<, to_ary, grep, first, [], []=, each, map' do
+      expect(invoke('class Array
+                       undef pack
+                       undef <<
+                       undef to_ary
+                       undef grep
+                       undef first
+                       undef []
+                       undef []=
+                       undef each
+                       undef map
+                       undef join
+                       undef size
+                     end').stderr).to eq ''
+    end
+
+    specify 'when Marshal does not have dump, load' do
+      expect(invoke('class << Marshal
+                       undef dump
+                       undef load
+                     end').stderr).to eq ''
+    end
+
+    specify 'when Kernel does not have defined?, kind_of?' do
+      expect(invoke('class Kernel
+                       undef defined?
+                       undef kind_of?
+                     end').stderr).to eq ''
+    end
+
+    specify 'when Enumerable does not have map' do
+      expect(invoke('class Module
+                       undef map
+                     end
+                    ').stderr).to eq ''
+    end
+
+    specify 'when SystemExit does not have status' do
+      # its fine to blow up if they undefine it and then they call exit,
+      # that's probably the expected behaviour
+      # But our code should be as resilient as possible,
+      # so shouldn't blow up b/c some feature happened to call exit
+      expect(invoke('class SystemExit
+                       undef status
+                     end
+                    ').stderr).to eq ''
+    end
+
+    specify 'when Exception does not have message, class (can\'t get backtrace to work)' do
+      result = invoke('class Exception
+                         undef message
+                         # undef backtrace
+                         undef class
+                       end
+                       raise "hello"
+                      ')
+      expect(result.exception.message).to eq 'hello'
+      # expect(result.exception.backtrace).to eq 'hello'
+      expect(result.exception.class_name).to eq 'RuntimeError'
+    end
+
+    specify 'when Thread does not have .new, .current, #join, #abort_on_exception' do
+      expect(invoke('class << Thread
+                       undef new
+                       undef current if "2.0.0" != RUBY_VERSION && "1.9.3" != RUBY_VERSION
+                     end
+                     class Thread
+                       undef join
+                       undef abort_on_exception
+                     end
+                    ').stderr).to eq ''
+    end
+
+    specify 'when Class does not have new, allocate, singleton_class, class_eval' do
+      expect(invoke('class Class
+                       undef new
+                       undef allocate
+                       undef singleton_class
+                       undef class_eval
+                     end
+                    ').stderr).to eq ''
+    end
+
+    specify 'when Class#new is overridden' do
+      result = invoke('class Class
+                         def new(arg)
+                           arg
+                         end
+                       end
+                       class A
+                       end
+                       A.new 123')
+      expect(result.exception).to eq nil
+      expect(result[3]).to eq ["123"]
+    end
+
+    specify 'when BasicObject does not have initialize' do
+      expect(invoke('class BasicObject
+                       undef initialize
+                     end
+                    ').stderr).to eq ''
+    end
+
+    specify 'when Module does not have define_method, instance_method' do
+      expect(invoke('class Module
+                       undef define_method
+                       undef instance_method
+                     end
+                    ').stderr).to eq ''
+    end
+
+    context 'not clear that there are good ways to deal with these' do
+      before { skip }
+
+      specify 'when UnboundMethod does not have bind' do
+        expect(invoke('class UnboundMethod
+                         undef bind
+                       end
+                      ').stderr).to eq ''
+      end
+
+      specify 'when Method does not have call' do
+        expect(invoke('class Method
+                         undef call
+                       end
+                      ').stderr).to eq ''
+      end
+      specify 'when Proc does not have call, to_proc' do
+        expect(invoke('class Proc
+                         undef call
+                         undef to_proc
+                       end
+                      ').stderr).to eq ''
+      end
+    end
   end
 end
+
+# all of them together