ruby-oci8 1.0.7-x86-mswin32-60 → 2.0.1-x86-mswin32-60

data/support/runit/cui/testrunner.rb

@@ -1,101 +0,0 @@
-require 'runit/testresult'
-require 'runit/robserver'
-
-module RUNIT
-  module CUI
-    class TestRunner
-      include RObserver
-      @@quiet_mode = false
-      def initialize(io=STDERR, wait=false)
-        @io = io
-        @wait = wait
-      end
-  
-      def TestRunner.quiet_mode=(flag)
-        @@quiet_mode = flag
-      end
-     
-      def TestRunner.run(test, io=STDERR, wait = false)
-        r = TestRunner.new(io, wait)
-        r.run(test)
-      end
-  
-      def run(test)
-        result = RUNIT::TestResult.new
-        result.add_observer(self)
-        test.run(result)
-	print_running_time(result.running_time)
-        print_result(result, test.count_test_cases)
-	print_waiting_message
-	result
-      end
-
-      def print_waiting_message
-        if @wait
-          STDERR.print "<RETURN> to Continue "
-          STDIN.gets
-        end
-      end
-
-      def print_running_time(rtm)
-        @io.print "\nTime: #{rtm}\n"
-      end
-
-      def start_test(t)
-        @io.print "\n", t.name ,  " " if !@@quiet_mode
-      end
-  
-      def add_failure(at, err)
-        @io.print("F")
-      end
-  
-      def add_error(at, err)
-        @io.print("E")
-      end
-  
-      def end_test(t)
-        @io.print(".")
-      end
-  
-      def print_result(result, count)
-        print_header(result, count)
-        print_failures(result)
-        print_errors(result)
-      end
-  
-      def print_header(result, count)
-        if result.succeed?
-          @io.puts "OK (#{result.run_tests}/#{count} tests  #{result.run_asserts} asserts)"
-        else
-          @io.puts "FAILURES!!!"
-          @io.puts "Test Results:"
-          @io.print " Run: #{result.run_tests}/#{count}(#{result.run_asserts} asserts)"
-          @io.print " Failures: #{result.failure_size}"
-          @io.puts  " Errors: #{result.error_size}"
-        end
-      end
-    
-      def print_failures(result)
-        @io.puts "Failures: #{result.failure_size}" if result.failure_size > 0
-        result.failures.each do |f|
-	  @io.print f.at[0], ": ", f.err, " (", f.err.class, ")\n"
-	  for at in f.at[1..-1]
-	    @io.print "\tfrom ", at, "\n"
-	  end
-        end
-      end
-    
-      def print_errors(result)
-        @io.puts "Errors: #{result.error_size}" if result.error_size > 0
-        result.errors.each do |e|
-	  @io.print e.at[0], ": ", e.err, " (", e.err.class, ")\n"
-	  for at in e.at[1..-1]
-	    @io.print "\tfrom ", at, "\n"
-	  end
-        end
-      end
-
-    end
-  end
-end
-

data/support/runit/error.rb

@@ -1,4 +0,0 @@
-module RUNIT
-  class AssertionFailedError < StandardError
-  end
-end

data/support/runit/method_mappable.rb

@@ -1,20 +0,0 @@
-module RUNIT
-  module MethodMappable
-    def attach_method(hash, method, *methods)
-      methods.each do |m|
-        hash[self.to_s + m.to_s] = method
-      end
-    end
-    private :attach_method
-
-    def invoke_method(hash, m)
-      if hash[self.to_s + m.to_s]
-        send hash[self.to_s + m.to_s]
-      elsif hash[self.class.to_s + m.to_s]
-        send hash[self.class.to_s + m.to_s]
-      end
-    end
-    private :invoke_method
-  end
-end
-

data/support/runit/robserver.rb

@@ -1,25 +0,0 @@
-module RUNIT
-  module RObserver
-    ADD_ERROR = :add_error
-    ADD_FAILURE = :add_failure
-    START_TEST = :start_test
-    END_TEST = :end_test
-
-    def add_error(*arg)
-    end
-
-    def add_failure(*arg)
-    end 
-
-    def start_test(*arg)
-    end
-
-    def end_test(*arg)
-    end
-
-    def update(ev, *arg)
-      send(ev, *arg)
-    end
-
-  end
-end

data/support/runit/setuppable.rb

@@ -1,15 +0,0 @@
-require 'runit/method_mappable'
-module RUNIT
-  module Setuppable
-    include MethodMappable
-    @@setups = {}
-    def attach_setup(setup_method, *methods)
-      attach_method(@@setups, setup_method, *methods)
-    end
-    private :attach_setup
-    def invoke_setup(m)
-      invoke_method(@@setups, m)
-    end
-    private :invoke_setup
-  end
-end

data/support/runit/teardownable.rb

@@ -1,16 +0,0 @@
-require 'runit/method_mappable'
-module RUNIT
-  module Teardownable
-    include MethodMappable
-    @@teardowns = {}
-    def attach_teardown(teardown_method, *methods)
-      attach_method(@@teardowns, teardown_method, *methods)
-    end
-    private :attach_teardown
-    def invoke_teardown(m)
-      invoke_method(@@teardowns, m)
-    end
-    private :invoke_teardown
-  end
-end
-      

data/support/runit/testcase.rb

@@ -1,113 +0,0 @@
-require 'observer'
-require 'runit/testsuite'
-require 'runit/robserver'
-require 'runit/error'
-require 'runit/assert'
-require 'runit/setuppable'
-require 'runit/teardownable'
-
-module RUNIT
-  class TestCase
-    alias_method :extend_test, :extend
-
-    include Assert
-    include Observable
-
-    include Setuppable
-    extend Setuppable
-    include Teardownable
-    extend Teardownable
-
-    @@test_classes = []
-
-    def initialize(method, name=self.class.name)
-      @method = method
-      @name = name
-    end
-
-    def setup
-    end
-    private :setup
-
-    def teardown
-    end
-    private :teardown
-
-    def name
-      @name + "#" +  @method
-    end
-
-    def method_name
-      @method
-    end
-
-    def count_test_cases
-      1
-    end
-
-    def run(result)
-      result.start_test(self)
-      begin
-        run_bare
-      rescue AssertionFailedError
-        result.add_failure($@, $!, self.class)
-      rescue StandardError, ScriptError
-        result.add_error($@, $!, self.class)
-      end
-      result.end_test(self)
-    end
-  
-    def run_bare
-      setup
-      invoke_setup(@method)
-      begin 
-        send(@method)
-      ensure
-        begin
-          invoke_teardown(@method)
-          teardown
-        rescue
-          changed
-          notify_observers(RObserver::ADD_ERROR, $@, $!, self.class)
-        end
-      end
-    end
-        
-    def ==(other)
-      other.class == self.class && other.method_name && self.method_name
-    end
-
-    def TestCase.suite
-      TestSuite.new(self_test_cases)
-    end
-
-    def TestCase.inherited(sub)
-      @@test_classes.push sub
-    end
-
-    def TestCase.self_test_cases
-      instance_methods(true).sort.collect {|m|
-	new(m, name) if /^test/ =~ m
-      }.compact
-    end
-
-    def TestCase.test_cases
-      if self == TestCase
-        TestSuite.new(*@@test_classes)
-      else
-        suite
-      end
-    end
-
-
-    class<<TestCase
-      alias test_methods test_cases
-      alias all_suite test_cases
-      private :self_test_cases
-    end
-
-    def TestCase.test_classes
-      @@test_classes
-    end
-  end
-end

data/support/runit/testfailure.rb

@@ -1,25 +0,0 @@
-module RUNIT
-  SKIP_FILES = $:.collect{|path| /#{path}\/runit\//}.push /\/rubyunit\.rb:/
-
-  class TestFailure
-    attr_reader :at, :err
-    def initialize(at, err, testclass)
-      skip_trace = at.reject{|i|
-        SKIP_FILES.find {|pat|
-          pat =~ i
-	}
-      }
-      @at = insert_class_name(skip_trace, testclass)
-      @err = err
-    end
-    def to_s
-      "#{@at[0]} #{@err}(#{@err.type})"
-    end
-    def insert_class_name(last_exception_backtrace, testclass)
-      tns = testclass.inspect.split("::")
-      last_exception_backtrace[0] += "(" + tns[tns.length-1] + ")"
-      last_exception_backtrace
-    end
-    private :insert_class_name
-  end
-end

data/support/runit/testresult.rb

@@ -1,121 +0,0 @@
-require 'observer'
-require 'runit/error'
-require 'runit/robserver'
-require 'runit/testfailure'
-
-module RUNIT
-  class TestResultItem
-    attr_reader :name
-    attr_reader :failures
-    attr_reader :errors
-    attr_accessor :run_asserts
-
-    def initialize(name)
-      @failures = []
-      @errors = []
-      @name = name
-      @run_asserts = 0
-    end
-
-    def add_failure(failure)
-      @failures.push failure
-    end
-
-    def add_error(error)
-      @errors.push error
-    end
-  end
-
-  class TestResult
-    include Observable
-    include RObserver
-
-    def initialize
-      @result = nil
-      @results = []
-      @test_start_time = nil
-      @test_end_time = nil
-      @start_assert_size = 0
-    end
-
-    def items
-      @results
-    end
-  
-    def run_tests
-      @results.size
-    end
-
-    def add_failure(at, err, testclass)
-      fail = TestFailure.new(at, err, testclass)
-      @result.add_failure(fail)
-      changed
-      notify_observers(RObserver::ADD_FAILURE, at, err)
-    end
-  
-    def add_error(at, err, testclass)
-      error = TestFailure.new(at, err, testclass)
-      @result.add_error(error)
-      changed
-      notify_observers(RObserver::ADD_ERROR, at, err)
-    end
-  
-    def assert_size
-      size = 0
-      @results.each do |i|
-        size += i.run_asserts
-      end
-      size
-    end
-    alias run_asserts assert_size
-
-    def failure_size
-      failures.size
-    end
-
-    def error_size
-      errors.size
-    end
-
-    def failures
-      @results.collect{|r|
-	r.failures
-      }.flatten
-    end
-
-    def errors
-      @results.collect{|r|
-        r.errors
-      }.flatten
-    end
-
-    def succeed?
-      failure_size == 0 && error_size == 0
-    end
-
-    def running_time
-      if @test_end_time && @test_start_time
-        @test_end_time - @test_start_time
-      else
-        0
-      end
-    end
-  
-    def start_test(testcase)
-      testcase.add_observer(self)
-      @result = TestResultItem.new(testcase.name)
-      @results.push @result
-      @start_assert_size = Assert.run_asserts
-      @test_start_time = Time.now if !@test_start_time
-      changed
-      notify_observers(RObserver::START_TEST, testcase)
-    end
-  
-    def end_test(testcase)
-      changed
-      notify_observers(RObserver::END_TEST, testcase)
-      @test_end_time = Time.now
-      @result.run_asserts = Assert.run_asserts - @start_assert_size
-    end
-  end
-end