benchmarker 0.1.0 → 1.0.0

data/test/oktest.rb

@@ -1,825 +0,0 @@
-###
-### $Release: $
-### $Copyright: copyright(c) 2010 kuwata-lab.com all rights reserved $
-### $License: MIT License $
-###
-
-module Oktest
-
-  DIFF = ENV['DIFF'] || File.file?('/usr/bin/diff')
-
-  def self.DIFF=(command)
-    remove_const(:DIFF)
-    const_set(:DIFF, command)
-  end
-
-  def self.diff(actual, expected)
-    ## actual and expected should be different
-    return nil if actual == expected
-    ## both actual and expected should be String
-    return nil unless actual.is_a?(String) && expected.is_a?(String)
-    ## either actual or expected should contain "\n"
-    return nil unless actual.index("\n") || expected.index("\n")
-    ## diff command
-    command = Oktest::DIFF
-    return nil unless command
-    command = 'diff -u' if command == true
-    ## diff
-    require 'tempfile' unless defined?(Tempfile)
-    output = nil
-    #Tempfile.open('actual') do |af|    # af.path file is not removed. why?
-    #  af.write(actual); af.flush()
-    #  Tempfile.open('expected') do |ef|
-    #    ef.write(expected); ef.flush()
-    #    #output = `#{command} #{ef.path} #{af.path}`
-    #    output = IO.popen(cmd="#{command} #{ef.path} #{af.path}") {|io| io.read }
-    #  end
-    #end
-    af = ef = nil
-    begin
-      af = Tempfile.open('actual')   ; af.write(actual)   ; af.flush
-      ef = Tempfile.open('expected') ; ef.write(expected) ; ef.flush
-      #output = `#{command} #{ef.path} #{af.path}`
-      output = IO.popen("#{command} #{ef.path} #{af.path}") {|io| io.read() }
-    ensure
-      af.close if ef
-      ef.close if ef
-    end
-    return output.sub(/\A.*?\n.*?\n/, "--- expected\n+++ actual\n")
-  end
-
-
-  class AssertionFailed < Exception
-    attr_accessor :diff
-  end
-
-  ASSERTION_FAILED = AssertionFailed
-
-
-  class AssertionObject
-
-    attr_reader :actual, :negative
-
-    def initialize(this, actual, negative=false)
-      @this = this
-      @actual = actual
-      @negative = negative
-    end
-
-    def ==(expected)
-      begin
-        do_assert(@actual == expected, expected, '==', '!=')
-      rescue AssertionFailed => ex
-        ex.diff = Oktest.diff(@actual, expected) if @actual != expected
-        raise ex
-      rescue ASSERTION_FAILED => ex
-        diff = Oktest.diff(@actual, expected) if @actual != expected
-        ex.message << "\n" << diff.chomp() if diff && ! diff.empty?
-        raise ex
-      end
-    end
-
-    if Object.new.respond_to?(:'!=')
-      eval <<-'END'
-    def !=(expected)
-      do_assert(@actual == expected, expected, '!=', '==')
-    end
-      END
-    end
-
-    def >(expected)
-      do_assert(@actual > expected, expected, '>', '<=')
-    end
-
-    def <(expected)
-      do_assert(@actual < expected, expected, '<', '>=')
-    end
-
-    def >=(expected)
-      do_assert(@actual >= expected, expected, '>=', '<')
-    end
-
-    def <=(expected)
-      do_assert(@actual <= expected, expected, '<=', '>')
-    end
-
-    def ===(expected)
-      do_assert(@actual === expected, expected, '===', '!==')
-    end
-
-    def =~(expected)
-      do_assert(@actual =~ expected, expected, '=~', '!~')
-    end
-
-    def in_delta?(expected, delta)
-      flag = expected - delta <= @actual && @actual <= expected + delta
-      check2(flag) { "(#{(expected - delta).inspect} <= #{@actual.inspect} <= #{(expected + delta).inspect})" }
-    end
-
-    def file?
-      check2(File.file?(@actual)) { "File.file?(#{@actual.inspect})" }
-    end
-
-    def dir?
-      check2(File.directory?(@actual)) { "File.directory?(#{@actual.inspect})" }
-    end
-
-    def exist?
-      check2(File.exist?(@actual)) { "File.exist?(#{@actual.inspect})" }
-    end
-
-    def same?(expected)
-      check2(@actual.equal?(expected)) { "#{@actual.inspect}.equal?(#{expected.inspect})" }
-    end
-
-    def in?(expected)
-      check2(expected.include?(@actual)) { "#{expected.inspect}.include?(#{@actual.inspect})" }
-    end
-
-    def include?(expected)
-      check2(@actual.include?(expected)) { "#{@actual.inspect}.include?(#{expected.inspect})" }
-    end
-
-    def is_a?(expected)
-      check2(@actual.is_a?(expected)) { "#{@actual.inspect}.is_a?(#{expected})" }
-    end
-    alias kind_of? is_a?
-
-    def nil?
-      check2(@actual.nil?) { "#{@actual.inspect}.nil?" }
-    end
-
-    def empty?
-      check2(@actual.empty?) { "#{@actual.inspect}.empty?" }
-    end
-
-    def raise?(exception_class, message=nil)
-      if @negative
-        _should_not_raise(exception_class)
-        ex = nil
-      else
-        ex = _should_raise(exception_class, message)
-      end
-      return ex
-    end
-
-    private
-
-    def _should_raise(exception_class, message)
-      not_raised = false
-      begin
-        @actual.call
-        not_raised = true
-      rescue Exception => ex
-        @actual.instance_variable_set('@exception', ex)
-        def @actual.exception; @exception; end
-        ex.class <= exception_class  or
-          raise new_assertion_failed("#{exception_class.name} expected but #{ex.class.name} raised.", 2)
-        if message
-          op = message.is_a?(Regexp) ? '=~' : '=='
-          ex.message.__send__(op, message)  or
-            raise new_assertion_failed("#{ex.message.inspect} #{op} #{message.inspect}: failed.", 2)
-        end
-      end
-      raise new_assertion_failed("#{exception_class.name} expected but not raised.", 2) if not_raised
-      return ex
-    end
-
-    def _should_not_raise(exception_class=Exception)
-      begin
-        @actual.call
-      rescue Exception => ex
-        @actual.instance_variable_set('@exception', ex)
-        def @actual.exception; @exception; end
-        if ex.class <= exception_class
-          raise new_assertion_failed("unexpected #{ex.class.name} raised.", 2)
-        end
-      end
-    end
-
-    def do_assert(flag, expected, op, negative_op)
-      flag, msg = check(flag, expected, op, negative_op)
-      return true if flag
-      raise new_assertion_failed(msg)
-    end
-
-    def new_assertion_failed(msg, depth=2)
-      ex = AssertionFailed.new(msg)
-      ex.set_backtrace(caller(depth+1))    # manipulate backtrace
-      return ex
-    end
-
-    def check(flag, expected, op, negative_op)
-      if @negative
-        flag = ! flag
-        op = negative_op
-      end
-      msg = flag ? nil : failed_message(expected, op)
-      return flag, msg
-    end
-
-    def failed_message(expected, op)
-      "#{@actual.inspect} #{op} #{expected.inspect}: failed."
-    end
-
-    def check2(flag)
-      flag = ! flag if @negative
-      return true if flag
-      expr = yield
-      expr = "! #{expr}" if @negative
-      raise new_assertion_failed("#{expr}: failed.")
-    end
-
-  end
-
-
-  module Helper
-
-    module_function
-
-    def ok
-      actual = yield
-      return Oktest::AssertionObject.new(self, actual, false)
-    end
-
-    def ok_(actual)
-      return Oktest::AssertionObject.new(self, actual, false)
-    end
-
-    def not_ok
-      actual = yield
-      return Oktest::AssertionObject.new(self, actual, true)
-    end
-
-    def not_ok_(actual)
-      return Oktest::AssertionObject.new(self, actual, true)
-    end
-
-    def dummy_io(stdin_str=nil)
-      require 'stringio' unless defined?(StringIO)
-      stdout, $stdout = $stdout, StringIO.new
-      stderr, $stderr = $stderr, StringIO.new
-      stdin,  $stdin  = $stdin,  StringIO.new(stdin_str) if stdin_str
-      begin
-        yield
-        return [$stdout.string, $stderr.string]
-      ensure
-        $stdout = stdout
-        $stderr = stderr
-        $stdin  = stdin if stdin_str
-      end
-    end
-    alias capture_io dummy_io    # for backward compatibility
-
-    def dummy_file(pairs)
-      fnames = []
-      begin
-        pairs.each do |fname, content|
-          fnames << fname
-          File.open(fname, 'wb') {|f| f.write(content) }
-          yield
-        end
-      ensure
-        File.unlink(*fnames)
-      end
-    end
-
-    def dummy_dir(*paths)
-      require 'fileutils' unless defined?(FileUtils)
-      begin
-        paths.each {|path| FileUtils.mkdir_p(path) }
-        yield
-      ensure
-        paths.reverse.each {|path| FileUtils.rm_rf(path) }
-      end
-    end
-
-    ## marker method to represent pre-condition
-    def pre_cond; yield; end
-
-    ## marker method to represent post-condition
-    def post_cond; yield; end
-
-    ## marker method to describe target of specification
-    def target(desc); yield; end
-
-    ## marker method to describe specification
-    #def spec(desc); yield if block_given?; end
-    def spec(desc)
-      reporter = @_oktest_runner && @_oktest_runner.reporter
-      status = nil
-      begin
-        reporter.enter_spec(self, desc) if reporter
-        if block_given?
-          yield
-          status = :ok
-        else
-          status = :empty
-        end
-      rescue AssertionFailed => ex
-        status = :fail
-        raise ex
-      rescue => ex
-        status = :error
-        raise ex
-      ensure
-        reporter.exit_spec(self, status) if reporter
-      end
-    end
-
-    def tracer(*args)
-      return Oktest::Util::Tracer.new(*args)
-    end
-
-  end
-
-
-  module ClassMethodHelper
-
-    def method_added(name)
-      super
-      dict = (@_test_method_names_dict ||= {})
-      name = name.to_s
-      if name =~ /\Atest_?/
-        ## if test method name is duplicated, raise error
-        dict[name].nil?  or
-          raise NameError.new("#{self.name}##{name}(): already defined (please change test method name).")
-        dict[name] = dict.size()
-        ## if ENV['TEST'] is set, remove unmatched method
-        if ENV['TEST']
-          remove_method(name) unless name.sub(/\Atest_?/, '').index(ENV['TEST'])
-        end
-      end
-    end
-
-    def method_undefined(method)
-      super
-      dict = @_test_method_names_dict
-      dict.delete(method.to_s) if dict
-    end
-
-    def test(desc, &block)
-      @_test_count ||= 0
-      @_test_count += 1
-      method_name = "test_%03d_%s" % [@_test_count, desc.to_s.gsub(/[^\w]/, '_')]
-      define_method(method_name, block)
-    end
-
-  end
-
-
-  module TestCase
-    include Helper
-
-    @_subclasses = []
-
-    def self._subclasses    # :nodoc:
-      return @_subclasses
-    end
-
-    def self.included(klass)
-      @_subclasses << klass if klass.is_a?(Class)
-      klass.class_eval do
-        extend Oktest::ClassMethodHelper
-      end
-    end
-
-  end
-
-
-  class Reporter
-
-    def before_all(klass)
-    end
-
-    def after_all(klass)
-    end
-
-    def before(obj)
-    end
-
-    def after(obj)
-    end
-
-    def print_ok(obj)
-    end
-
-    def print_failed(obj, ex)
-    end
-
-    def print_error(obj, ex)
-    end
-
-    def enter_spec(obj, desc)
-    end
-
-    def exit_spec(obj, status)
-    end
-
-  end
-
-
-  class BaseReporter < Reporter
-
-    def initialize(out=nil)
-      @out = out || $stdout
-      @_flush = @out.respond_to?(:flush)
-    end
-
-    def before_all(klass)
-      @count_test = 0
-      @count_spec = 0
-    end
-
-    def before(obj)
-      @count_test += 1
-      @spec_status = nil
-    end
-
-    def after(obj)
-    end
-
-    def enter_spec(obj, desc)
-      @count_spec += 1
-    end
-
-    def exit_spec(obj, status)
-      @spec_status = status
-      case status
-      when :ok      ; write('.')
-      when :empty   ; write('_')
-      when :fail    ; write('f')
-      when :error   ; write('E')
-      when nil      ; write('?')
-      else
-        raise "** internal error: status=#{status.inspect}"
-      end
-    end
-
-    private
-
-    def _test_ident(obj)
-      return obj.instance_variable_get('@_test_method')
-    end
-
-    def write(str)
-      @out << str
-      @out.flush if @_flush
-    end
-
-    def print_backtrace(ex, out=@out)
-      ex.backtrace.each do |str|
-        out << "    #{str}\n"
-        if str =~ /\A(.*):(\d+):in `(.*?)'/
-          filepath, linenum, method = $1, $2.to_i, $3
-          #break if method =~ /\Atest_?/
-          line = get_line(filepath, linenum)
-          out << "      #{line.strip}\n" if line
-          break if method =~ /\Atest_?/
-        end
-      end
-    end
-
-    def get_line(filepath, linenum)
-      return nil unless File.file?(filepath)
-      linenum = linenum.to_i
-      line = File.open(filepath) do |f|
-        i = 0
-        f.find { (i += 1) == linenum }
-      end
-      return line
-    end
-
-  end
-
-
-  class SimpleReporter < BaseReporter
-
-    def before_all(klass)
-      super
-      write("### %s: " % klass.name)
-      @buf = ""
-    end
-
-    def after_all(klass)
-      super
-      write(" (#{@count_test} tests, #{@count_spec} specs)\n")
-      @out << @buf.to_s
-      @buf = nil
-    end
-
-    def print_ok(obj)
-      write(".") unless @spec_status
-    end
-
-    def print_failed(obj, ex)
-      write("f") unless @spec_status
-      @buf << "Failed: #{_test_ident(obj)}()\n"
-      @buf << "    #{ex.message}\n"
-      print_backtrace(ex, @buf)
-      #assert ex.is_a?(AssertionFailed)
-      @buf << ex.diff if ex.diff
-    end
-
-    def print_error(obj, ex)
-      write("E") unless @spec_status
-      @buf << "ERROR: #{_test_ident(obj)}()\n"
-      @buf << "    #{ex.class.name}: #{ex.message}\n"
-      print_backtrace(ex, @buf)
-    end
-
-  end
-
-
-  class VerboseReporter < BaseReporter
-
-    def before_all(klass)
-      super
-      write("### %s\n" % klass.name)
-    end
-
-    def after_all(klass)
-      super
-      write(" (#{@count_test} tests, #{@count_spec} specs)\n")
-    end
-
-    def before(obj)
-      super
-      write("- #{_test_ident(obj)}: ")
-    end
-
-    def print_ok(obj)
-      write(" ok\n")
-    end
-
-    def print_failed(obj, ex)
-      write(" FAILED\n")
-      write("    #{ex.message}\n")
-      print_backtrace(ex, @out)
-      #assert ex.is_a?(AssertionFailed)
-      write(ex.diff) if ex.diff
-    end
-
-    def print_error(obj, ex)
-      write(" ERROR\n")
-      write("  #{ex.class.name}: #{ex.message}\n")
-      print_backtrace(ex, @out)
-    end
-
-  end
-
-
-  REPORTER = SimpleReporter
-  #REPORTER = VerboseReporter
-
-  def self.REPORTER=(reporter_class)
-    remove_const(:REPORTER)
-    const_set(:REPORTER, reporter_class)
-  end
-
-
-  class Runner
-
-    def initialize(reporter=nil)
-      @reporter = reporter || REPORTER.new
-    end
-    attr_accessor :reporter
-
-    def test_method_names_from(klass)
-      test_method_names = klass.instance_methods(true).collect {|sym| sym.to_s }.grep(/\Atest/).sort()
-      dict = klass.instance_variable_get('@_test_method_names_dict')
-      if dict
-        dict = dict.dup()   # key: test method name (String), value: index (Integer)
-        i = 0
-        test_method_names.select {|name| ! dict.key?(name) }.reverse.each {|name| dict[name] = (i -= 1) }
-        test_method_names = dict.sort_by {|k, v| v }.collect {|k, v| k }
-      end
-      return test_method_names
-    end
-
-    def warning(msg)
-      warn "WARNING: #{msg}"
-    end
-
-    def run(klass)
-      reporter = @reporter
-      ## gather test methods
-      test_method_names = test_method_names_from(klass)
-      ## filer by $TEST environment variable
-      pattern = ENV['TEST']
-      test_method_names.delete_if {|x| x.index(pattern).nil? } if pattern
-      ## sort by linenumber
-      # nothing
-      ## invoke before_all()
-      reporter.before_all(klass)
-      if klass.respond_to?(:before_all)
-        klass.before_all()
-      elsif klass.method_defined?(:before_all)
-        warning "#{klass.name}#before_all() should be class method (but defined as instance method)"
-      end
-      ## invoke test methods
-      count = 0
-      flag_before   = klass.method_defined?(:before)
-      flag_setup    = klass.method_defined?(:setup)
-      flag_after    = klass.method_defined?(:after)
-      flag_teardown = klass.method_defined?(:teardown)
-      test_method_names.each do |method_name|
-        ## create instance object for each test
-        begin
-          obj = klass.new
-        rescue ArgumentError
-          obj = klass.new(method_name)
-        end
-        obj.instance_variable_set('@_name', method_name.sub(/\Atest_?/, ''))
-        obj.instance_variable_set('@_test_method', method_name)
-        obj.instance_variable_set('@_oktest_runner', self)
-        ## invoke before() or setup()
-        reporter.before(obj)
-        flag_before ? obj.before() : flag_setup ? obj.setup() : nil
-        ## invoke test method
-        begin
-          obj.__send__(method_name)
-          reporter.print_ok(obj)
-        rescue Oktest::AssertionFailed => ex
-          count += 1
-          reporter.print_failed(obj, ex)
-        rescue Exception => ex
-          count += 1
-          reporter.print_error(obj, ex)
-        ensure
-          ## invoke after() or teardown()
-          flag_after ? obj.after() : flag_teardown ? obj.teardown() : nil
-          reporter.after(obj)
-        end
-      end
-      ## invoke after_all()
-      if klass.respond_to?(:after_all)
-        klass.after_all()
-      elsif klass.method_defined?(:after_all)
-        warning "#{klass.name}#after_all() should be class method (but defined as instance method)"
-      end
-      reporter.after_all(klass)
-      ##
-      return count
-    end
-  end
-
-
-  def self.run(*classes)
-    opts = classes.last.is_a?(Hash) ? classes.pop() : {}
-    reporter_class = opts[:verbose] ? VerboseReporter : REPORTER
-    reporter = reporter_class.new(opts[:out])
-    runner = Runner.new(reporter)
-    classes.each {|cls| runner.run(cls) }
-    self.run_at_exit = false
-  end
-
-  def self.run_all(opts={})
-    classes = Oktest::TestCase._subclasses()
-    args = classes + [opts]
-    self.run(*args)
-  end
-
-  @_run_at_exit = true
-
-  def self.run_at_exit?
-    return @_run_at_exit
-  end
-
-  def self.run_at_exit=(flag)
-    @_run_at_exit = flag
-  end
-
-
-  module Util
-
-
-    class Call
-
-      def initialize(name, args, ret)
-        @name, @args, @ret = name, args, ret
-      end
-
-      attr_accessor :name, :args, :ret
-
-      def to_a
-        return [@name, @args, @ret]
-      end
-
-    end
-
-
-    class FakeObject
-
-      def initialize(*args)
-        if (hash = args[-1]).is_a?(Hash)
-          hash.each do |k, v|
-            v.is_a?(Proc) ? add_response(k, &v) : add_response(k, v)
-          end
-        end
-        @_calls = []
-      end
-
-      attr_reader :_calls
-
-      def add_response(name, return_value=nil, &block)
-        #if block
-          (class << self; self; end).class_eval do
-            define_method name do |*args|
-              @_calls << (call = Call.new(name, args, return_value))
-              call.ret = block.call(*args) if block
-              call.ret
-            end
-          end
-        #else
-        #  (class << self; self; end).class_eval do
-        #    define_method name do |*args, &blk|
-        #      @calls << (call = Call.new(name, args, return_value))
-        #      call.ret
-        #    end
-        #  end
-        #end
-      end
-
-    end
-
-
-    class Tracer
-
-      def initialize
-        @calls = []
-      end
-
-      attr_reader :calls
-
-      def [](index)
-        @calls[index]
-      end
-
-      def length
-        @calls.length
-      end
-
-      alias size length
-
-      def trace_method(obj, *method_names)
-        #tracer = self
-        #method_names.each do |method_name|
-        #  (class << obj; self; end).class_eval do
-        #    alias_method "__orig_#{method_name}", method_name
-        #    define_method method_name do |*args|
-        #      tracer.calls << (call = Call.new(method_name, args, nil))
-        #      call.ret = obj.__send__("__orig_#{method_name}", *args)
-        #      call.ret
-        #    end
-        #  end
-        #end
-        obj.instance_variable_set("@__calls", @calls)
-        method_names.each do |method_name|
-          (class << obj; self; end).class_eval <<-"END"
-              alias_method :__orig_#{method_name}, :#{method_name}
-              def #{method_name}(*args, &blk)
-                @__calls << (call = Call.new(:#{method_name}, args, nil))
-                #call.ret = self.__orig_#{method_name}(*args, &blk)
-                call.ret = self.__send__(:__orig_#{method_name}, *args, &blk)
-                call.ret
-              end
-          END
-        end
-        nil
-      end
-
-      def fake_method(obj, method_name, return_value=nil, &block)
-        tracer = self
-        (class << obj; self; end).class_eval do
-          define_method method_name do |*args|
-            tracer.calls << (call = Call.new(method_name, args, return_value))
-            call.ret = block.call(*args) if block
-            call.ret
-          end
-        end
-        nil
-      end
-
-      def fake_object(*args)
-        fake_obj = FakeObject.new(*args)
-        fake_obj.instance_variable_set('@_calls', @calls)
-        return fake_obj
-      end
-
-    end
-
-
-  end #Util
-
-
-end
-
-
-at_exit do
-  ex = $!
-  if (! ex || ex.is_a?(SystemExit)) && Oktest.run_at_exit? # && ! defined?(Test::Unit)
-    Oktest.run_all()
-    raise ex if ex
-  end
-end