quarry 0.4.0 → 0.5.0

data/work/sandbox/x_isotest.rb

@@ -1,532 +0,0 @@
-#!/usr/bin/env ruby
-
-require 'facets/core/hash/rekey'
-require 'facets/core/string/margin'
-require 'facets/more/progressbar'
-
-require 'test/unit/ui/testrunnermediator' #require 'test/unit'
-::Test::Unit.run = true # Don't autorun tests!
-
-class Project
-
-  # Define testing tasks.
-
-  def task_test()
-
-    #desc "Run unit tests"
-    #task :run do
-    #  project.run_iso_tests  # TODO Fix
-    #end
-
-    desc "Run isolated unit test"
-    task :test do
-      project.run_isotests
-    end
-
-    desc "Extract embedded tests"
-    task :tests do
-      project.extract_tests
-    end
-
-    desc "Run syntax check"
-    task :syntax do
-      project.test_syntax
-    end
-
-    desc 'Test load dependencies'
-    task :load do
-      project.test_load
-    end
-
-  end
-
-  # Default test files to run.
-  DEFAULT_TEST_FILES = [ 'test/**/tc*.rb', 'test/**/test*.rb', 'test/**/*test.rb' ]
-  DEFAULT_SCRIPT_FILES = [ 'lib/**/*.rb' ]
-
-  # Test syntax.
-
-  def test_syntax
-    res = true
-    cnt = 0
-    scripts = info.scripts || DEFAULT_SCRIPT_FILES
-    scripts = Dir.multiglob(*scripts) - Dir.multiglob_r(ignore)
-    scripts.each do |s|
-      next unless File.file?(s)
-      if not system "ruby -c -Ibin:lib:test #{s} &> /dev/null" then
-        puts "Syntax Error: #{s}"
-        checklist << :syntax
-        cnt += 1
-        res = false
-      end
-    end
-    if cnt == 0
-      puts "Syntax       [PASS]"
-    else
-      puts "Syntax       [FAIL]"
-    end
-    return res
-  end
-
-  # Test load dependencies.
-
-  def test_load
-    res = true
-    cnt = 0
-    tests = info.test_files || DEFAULT_TEST_FILES
-    tests = Dir.multiglob(*tests)
-    tests.each do |t|
-      if not system "ruby -Ibin:lib:test #{t} &> /dev/null" then
-        puts "Load Issue: #{t}"
-        checklist << :load
-        cnt += 1
-        res = false
-      end
-    end
-    if cnt == 0
-      puts "Load         [PASS]"
-    else
-      puts "Load         [FAIL]"
-    end
-    #puts "#{cnt} Dependency Issues"
-    return res
-  end
-
-  # Run unit-tests. Each test is run in a separate interpretor
-  # to prevent script clash. This makes for a more robust test
-  # facility and prevents potential conflicts between test scripts.
-  #
-  #   tests     Test files (eg. test/tc_**/*.rb) [test/**/*]
-  #   libs      Directories to include in load path.
-  #             ('./lib' is always included)
-  #   live      Deactive use of local libs and test against install.
-  #   reqs      List of files to require prior to running tests.
-  #   extract   Extract embedded tests first? [false]
-  #
-  # To isolate tests this tool marshals test results across a
-  # stdout->stdin shell pipe. This prevents interfence of one
-  # script's tests on another. But consequently it is not always
-  # possible to send debug info to stdout in the tests themselves
-  # (eg. #p and #puts).
-
-  def run_isotests
-    tests   = info.test_files
-    libs    = info.test_libpath
-    reqs    = info.test_require
-    live    = info.test_live
-    extract = info.test_extract
-
-    tests = [ tests ].flatten
-    libs  = [ libs ].flatten
-
-    #files = [ @files ].flatten
-    extract_tests if extract
-
-    results  = TestResults.new #(style)
-
-    # get test files
-    test_libs  = libs.join(':')
-    test_files = Dir.multiglob( *tests )
-    if test_files.empty?
-      puts "Tests        [NONE]"
-      return
-    end
-
-    # run tests
-
-    if trace?
-      pbar = nil
-      size = test_files.collect{|f| f.size}.max + 5
-      dots = '.' * size
-    else
-      pbar = Console::ProgressBar.new( 'Testing', test_files.size )
-      pbar.inc
-    end
-
-    test_files.each do |test_file|
-      pbar.inc if pbar
-      if ! File.file?(test_file)
-        next #r = nil
-      else
-        unless pbar
-          print test_file + dots[test_file.size..-1]
-          $stdout.flush
-        end
-        r = fork_test( test_file, :libs=>libs, :reqs=>reqs, :live=>live )
-        unless pbar
-          puts r.passed? ? "[PASS]" : "[FAIL]"
-        end
-      end
-      results << r
-    end
-
-    pbar.finish if pbar
-
-    # display results
-    puts results
-
-    fails, errrs = results.failure_count, results.error_count
-    CHECKLIST << :test if fails > 0
-    CHECKLIST << :test if errrs > 0
-    return (fails + errrs > 0)
-  end
-
-  # Run a test in a separate process.
-  #
-  # Currently send program output to null device.
-  # Could send to a logger in future version.
-  #
-  # Key parameters are libs, reqs, live.
-
-  def fork_test( file, keys )
-    keys = keys.rekey(:to_s)
-
-    libs = keys['lib'] || []
-    reqs = keys['req'] || []
-    live = keys['live']
-
-    src = ''
-
-    unless live
-      l = File.join( Dir.pwd, 'lib' )
-      if File.directory?( l )
-        src << %{$:.unshift('#{l}')\n}
-      end
-      libs.each { |r| src << %{$:.unshift('#{r}')\n} }
-    end
-
-    src << %{
-      #require 'test/unit'
-      require 'test/unit/collector'
-      require 'test/unit/collector/objectspace'
-      require 'test/unit/ui/testrunnermediator'
-    }
-
-    reqs.each do |fix|
-      src << %Q{
-        require '#{fix}'
-      }
-    end
-
-    src << %{
-      def warn(*null); end  # silence warnings
-
-      output = STDOUT.dup
-      STDOUT.reopen( PLATFORM =~ /mswin/ ? "NUL" : "/dev/null" )
-
-      load('#{file}')
-      tests = Test::Unit::Collector::ObjectSpace.new.collect
-      runner = Test::Unit::UI::TestRunnerMediator.new( tests )
-      result = runner.run_suite
-
-      begin
-        marshalled = Marshal.dump(result)
-      rescue TypeError => e
-        $stderr << "MARSHAL ERROR\n"
-        $stderr << "TEST: #{file}\n"
-        $stderr << "DATA:" << result.inspect
-        exit -1
-      end
-      output << marshalled
-
-      STDOUT.reopen(output)
-      output.close
-    }
-
-    result = IO.popen("ruby","w+") do |ruby|
-      ruby.puts src
-      ruby.close_write
-      ruby.read
-    end
-
-    begin
-      marsh = Marshal.load(result)
-    rescue ArgumentError
-      $stderr << "\nCannot load marshalled test data.\n"
-      $stderr << result << "\n"
-      exit -1
-    end
-
-    return marsh
-  end
-
-  #
-  # Support class for collecting test results.
-  #
-
-  class TestResults
-    attr_reader :assertion_count,
-                :run_count,
-                :failure_count,
-                :error_count
-
-    attr_accessor :style
-
-    def initialize( style=nil )
-      @style = style
-
-      @results = []
-
-      @assertion_count = 0
-      @run_count = 0
-      @failure_count = 0
-      @error_count = 0
-    end
-
-    # Add a result to the results collection.
-
-    def <<( result )
-      @results << result
-
-      @assertion_count += result.assertion_count
-      @run_count += result.run_count
-      @failure_count += result.failure_count
-      @error_count += result.error_count
-    end
-
-    #
-
-    def errors
-      errors = []
-      @results.each do |r|
-        unless r.passed?
-          errors << r.instance_variable_get('@errors')
-        end
-      end
-      errors.reject! { |e| e == [] }
-      errors
-    end
-
-    #
-
-    def failures
-      failures = []
-      @results.each do |r|
-        unless r.passed?
-          failures << r.instance_variable_get('@failures')
-        end
-      end
-      failures.reject! { |e| e == [] }
-      failures
-    end
-
-    # Output format for test results.
-
-    def to_s
-      return @results.to_s if style == 'pease'
-
-      s = []
-      # Display failures
-      unless failures.empty?
-        s << ''
-        s << "FAILURES:"
-        failures.reverse.each do |fails|
-          fails.reverse.each do |failure|
-            #puts
-            s << %{  - test      : #{failure.test_name}}
-            s << %{    location  : #{failure.location}}
-            if failure.message.index("\n")
-              s << %{    message   : >}
-              s << failure.message.tabto(6)
-            else
-              s << %{    message   : #{failure.message}}
-            end
-          end
-        end
-      end
-
-      # Display errors
-      unless errors.empty?
-        s << ''
-        s << "ERRORS:"
-        errors.reverse.each do |errs|
-          errs.reverse.each do |err|
-            s << ''
-            s << %{  - test      : #{err.test_name}}
-            s << %{    message   : #{err.exception.message}}
-            s << %{    backtrace :}
-            err.exception.backtrace[0...-1].each { |bt| s << %Q{      - #{bt}} }
-          end
-        end
-      end
-
-      # Display final results
-      s << ''
-      s << "Summary:"
-      s << "  Tests      : #{@run_count}"
-      s << "  Assertions : #{@assertion_count}"
-      s << "  Failures   : #{@failure_count}"
-      s << "  Errors     : #{@error_count}"
-      s << ''
-      s << ''
-
-      return s.join("\n")
-    end
-
-    # Delegate missing call to the results array.
-
-    def method_missing(*a,&b)
-      @results.send(*a,&b)
-    end
-  end
-
-  # Extract unit tests. This task scans every package script
-  # looking for sections of the form:
-  #
-  #     =begin test
-  #       ...
-  #     =end
-  #
-  # With appropriate headers, it copies these sections to files
-  # in your project's test/ dir, which then can be run using the
-  # Ratchet test task. The exact directory layout of the files to
-  # be tested is reflected in the test directory. You can then
-  # use project.rb's test task to run the tests.
-  #
-  #     files      Files to extract ['lib/**/*.rb']
-  #     output     Test directory   ['test/']
-  #
-
-  def extract_tests
-    #files  = info.extract
-    files  = ['lib/**/*.rb']  # FIXME Includes everthing? Perhaps extracts should be configurable.
-    output = 'test'           # Don't think output should be setable.
-
-    filelist = Dir.multiglob(*files)
-    if filelist.empty?
-      puts "No script files found."
-      return
-    end
-
-    mkdir_p(output) unless File.directory?(output)
-
-    if trace?
-      pbar = nil
-      dots = '.' * (filelist.collect{ |f| f.size }.max + 11)
-    else
-      pbar = Console::ProgressBar.new('Extracting', filelist.size)
-      pbar.inc
-    end
-
-    filelist.each do |file|
-      if pbar
-        pbar.inc
-      else
-        print file + dots[file.size..-1]
-        $stdout.flush
-      end
-      testing = extract_test_from_file( file )
-      if testing.strip.empty?
-        puts "[NONE]" unless pbar
-      else
-        complete_test = create_test( testing, file )
-        libpath = File.dirname( file )
-        testfile = "test_" + File.basename( file )
-        fp = File.join( output, libpath, testfile )
-        unless File.directory?( File.dirname( fp ) )
-          FileUtils.mkdir_p( File.dirname(fp) )
-        end
-        File.open( fp, "w" ) { |fw| fw << complete_test }
-        puts "[TEST]" unless pbar
-      end
-    end
-    pbar ? pbar.finish : puts
-  end
-
-  private
-
-  # Extract test from a file's testing comments.
-
-  def extract_test_from_file( file )
-    return nil if ! File.file?( file )
-    tests = ""; inside = false
-    fstr = File.read( file )
-    fstr.split(/\n/).each do |l|
-      if l =~ /^=begin[ ]*test/i
-        tests << "\n"
-        inside = true
-        next
-      elsif inside and l =~ /^=[ ]*end/
-        inside = false
-        next
-      end
-      if inside
-        tests << l << "\n"
-      end
-    end
-    tests
-  end
-
-  # Generate the test.
-
-  def create_test( testing, file )
-    fp = file.split(/[\/]/)
-    if fp[0] == 'lib'
-      reqf = "require '#{fp[1..-1].join('/')}'"
-    else
-      reqf = ''
-    end
-    teststr = <<-HERE.margin
-      `#  _____         _
-      `# |_   _|__  ___| |_
-      `#   | |/ _ \\/ __| __|
-      `#   | |  __/\\__ \\ |_
-      `#   |_|\\___||___/\\__|
-      `#
-      `# for #{file}
-      `#
-      `# Extracted #{Time.now}
-      `# Project.rb Test Extraction
-      `#
-      `
-      `#{reqf}
-      `
-    HERE
-    teststr << testing << "\n"
-    teststr
-  end
-
-end # class Project
-
-
-=begin
-  # Files and file patterns of the test scripts to run.
-  attr_accessor :tests
-  alias_method :files, :tests
-  alias_method :files=, :tests=
-
-  # Prerequisite libraries to require before running tests.
-  attr_accessor :reqs
-  alias_method :require, :reqs
-  alias_method :require=, :reqs=
-
-  # Prerequisite additions to the $LOAD_PATH.
-  attr_accessor :libs
-  alias_method :libpath, :libs
-  alias_method :libpath=, :libs=
-
-  # Run from live installation instead of from the project.
-  attr_accessor :live
-
-  # Test result output format (tim pease)
-  #attr_accessor :style
-
-  # Extract embedded unit tests?
-  attr_accessor :extract
-
-  # Files to check syntax.
-  attr_accessor :scripts
-
-  # New testing tasks.
-  def initialize
-    yield self if block_given?
-
-    @tests   ||= DEFAULT_TEST_FILES
-    @reqs    ||= []
-    @libs    ||= []
-    @live    ||= false
-    @extract ||= false
-
-    define
-  end
-=end