TwP-turn 0.5.1

data/lib/turn/runners/solorunner.rb

@@ -0,0 +1,8 @@
+module Turn
+  require 'turn/runners/isorunner'
+
+  class SoloRunner < IsoRunner
+  end
+
+end
+

data/lib/turn/runners/testrunner.rb

@@ -0,0 +1,154 @@
+#require 'test/unit'; Test::Unit.run = false
+require 'test/unit/ui/console/testrunner'
+
+#require 'turn/colorize'
+#require 'turn/components/suite.rb'
+#require 'turn/components/case.rb'
+#require 'turn/components/method.rb'
+#require 'turn/reporters/outline_reporter.rb'
+#require 'turn/reporters/progress_reporter.rb'
+
+module Turn
+
+  # = TestUnit TestRunner
+  #
+  #--
+  # TODO: Add minitest runner.
+  #++
+  class TestRunner < ::Test::Unit::UI::Console::TestRunner
+
+    def initialize(controller)
+      output_level = 2 # 2-NORMAL 3-VERBOSE
+
+      controller.loadpath.each{ |path| $: << path } unless controller.live?
+      controller.requires.each{ |path| require(path) }
+
+      [controller.files].flatten.each{ |path| require(path) }
+
+      sub_suites = []
+      ObjectSpace.each_object(Class) do |klass|
+        if(Test::Unit::TestCase > klass)
+          sub_suites << klass.suite
+        end
+      end
+      suite = Test::Unit::TestSuite.new('')  # FIXME: Name?
+      sub_suites.sort_by{|s|s.name}.each{|s| suite << s}
+
+      @t_reporter = controller.reporter
+
+      super(suite, output_level, $stdout)
+    end
+
+    # Is this needed?
+    alias :t_attach_to_mediator :attach_to_mediator
+
+    def attach_to_mediator
+      @mediator.add_listener(::Test::Unit::UI::TestRunnerMediator::STARTED, &method(:t_started))
+      @mediator.add_listener(::Test::Unit::UI::TestRunnerMediator::FINISHED, &method(:t_finished))
+      @mediator.add_listener(::Test::Unit::TestSuite::STARTED, &method(:t_case_started))
+      @mediator.add_listener(::Test::Unit::TestSuite::FINISHED, &method(:t_case_finished))
+      @mediator.add_listener(::Test::Unit::TestCase::STARTED, &method(:t_test_started))
+      @mediator.add_listener(::Test::Unit::TestCase::FINISHED, &method(:t_test_finished))
+      @mediator.add_listener(::Test::Unit::TestResult::FAULT, &method(:t_fault))
+
+      @io.sync    = true
+
+      @t_result   = nil
+      @t_fault    = nil
+
+      @t_previous_run_count       = 0
+      @t_previous_error_count     = 0
+      @t_previous_failure_count   = 0
+      @t_previous_assertion_count = 0
+    end
+
+    def t_started(result)
+      @t_suite = Turn::TestSuite.new #@suite
+      @t_suite.size = @suite.size
+      @t_result = result
+      @t_reporter.start_suite(@t_suite)
+    end
+
+    def t_case_started(name)
+      # Err.. why is testunit running this on the suite?
+      (@not_first_case = true; return) unless @not_first_case
+      @t_case = @t_suite.new_case(name)
+      @t_reporter.start_case(@t_case)
+    end
+
+    def t_test_started(name)
+      methname, tcase = name.scan(%r/^([^\(]+)\(([^\)]+)\)/o).flatten!
+      @t_test = @t_case.new_test(methname)
+      #@t_test.file = tcase
+      #@t_test.name = method
+      @t_reporter.start_test(@t_test)
+    end
+
+    def t_fault(fault)
+      case fault
+      when ::Test::Unit::Error
+        msg = ""
+        msg << fault.to_s.split("\n")[2..-1].join("\n")
+        @t_test.error!(msg)
+        @t_reporter.error(msg)
+      when ::Test::Unit::Failure
+        msg = ""
+        msg << fault.location[0] << "\n"
+        msg << fault.message #.gsub("\n","\n")
+        @t_test.fail!(msg)
+        @t_reporter.fail(msg)
+      end
+    end
+
+    def t_test_finished(name)
+      @t_reporter.pass if @t_test.pass?
+      @t_reporter.finish_test(@t_test)
+    end
+
+      def t_case_finished(name)
+      # Err.. why is testunit running this on the suite?
+      return if name=='' # FIXME skip suite call
+
+      #t = @t_result.run_count       - @t_previous_run_count
+      #f = @t_result.failure_count   - @t_previous_failure_count
+      #e = @t_result.error_count     - @t_previous_error_count
+      a = @t_result.assertion_count - @t_previous_assertion_count
+
+      #@t_case.counts(t,a,f,e)
+
+      @t_case.count_assertions = a
+
+      #@t_previous_run_count       = @t_result.run_count.to_i
+      #@t_previous_failure_count   = @t_result.failure_count.to_i
+      #@t_previous_error_count     = @t_result.error_count.to_i
+      @t_previous_assertion_count = @t_result.assertion_count.to_i
+
+      @t_reporter.finish_case(@t_case)
+    end
+
+    def t_finished(elapsed_time)
+      #@t_suite.count_tests      = @t_result.run_count
+      #@t_suite.count_failures   = @t_result.failure_count
+      #@t_suite.count_errors     = @t_result.error_count
+      #@t_suite.count_passes     = @t_result.run_count - @t_result.failure_count - @t_result.error_count
+      @t_suite.count_assertions = @t_result.assertion_count
+
+      @t_reporter.finish_suite(@t_suite)
+    end
+
+    # This is copied verbatim from test/unit/ui/console/testrunner.rb.
+    # It is here for one simple reason: to supress testunits output of
+    # "Loaded Suite".
+    def setup_mediator
+      @mediator = create_mediator(@suite)
+      suite_name = @suite.to_s
+      if ( @suite.kind_of?(Module) )
+        suite_name = @suite.name
+      end
+      #output("Loaded suite #{suite_name}")
+    end
+
+  end#class TestRunner
+
+end#module Turn
+

data/test/test_example.rb

@@ -0,0 +1,15 @@
+require 'test/unit'
+#require 'turn'
+
+class TC_Example < Test::Unit::TestCase
+
+  def test_example_pass
+    assert_equal(4,4)
+  end
+
+  def test_example_fail
+    assert_equal(2,3)
+  end
+
+end
+

data/test/test_sample.rb

@@ -0,0 +1,15 @@
+require 'test/unit'
+require 'turn'
+
+class TC_Sample < Test::Unit::TestCase
+
+  def test_sample_pass
+    assert_equal(1,1)
+  end
+
+  def test_sample_fail
+    assert_equal(1,2)
+  end
+
+end
+

data/turn.gemspec

@@ -0,0 +1,37 @@
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{turn}
+  s.version = "0.5.1"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Tim Pease"]
+  s.date = %q{2009-03-26}
+  s.default_executable = %q{turn}
+  s.description = %q{TURN is a new way to view Test::Unit results. With longer running tests, it can be very frustrating to see a failure (....F...) and then have to wait till all the tests finish before you can see what the exact failure was. TURN displays each test on a separate line with failures being displayed immediately instead of at the end of the tests.  If you have the 'facets' gem installed, then TURN output will be displayed in wonderful technicolor (but only if your terminal supports ANSI color codes). Well, the only colors are green and red, but that is still color.}
+  s.email = %q{tim.pease@gmail.com}
+  s.executables = ["turn"]
+  s.extra_rdoc_files = ["History.txt", "README.txt", "Release.txt", "bin/turn"]
+  s.files = ["History.txt", "README.txt", "Rakefile", "Release.txt", "VERSION", "bin/turn", "lib/turn.rb", "lib/turn/colorize.rb", "lib/turn/command.rb", "lib/turn/components/case.rb", "lib/turn/components/method.rb", "lib/turn/components/suite.rb", "lib/turn/controller.rb", "lib/turn/reporter.rb", "lib/turn/reporters/dot_reporter.rb", "lib/turn/reporters/marshal_reporter.rb", "lib/turn/reporters/outline_reporter.rb", "lib/turn/reporters/progress_reporter.rb", "lib/turn/runners/crossrunner.rb", "lib/turn/runners/isorunner.rb", "lib/turn/runners/loadrunner.rb", "lib/turn/runners/solorunner.rb", "lib/turn/runners/testrunner.rb", "test/test_example.rb", "test/test_sample.rb", "turn.gemspec", "work/quicktest.rb", "work/turn.rb"]
+  s.has_rdoc = true
+  s.homepage = %q{http://codeforpeople.rubyforge.org/turn}
+  s.rdoc_options = ["--main", "README.txt"]
+  s.require_paths = ["lib"]
+  s.rubyforge_project = %q{codeforpeople}
+  s.rubygems_version = %q{1.3.1}
+  s.summary = %q{Test::Unit Reporter (New) -- new output format for Test::Unit}
+  s.test_files = ["test/test_example.rb", "test/test_sample.rb"]
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 2
+
+    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
+      s.add_development_dependency(%q<bones>, [">= 2.4.2"])
+    else
+      s.add_dependency(%q<bones>, [">= 2.4.2"])
+    end
+  else
+    s.add_dependency(%q<bones>, [">= 2.4.2"])
+  end
+end

data/work/quicktest.rb

@@ -0,0 +1,42 @@
+# Christian Neukirchen
+
+# This could actually be quite usable if it weren't for one small problem:
+# There is no way to close off blocks from the outside scope.
+# This can cause interferance between separate tests.
+# So while quicktest works for simple cases, it may well run into
+# problems with anything sizable.
+
+require 'test/unit'
+
+$TCGEN = "000000"
+$TGEN  = "000000"
+
+#$TS = []
+$TC = [nil]
+
+def testcase(name=nil, &block)
+  tc = Class.new(Test::Unit::TestCase)
+  #self.class.const_set("TC_#{(name||$TCGEN.succ!)}", tc)
+  $TC << tc
+  tc.class_eval &block
+end
+
+class Test::Unit::TestCase
+  def self.gen_test_name
+    @gen_test_name ||= "000000"
+    @gen_test_name.succ!
+    return "#{@gen_test_name}"
+  end
+  def self.test(name=nil, &block)
+    __send__(:define_method, "test_#{(name||gen_test_name)}", &block)
+  end
+end
+
+def test(name=nil, &block)
+  $TC[0] ||= Class.new(Test::Unit::TestCase)
+  self.class.const_set("TC#{$TCGEN.succ!}", $TC[0])
+  $TC[0].__send__(:define_method, "test_#{(name||$TGEN.succ!)}", &block)
+end
+
+
+#Test::Unit.run = !$DEBUG

data/work/turn.rb

@@ -0,0 +1,119 @@
+require 'test/unit/ui/console/testrunner'
+require 'turn/colorize'
+
+require 'turn/components/suite.rb'
+require 'turn/components/case.rb'
+require 'turn/components/method.rb'
+
+require 'turn/reporters/outline_reporter.rb'
+require 'turn/reporters/progress_reporter.rb'
+
+#$turn_reporter = Turn::ProgressReporter.new(@io)
+$turn_reporter = Turn::OutlineReporter.new(@io)
+
+module ::Test::Unit
+module UI
+module Console
+  class TestRunner
+    include Turn::Colorize
+
+    # Is this needed?
+    alias :t_attach_to_mediator :attach_to_mediator
+
+    def attach_to_mediator
+      @mediator.add_listener(TestRunnerMediator::STARTED, &method(:t_started))
+      @mediator.add_listener(TestRunnerMediator::FINISHED, &method(:t_finished))
+      @mediator.add_listener(TestSuite::STARTED, &method(:t_case_started))
+      @mediator.add_listener(TestSuite::FINISHED, &method(:t_case_finished))
+      @mediator.add_listener(TestCase::STARTED, &method(:t_test_started))
+      @mediator.add_listener(TestCase::FINISHED, &method(:t_test_finished))
+      @mediator.add_listener(TestResult::FAULT, &method(:t_fault))
+
+      @io.sync    = true
+
+      @t_result   = nil
+      @t_fault    = nil
+      @t_reporter = $turn_reporter
+
+      @t_previous_run_count       = 0
+      @t_previous_error_count     = 0
+      @t_previous_failure_count   = 0
+      @t_previous_assertion_count = 0
+    end
+
+    def t_started(result)
+      @t_suite = Turn::TestSuite.new #@suite
+      @t_suite.size = @suite.size
+      @t_result = result
+      @t_reporter.start_suite(@t_suite)
+    end
+
+    def t_case_started(name)
+      (@not_first_case = true; return) unless @not_first_case
+      @t_case = @t_suite.new_case(name)
+      @t_reporter.start_case(@t_case)
+    end
+
+    def t_test_started(name)
+      methname, tcase = name.scan(%r/^([^\(]+)\(([^\)]+)\)/o).flatten!
+      @t_test = @t_case.new_test(methname)
+      #@t_test.file = tcase
+      #@t_test.name = method
+      @t_reporter.start_test(@t_test)
+    end
+
+    def t_fault(fault)
+      case fault
+      when ::Test::Unit::Error
+        msg = "\t"
+        msg << fault.to_s.split("\n")[2..-1].join("\n\t")
+        msg = ::ANSICode.magenta(msg) if COLORIZE
+        @t_test.error!(msg)
+        @t_reporter.error(msg)
+      when ::Test::Unit::Failure
+        msg = "\t"
+        msg << fault.location[0] << "\n\t"
+        msg << fault.message.gsub("\n","\n\t")
+        msg = ::ANSICode.magenta(msg) if COLORIZE
+        @t_test.fail!(msg)
+        @t_reporter.fail(msg)
+      end
+    end
+
+    def t_test_finished(name)
+      @t_reporter.pass if @t_test.pass?
+      @t_reporter.finish_test(@t_test)
+    end
+
+    def t_case_finished(name)
+      t = @t_result.run_count       - @t_previous_run_count
+      f = @t_result.failure_count   - @t_previous_failure_count
+      e = @t_result.error_count     - @t_previous_error_count
+      a = @t_result.assertion_count - @t_previous_assertion_count
+
+      @t_case.counts(t,a,f,e)
+
+      @t_previous_run_count       = @t_result.run_count
+      @t_previous_failure_count   = @t_result.failure_count
+      @t_previous_error_count     = @t_result.error_count
+      @t_previous_assertion_count = @t_result.assertion_count
+
+      @t_reporter.finish_case(@t_case)
+    end
+
+    def t_finished(elapsed_time)
+      @t_suite.count_tests      = @t_result.run_count
+      @t_suite.count_failures   = @t_result.failure_count
+      @t_suite.count_errors     = @t_result.error_count
+      @t_suite.count_passes     = @t_result.run_count - @t_result.failure_count - @t_result.error_count
+      @t_suite.count_assertions = @t_result.assertion_count
+
+      @t_reporter.finish_suite(@t_suite)
+    end
+
+  end
+end
+end
+end
+
+# EOF

metadata

@@ -0,0 +1,94 @@
+--- !ruby/object:Gem::Specification 
+name: TwP-turn
+version: !ruby/object:Gem::Version 
+  version: 0.5.1
+platform: ruby
+authors: 
+- Tim Pease
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-03-26 00:00:00 -07:00
+default_executable: turn
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: bones
+  type: :development
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 2.4.2
+    version: 
+description: TURN is a new way to view Test::Unit results. With longer running tests, it can be very frustrating to see a failure (....F...) and then have to wait till all the tests finish before you can see what the exact failure was. TURN displays each test on a separate line with failures being displayed immediately instead of at the end of the tests.  If you have the 'facets' gem installed, then TURN output will be displayed in wonderful technicolor (but only if your terminal supports ANSI color codes). Well, the only colors are green and red, but that is still color.
+email: tim.pease@gmail.com
+executables: 
+- turn
+extensions: []
+
+extra_rdoc_files: 
+- History.txt
+- README.txt
+- Release.txt
+- bin/turn
+files: 
+- History.txt
+- README.txt
+- Rakefile
+- Release.txt
+- VERSION
+- bin/turn
+- lib/turn.rb
+- lib/turn/colorize.rb
+- lib/turn/command.rb
+- lib/turn/components/case.rb
+- lib/turn/components/method.rb
+- lib/turn/components/suite.rb
+- lib/turn/controller.rb
+- lib/turn/reporter.rb
+- lib/turn/reporters/dot_reporter.rb
+- lib/turn/reporters/marshal_reporter.rb
+- lib/turn/reporters/outline_reporter.rb
+- lib/turn/reporters/progress_reporter.rb
+- lib/turn/runners/crossrunner.rb
+- lib/turn/runners/isorunner.rb
+- lib/turn/runners/loadrunner.rb
+- lib/turn/runners/solorunner.rb
+- lib/turn/runners/testrunner.rb
+- test/test_example.rb
+- test/test_sample.rb
+- turn.gemspec
+- work/quicktest.rb
+- work/turn.rb
+has_rdoc: true
+homepage: http://codeforpeople.rubyforge.org/turn
+post_install_message: 
+rdoc_options: 
+- --main
+- README.txt
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: codeforpeople
+rubygems_version: 1.2.0
+signing_key: 
+specification_version: 2
+summary: Test::Unit Reporter (New) -- new output format for Test::Unit
+test_files: 
+- test/test_example.rb
+- test/test_sample.rb