test-loop 11.0.0 → 12.2.0

data/LICENSE

@@ -0,0 +1,17 @@
+(the ISC license)
+
+Copyright 2010 Suraj N. Kurapati <sunaku@gmail.com>
+Copyright 2011 Brian D. Burns <burns180@gmail.com>
+Copyright 2011 Daniel Pittman <daniel@rimspace.net>
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted, provided that the above
+copyright notice and this permission notice appear in all copies.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.

data/README.md

@@ -4,33 +4,50 @@ test-loop - Continuous testing for Ruby with fork/eval
 test-loop is a fast continuous testing tool for Ruby that automatically
 detects and tests changes in your application in an efficient manner:
 
-1. Absorbs the test execution overhead into the main Ruby process.
-2. Forks to run your test files without overhead and in parallel.
-3. Avoids running unchanged test blocks inside changed test files.
+  1. Absorbs the test execution overhead into the main Ruby process.
+
+  2. Forks to run your test files without overhead and in parallel.
+
+  3. Avoids running unchanged test blocks inside changed test files.
 
 ------------------------------------------------------------------------------
 Features
 ------------------------------------------------------------------------------
 
-* Tests *changes* in your Ruby application: avoids running (1) unchanged
-  test files and (2) unchanged test blocks inside changed test files.
+  * Tests *changes* in your Ruby application: avoids running (1) unchanged
+    test files and (2) unchanged test blocks inside changed test files.
+
+  * Supports Test::Unit, RSpec, and any other testing framework that (1)
+    reflects failures in the process' exit status and (2) is loaded by your
+    application's `test/test_helper.rb` or `spec/spec_helper.rb` file.
+
+  * Reabsorbs test execution overhead if the test or spec helper file changes.
+
+  * Executes test files in parallel, making full use of multiple processors.
 
-* Supports Test::Unit, RSpec, and any other testing framework that (1)
-  reflects failures in the process' exit status and (2) is loaded by your
-  application's `test/test_helper.rb` or `spec/spec_helper.rb` file.
+  * Logs the output from your tests into separate files: one log per test.
+    The path to a log file is simply the path of its test file plus ".log".
 
-* Reabsorbs test execution overhead if the test or spec helper file changes.
+  * Generally I/O bound, so you can keep it running without CPU slowdown.
+
+  * Configurable through a `.test-loop` file in your working directory.
+
+  * Implemented in less than 240 lines (SLOC) of pure Ruby code! :-)
+
+------------------------------------------------------------------------------
+Prerequisites
+------------------------------------------------------------------------------
 
-* Executes test files in parallel, making full use of multiple processors.
+  * Ruby 1.8.7 or 1.9.2 or newer.
 
-* Logs the output from your tests into separate files: one log per test file.
-  The path to a log file is simply the path of its test file plus ".log".
+  * Operating system that supports POSIX signals and the `fork()` system call.
 
-* Generally I/O bound, so you can have it always running without CPU slowdown.
+    To check if your system qualifies, launch `irb` and enter the following:
 
-* Configurable through a `.test-loop` file in your current working directory.
+        Process.respond_to? :fork                    # must be true
 
-* Implemented in less than 250 lines (SLOC) of pure Ruby code! :-)
+        signals = %w[INT TSTP QUIT TERM CHLD].sort
+        Signal.list.keys.sort & signals == signals   # must be true
 
 ------------------------------------------------------------------------------
 Installation
@@ -59,19 +76,23 @@ If installed as a Git clone:
 
 You can monitor your test processes in another terminal:
 
-    watch 'ps xf | grep test-loop | sed 1,3d'
+    watch 'ps xfw | sed -n "1p; /test-loop/p" | fgrep -v sed'
+
+If it stops responding, you can annihilate test-loop from another terminal:
+
+    pkill -9 -f test-loop
 
 ------------------------------------------------------------------------------
 Operation
 ------------------------------------------------------------------------------
 
-* Press Control-Z or send the SIGTSTP signal to forcibly run all
-  tests, even if there are no changes in your Ruby application.
+  * Press Control-Z or send the SIGTSTP signal to forcibly run all
+    tests, even if there are no changes in your Ruby application.
 
-* Press Control-\ or send the SIGQUIT signal to forcibly reabsorb
-  the test execution overhead, even if its sources have not changed.
+  * Press Control-\\ or send the SIGQUIT signal to forcibly reabsorb
+    the test execution overhead, even if its sources have not changed.
 
-* Press Control-C or send the SIGINT signal to quit the test loop.
+  * Press Control-C or send the SIGINT signal to quit the test loop.
 
 ------------------------------------------------------------------------------
 Configuration
@@ -81,19 +102,23 @@ test-loop looks for a configuration file named `.test-loop` in the current
 working directory.  This configuration file is a normal Ruby script in which
 you can query and modify the `Test::Loop` OpenStruct configuration as follows:
 
+### Test::Loop.delay_per_iteration
+
+Number of seconds to wait after each loop iteration.  The default value is 1.
+
 ### Test::Loop.overhead_file_globs
 
-An array of file globbing patterns that describe a set of Ruby scripts that
-are loaded into the main Ruby process as overhead.
+Array of file globbing patterns that describe a set of Ruby scripts that are
+loaded into the main Ruby process as overhead.
 
 ### Test::Loop.reabsorb_file_globs
 
-An array of file globbing patterns that describe a set of files which cause
-the overhead to be reabsorbed whenever they change.
+Array of file globbing patterns that describe a set of files which cause the
+overhead to be reabsorbed whenever they change.
 
 ### Test::Loop.test_file_matchers
 
-A hash that maps a file globbing pattern describing a set of source files to a
+Hash that maps a file globbing pattern describing a set of source files to a
 lambda function yielding a file globbing pattern describing a set of test
 files that need to be run.  In other words, whenever the source files (the
 hash key; left-hand side of the mapping) change, their associated test files
@@ -102,8 +127,8 @@ hash key; left-hand side of the mapping) change, their associated test files
 For example, if test files had the same names as their source files followed
 by an underscore and the file name in reverse like this:
 
-* `lib/hello.rb` => `test/hello_olleh.rb`
-* `app/world.rb` => `spec/world_ldrow.rb`
+  * `lib/hello.rb` => `test/hello_olleh.rb`
+  * `app/world.rb` => `spec/world_ldrow.rb`
 
 Then you would add the following to your configuration file:
 
@@ -128,9 +153,9 @@ will return `nil`, thereby excluding those source files from being tested.
 
 ### Test::Loop.test_name_parser
 
-A lambda function that is passed a line of source code to determine whether
-that line can be considered as a test definition, in which case it must return
-the name of the test being defined.
+Lambda function that is passed a line of source code to determine whether that
+line can be considered as a test definition, in which case it must return the
+name of the test being defined.
 
 ### Test::Loop.before_each_test
 
@@ -188,7 +213,8 @@ preset does this for you):
       unless run_status.success? or run_status.signaled?
         title = 'FAIL at %s in %0.1fs' % [started_at.strftime('%r'), elapsed_time]
 
-        message = test_file
+        statistics = File.readlines(log_file).grep(/^\d+ \w+,/)
+        message = test_file + "\n" + statistics.join
 
         Thread.new do # run in background
           system 'notify-send', '-i', 'dialog-error', title, message or
@@ -210,7 +236,8 @@ configuration file:
       title = '%s at %s in %0.1fs' %
         [success ? 'PASS' : 'FAIL', started_at.strftime('%X'), elapsed_time]
 
-      message = test_file
+      statistics = File.readlines(log_file).grep(/^\d+ \w+,/)
+      message = test_file + "\n" + statistics.join
 
       Thread.new do # run in background
         system 'notify-send', '-i', "dialog-#{success ? 'information' : 'error'}", title, message or
@@ -220,7 +247,7 @@ configuration file:
     }
 
 ------------------------------------------------------------------------------
-Configuration Presets
+Configuration presets
 ------------------------------------------------------------------------------
 
 The following sub-libraries provide "preset" configurations.  To use them,
@@ -231,26 +258,34 @@ your application's `test/test_helper.rb` or `spec/spec_helper.rb` file.
 
 Shows on-screen-display notifications for test failures.
 
+### require 'test/loop/rails'
+
+Provides support for the Ruby on Rails web framework.
+
+### require 'test-loop/coco'
+
+Integrates the [coco](https://github.com/lkdjiin/coco) code coverage library.
+
 ------------------------------------------------------------------------------
 Known issues
 ------------------------------------------------------------------------------
 
 ### Ruby on Rails
 
-* Ensure that your `config/environments/test.rb` file disables class caching
-  as follows (**NOTE:** this is done automatically for you if you use Rails
-  3):
+  * Ensure that your `config/environments/test.rb` file disables class caching
+    as follows (**NOTE:** if you are using Rails 3, the `test/loop/rails`
+    preset will automatically do this for you):
 
-      config.cache_classes = false
+        config.cache_classes = false
 
-  Otherwise, test-loop will appear to ignore source-code changes in your
-  models, controllers, helpers, and other Ruby source files.
+    Otherwise, test-loop will appear to ignore source-code changes in your
+    models, controllers, helpers, and other Ruby source files.
 
-* SQLite3 [raises `SQLite3::BusyException: database is locked` errors](
-  https://github.com/sunaku/test-loop/issues/2 ) because test-loop runs your
-  test files in parallel.  You can work around this by using an [in-memory
-  adapter for SQLite3]( https://github.com/mvz/memory_test_fix ) or by using
-  different database software (such as MySQL) for your test environment.
+  * SQLite3 [raises `SQLite3::BusyException: database is locked` errors](
+    https://github.com/sunaku/test-loop/issues/2 ) because test-loop runs your
+    test files in parallel.  You can work around this by using an [in-memory
+    adapter for SQLite3]( https://github.com/mvz/memory_test_fix ) or by using
+    different database software (such as MySQL) for your test environment.
 
 ------------------------------------------------------------------------------
 License

data/bin/test-loop

@@ -1,4 +1,4 @@
 #!/usr/bin/env ruby
 require 'test/loop'
 Test::Loop.run
-exit! true # skip at_exit() handlers registered in the master process
+raise SystemExit # prevent empty test suite run in master process

data/lib/test/loop/notify.rb

@@ -4,7 +4,8 @@ Test::Loop.after_each_test.push lambda {
   |test_file, log_file, run_status, started_at, elapsed_time|
   unless run_status.success? or run_status.signaled?
     title = 'FAIL at %s in %0.1fs' % [started_at.strftime('%r'), elapsed_time]
-    message = test_file
+    statistics = File.readlines(log_file).grep(/^\d+ \w+,/)
+    message = test_file + "\n" + statistics.join
     Thread.new do # run in background
       system 'notify-send', '-i', 'dialog-error', title, message or
       system 'growlnotify', '-a', 'Xcode', '-m', message, title or

data/lib/test/loop/rails.rb

@@ -0,0 +1,20 @@
+require 'test/loop'
+
+Test::Loop.reabsorb_file_globs.push(
+  'config/**/*.{rb,yml}',
+  'db/schema.rb',
+  'Gemfile.lock'
+)
+
+Test::Loop.test_file_matchers['{app,lib,test,spec}/**/*.rb'] =
+  Test::Loop.test_file_matchers.delete('lib/**/*.rb')
+
+require 'rails/railtie'
+Class.new Rails::Railtie do
+  config.before_initialize do |app|
+    if app.config.cache_classes
+      warn "test-loop: Setting #{app.class}.config.cache_classes = false"
+      app.config.cache_classes = false
+    end
+  end
+end

data/lib/test/loop.rb

@@ -4,6 +4,8 @@ require 'diff/lcs'
 module Test
   Loop = OpenStruct.new
 
+  Loop.delay_per_iteration = 1
+
   Loop.overhead_file_globs = ['{test,spec}/{test,spec}_helper.rb']
 
   Loop.reabsorb_file_globs = Loop.overhead_file_globs.dup
@@ -49,19 +51,15 @@ module Test
 
   class << Loop
     def run
-      @running_files = []
-      @running_files_lock = Mutex.new
-      @lines_by_file = {} # path => readlines
-      @last_ran_at = @started_at = Time.now
-
-      register_signals
+      init_shared_vars
+      trap_user_signals
       load_user_config
-      absorb_overhead
-      load_lib_support
-      run_test_loop
+      load_user_overhead
+      init_worker_queue
+      enter_testing_loop
 
     rescue Interrupt
-      # allow user to break the loop by pressing Ctrl-C or sending SIGINT
+      # allow user to break the loop
 
     rescue Exception => error
       STDERR.puts error.inspect, error.backtrace
@@ -69,19 +67,23 @@ module Test
       reload_master_process
 
     ensure
-      kill_workers
+      stop_worker_queue
       notify 'Goodbye!'
     end
 
     private
 
-    EXEC_VECTOR = [$0, *ARGV].map {|s| s.dup.freeze }.freeze
+    MASTER_EXECV = [$0, *ARGV].map {|s| s.dup.freeze }.freeze
+    MASTER_ENV = Hash[ENV.map {|k,v| [k.freeze, v.freeze] }].freeze
     RESUME_ENV_KEY = 'TEST_LOOP_RESUME_FILES'.freeze
 
     ANSI_CLEAR_LINE = "\e[2K\e[0G".freeze
     ANSI_GREEN = "\e[32m%s\e[0m".freeze
     ANSI_RED = "\e[31m%s\e[0m".freeze
 
+    Worker = Struct.new(:test_file, :log_file, :started_at, :finished_at,
+                        :exit_status)
+
     def notify message
       # using print() because puts() is not an atomic operation.
       # also, clear the line before printing because some shells emit
@@ -89,49 +91,48 @@ module Test
       print "#{ANSI_CLEAR_LINE}test-loop: #{message}\n"
     end
 
-    def register_signals
-      # this signal is ignored in master and honored in workers, so all
-      # workers can be killed by sending it to the entire process group
-      trap :TERM, :IGNORE
-
-      master_pid = $$
-      master_trap = lambda do |signal, &handler|
-        trap signal do
-          if $$ == master_pid
-            handler.call
-          else
-            # ignore future ocurrences of this signal in worker processes
-            trap signal, :IGNORE
-          end
-        end
-      end
+    def pause_momentarily
+      sleep delay_per_iteration
+    end
 
-      master_trap.call(:QUIT) { reload_master_process }
-      master_trap.call(:TSTP) { forcibly_run_all_tests }
+    def init_shared_vars
+      @lines_by_file = {} # path => readlines
+      @last_ran_at = @started_at = Time.now
+      @worker_by_pid = {}
     end
 
-    def kill_workers
-      notify 'Stopping tests...'
-      Process.kill :TERM, -$$
-      Process.waitall
+    def trap_user_signals
+      trap(:INT) { raise Interrupt }
+      trap(:TSTP) { forcibly_run_all_tests }
+      trap(:QUIT) { reload_master_process }
+    end
+
+    def forcibly_run_all_tests
+      notify 'Running all tests...'
+      @last_ran_at = Time.at(0)
+      @lines_by_file.clear
     end
 
     # The given test files are passed down (along with currently running
     # test files) to the next incarnation of test-loop for resumption.
     def reload_master_process test_files = []
-      @running_files_lock.synchronize { test_files.concat @running_files }
-      kill_workers
-      exec({RESUME_ENV_KEY => test_files.inspect}, *EXEC_VECTOR)
+      test_files.concat currently_running_test_files
+      stop_worker_queue
+      ENV.replace MASTER_ENV.merge(RESUME_ENV_KEY => test_files.inspect)
+      exec(*MASTER_EXECV)
     end
 
     def load_user_config
       if File.exist? config_file = File.join(Dir.pwd, '.test-loop')
         notify 'Loading configuration...'
         load config_file
+
+        # ...and if the configuration file changes, reload everything.
+        reabsorb_file_globs.push config_file
       end
     end
 
-    def absorb_overhead
+    def load_user_overhead
       notify 'Absorbing overhead...'
       $LOAD_PATH.unshift 'lib', 'test', 'spec'
       Dir[*overhead_file_globs].each do |file|
@@ -139,23 +140,11 @@ module Test
       end
     end
 
-    def load_lib_support
-      Dir[File.expand_path '../loop/support/*.rb', __FILE__].each {|f| load f }
-    end
-
-    def pause_momentarily
-      sleep 1
-    end
-
-    def forcibly_run_all_tests
-      notify 'Running all tests...'
-      @last_ran_at = Time.at(0)
-      @lines_by_file.clear
-    end
-
-    def run_test_loop
+    def enter_testing_loop
       notify 'Ready for testing!'
       loop do
+        reap_worker_queue
+
         # find test files that have been modified since the last run
         test_files = test_file_matchers.map do |source_glob, test_matcher|
           Dir[source_glob].select {|file| File.mtime(file) > @last_ran_at }.
@@ -179,38 +168,85 @@ module Test
 
         # fork workers to run the test files in parallel,
         # excluding test files that are already running
-        test_files = @running_files_lock.
-          synchronize { test_files - @running_files }
-
+        test_files -= currently_running_test_files
         unless test_files.empty?
           @last_ran_at = Time.now
-          test_files.each {|file| run_test_file file }
+          test_files.each {|file| fork_worker Worker.new(file) }
         end
 
         pause_momentarily
       end
     end
 
-    def run_test_file test_file
-      @running_files_lock.synchronize { @running_files.push test_file }
-      log_file = test_file + '.log'
+    def currently_running_test_files
+      @worker_by_pid.values.map(&:test_file)
+    end
+
+    def init_worker_queue
+      # collect children (of which some may be workers) for reaping below
+      @exited_child_infos = []
+      trap :CHLD do
+        finished_at = Time.now
+        begin
+          while wait2_array = Process.wait2(-1, Process::WNOHANG)
+            @exited_child_infos.push [wait2_array, finished_at]
+          end
+        rescue SystemCallError
+          # raised by wait() when there are no child processes at all
+        end
+      end
+    end
+
+    # reap finished workers from previous iterations of the loop
+    def reap_worker_queue
+      while info = @exited_child_infos.shift
+        (child_pid, exit_status), finished_at = info
+        if worker = @worker_by_pid.delete(child_pid)
+          worker.exit_status = exit_status
+          worker.finished_at = finished_at
+          reap_worker worker
+        end
+      end
+    end
+
+    def stop_worker_queue
+      notify 'Stopping tests...'
+      trap :CHLD, 'DEFAULT'
+      @worker_by_pid.each_key do |worker_pid|
+        begin
+          Process.kill :TERM, -worker_pid
+        rescue SystemCallError
+          # worker is already terminated
+        end
+      end
+      Process.waitall
+    end
+
+    def fork_worker worker
+      notify "TEST #{worker.test_file}"
+
+      worker.log_file = worker.test_file + '.log'
 
       # cache the contents of the test file for diffing below
-      new_lines = File.readlines(test_file)
-      old_lines = @lines_by_file[test_file] || new_lines
-      @lines_by_file[test_file] = new_lines
+      new_lines = File.readlines(worker.test_file)
+      old_lines = @lines_by_file[worker.test_file] || new_lines
+      @lines_by_file[worker.test_file] = new_lines
+
+      worker.started_at = Time.now
+      pid = fork do
+        # detach worker from master's terminal device so that
+        # it does not receieve the user's control-key presses
+        Process.setsid
 
-      worker_pid = fork do
-        # this signal is ignored in master and honored in workers, so all
-        # workers can be killed by sending it to the entire process group
-        trap :TERM, :DEFAULT
+        # unregister signal handlers inherited from master process
+        [:INT, :TSTP, :QUIT].each {|sig| trap sig, 'DEFAULT' }
 
-        # this signal is honored by master and ignored in workers
-        trap :INT, :IGNORE
+        # detach worker from master's standard input stream
+        STDIN.reopen IO.pipe.first
 
         # capture test output in log file because tests are run in parallel
         # which makes it difficult to understand interleaved output thereof
-        $stderr.reopen($stdout.reopen(log_file, 'w')).sync = true
+        STDERR.reopen(STDOUT.reopen(worker.log_file, 'w')).sync = true
 
         # determine which test blocks have changed inside the test file
         test_names = Diff::LCS.diff(old_lines, new_lines).flatten.map do |change|
@@ -226,39 +262,34 @@ module Test
         end.compact.uniq
 
         # tell the testing framework to run only the changed test blocks
-        before_each_test.each {|f| f.call test_file, log_file, test_names }
+        before_each_test.each do |hook|
+          hook.call worker.test_file, worker.log_file, test_names
+        end
 
         # make the process title Test::Unit friendly and ps(1) searchable
-        $0 = "test-loop #{test_file}"
+        $0 = "test-loop #{worker.test_file}"
 
         # after loading the user's test file, the at_exit() hook of the
         # user's testing framework will take care of running the tests and
         # reflecting any failures in the worker process' exit status
-        load test_file
+        load worker.test_file
       end
 
-      # monitor and report on the worker's progress
-      Thread.new do
-        notify "TEST #{test_file}"
-
-        # wait for worker to finish
-        Process.waitpid worker_pid
-        run_status = $?
-        elapsed_time = Time.now - @last_ran_at
-
-        # report test results along with any failure logs
-        if run_status.success?
-          notify ANSI_GREEN % "PASS #{test_file}"
-        elsif run_status.exited?
-          notify ANSI_RED % "FAIL #{test_file}"
-          STDERR.print File.read(log_file)
-        end
+      @worker_by_pid[pid] = worker
+    end
 
-        after_each_test.each do |f|
-          f.call test_file, log_file, run_status, @last_ran_at, elapsed_time
-        end
+    def reap_worker worker
+      # report test results along with any failure logs
+      if worker.exit_status.success?
+        notify ANSI_GREEN % "PASS #{worker.test_file}"
+      elsif worker.exit_status.exited?
+        notify ANSI_RED % "FAIL #{worker.test_file}"
+        STDERR.print File.read(worker.log_file)
+      end
 
-        @running_files_lock.synchronize { @running_files.delete test_file }
+      after_each_test.each do |hook|
+        hook.call worker.test_file, worker.log_file, worker.exit_status,
+                  worker.started_at, worker.finished_at - worker.started_at
       end
     end
   end

metadata

@@ -2,17 +2,17 @@
 name: test-loop
 version: !ruby/object:Gem::Version 
   prerelease: 
-  version: 11.0.0
+  version: 12.2.0
 platform: ruby
 authors: 
 - Suraj N. Kurapati
 - Brian D. Burns
+- Daniel Pittman
 autorequire: 
 bindir: bin
 cert_chain: []
 
-date: 2011-04-14 00:00:00 -07:00
-default_executable: 
+date: 2011-06-01 00:00:00 Z
 dependencies: 
 - !ruby/object:Gem::Dependency 
   name: diff-lcs
@@ -34,14 +34,12 @@ extensions: []
 extra_rdoc_files: []
 
 files: 
+- LICENSE
 - README.md
 - bin/test-loop
 - lib/test/loop.rb
 - lib/test/loop/notify.rb
-- lib/test/loop/support/rails.rb
-- lib/test/loop/support/minitest.rb
-- lib/test/loop/support/testunit.rb
-has_rdoc: true
+- lib/test/loop/rails.rb
 homepage: http://github.com/sunaku/test-loop
 licenses: []
 
@@ -65,7 +63,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 
 rubyforge_project: 
-rubygems_version: 1.6.2
+rubygems_version: 1.8.5
 signing_key: 
 specification_version: 3
 summary: Continuous testing for Ruby with fork/eval

data/lib/test/loop/support/minitest.rb

@@ -1,5 +0,0 @@
-if defined? MiniTest::Unit
-  Test::Loop.before_each_test.push proc {
-    MiniTest::Unit.output = $stdout
-  }
-end

data/lib/test/loop/support/rails.rb

@@ -1,21 +0,0 @@
-if defined? Rails::VERSION
-  Test::Loop.reabsorb_file_globs.push(
-    'config/**/*.{rb,yml}',
-    'test/factories/*.rb',
-    'Gemfile.lock'
-  )
-
-  Test::Loop.test_file_matchers['app/**/*.rb'] =
-    Test::Loop.test_file_matchers['lib/**/*.rb']
-
-  class << Test::Loop
-    class Railtie < Rails::Railtie
-      config.before_initialize do |app|
-        if app.config.cache_classes
-          warn "test-loop: Setting #{app.class}.config.cache_classes = false"
-          app.config.cache_classes = false
-        end
-      end
-    end
-  end
-end

data/lib/test/loop/support/testunit.rb

@@ -1,7 +0,0 @@
-if defined? Test::Unit::AutoRunner
-  Test::Loop.before_each_test.push proc {
-    Test::Unit::AutoRunner.prepare do |config|
-      config.runner_options[:output] = $stdout
-    end
-  }
-end