zentest-without-autotest 4.1.4

data/lib/multiruby.rb

@@ -0,0 +1,426 @@
+require 'fileutils'
+require 'open-uri'
+
+##
+# multiruby_setup is a script to help you manage multiruby.
+#
+# usage: multiruby_setup [-h|cmd|spec...]
+#
+#   cmds:
+#
+#     -h, --help, help = show this help.
+#     build            = build and install everything. used internally.
+#     clean            = clean scm build dirs and remove non-scm build dirs.
+#     list             = print installed versions.
+#     rm:$version      = remove a particular version.
+#     rubygems:merge   = symlink all rubygem dirs to one dir.
+#     tags             = list all tags from svn.
+#     update           = update svn builds.
+#     update:rubygems  = update rubygems and nuke install dirs.
+#
+#   specs:
+#
+#     the_usual              = alias for latest versions from tar + rubygems
+#     mri:svn:current        = alias for mri:svn:releases and mri:svn:branches.
+#     mri:svn:releases       = alias for supported releases of mri ruby.
+#     mri:svn:branches       = alias for active branches of mri ruby.
+#     mri:svn:branch:$branch = install a specific $branch of mri from svn.
+#     mri:svn:tag:$tag       = install a specific $tag of mri from svn.
+#     mri:tar:$version       = install a specific $version of mri from tarball.
+#     rbx:ln:$dir            = symlink your rbx $dir
+#     rbx:git:current        = install rbx from git
+#
+#   environment variables:
+#
+#     GEM_URL  = url for rubygems tarballs
+#     MRI_SVN  = url for MRI SVN
+#     RBX_GIT  = url for rubinius git
+#     RUBY_URL = url for MRI tarballs
+#     VERSIONS = what versions to install
+#
+#     RUBYOPT is cleared on installs.
+#
+# NOTES:
+#
+# * you can add a symlink to your rubinius build into ~/.multiruby/install
+# * I need patches/maintainers for other implementations.
+#
+module Multiruby
+  def self.env name, fallback; ENV[name] || fallback; end # :nodoc:
+
+  TAGS     = %w(    1_8_6 1_8_7 1_9_1)
+  BRANCHES = %w(1_8 1_8_6 1_8_7 trunk)
+
+  VERSIONS = env('VERSIONS', TAGS.join(":").gsub(/_/, '.')).split(/:/)
+  MRI_SVN  = env 'MRI_SVN',  'http://svn.ruby-lang.org/repos/ruby'
+  RBX_GIT  = env 'RBX_GIT',  'git://github.com/evanphx/rubinius.git'
+  RUBY_URL = env 'RUBY_URL', 'http://ftp.ruby-lang.org/pub/ruby'
+  GEM_URL  = env 'GEM_URL',  'http://files.rubyforge.vm.bytemark.co.uk/rubygems'
+
+  HELP = []
+
+  File.readlines(__FILE__).each do |line|
+    next unless line =~ /^#( |$)/
+    HELP << line.sub(/^# ?/, '')
+  end
+
+  def self.build_and_install
+    ENV.delete 'RUBYOPT'
+
+    root_dir = self.root_dir
+    versions = []
+
+    Dir.chdir root_dir do
+      self.setup_dirs
+
+      rubygems = Dir["versions/rubygems*.tgz"]
+      abort "You should delete all but one rubygem tarball" if rubygems.size > 1
+      rubygem_tarball = File.expand_path rubygems.last rescue nil
+
+      Dir.chdir "build" do
+        Dir["../versions/*"].sort.each do |tarball|
+          next if tarball =~ /rubygems/
+
+          build_dir = File.basename tarball, ".tar.gz"
+          version = build_dir.sub(/^ruby-?/, '')
+          versions << version
+          inst_dir = "#{root_dir}/install/#{version}"
+
+          unless test ?d, inst_dir then
+            unless test ?d, build_dir then
+              if test ?d, tarball then
+                dir = File.basename tarball
+                FileUtils.ln_sf "../versions/#{dir}", "../build/#{dir}"
+              else
+                puts "creating #{inst_dir}"
+                Dir.mkdir inst_dir
+                run "tar zxf #{tarball}"
+              end
+            end
+            Dir.chdir build_dir do
+              puts "building and installing #{version}"
+              if test ?f, "configure.in" then
+                gnu_utils_build inst_dir
+              elsif test ?f, "Rakefile" then
+                rake_build inst_dir
+              else
+                raise "dunno how to build"
+              end
+
+              if rubygem_tarball and version !~ /1[._-]9|mri_trunk|rubinius/ then
+                rubygems = File.basename rubygem_tarball, ".tgz"
+                run "tar zxf #{rubygem_tarball}" unless test ?d, rubygems
+
+                Dir.chdir rubygems do
+                  run "../ruby ./setup.rb --no-rdoc --no-ri", "../log.rubygems"
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+
+    versions
+  end
+
+  def self.clean
+    self.each_scm_build_dir do |style|
+      case style
+      when :svn, :git then
+        if File.exist? "Rakefile" then
+          run "rake clean"
+        elsif File.exist? "Makefile" then
+          run "make clean"
+        end
+      else
+        FileUtils.rm_rf Dir.pwd
+      end
+    end
+  end
+
+  def self.each_scm_build_dir
+    Multiruby.in_build_dir do
+      Dir["*"].each do |dir|
+        next unless File.directory? dir
+        Dir.chdir dir do
+          if File.exist?(".svn") || File.exist?(".git") then
+            scm = File.exist?(".svn") ? :svn : :git
+            yield scm
+          else
+            yield :none
+          end
+        end
+      end
+    end
+  end
+
+  def self.extract_latest_version url, matching=nil
+    file = URI.parse(url).read
+    versions = file.scan(/href="(ruby.*tar.gz)"/).flatten.reject { |s|
+      s =~ /preview|-rc\d/
+    }.sort_by { |s|
+      s.split(/\D+/).map { |i| i.to_i }
+    }.flatten
+    versions = versions.grep(/#{Regexp.escape(matching)}/) if matching
+    versions.last
+  end
+
+  def self.fetch_tar v
+    in_versions_dir do
+      warn "  Determining latest version for #{v}"
+      ver = v[/\d+\.\d+/]
+      base = extract_latest_version("#{RUBY_URL}/#{ver}/", v)
+      abort "Could not determine release for #{v}" unless base
+      url = File.join RUBY_URL, ver, base
+      unless File.file? base then
+        warn "    Fetching #{base} via HTTP... this might take a while."
+        open(url) do |f|
+          File.open base, 'w' do |out|
+            out.write f.read
+          end
+        end
+      end
+    end
+  end
+
+  def self.git_clone url, dir
+    Multiruby.in_versions_dir do
+      Multiruby.run "git clone #{url} #{dir}" unless File.directory? dir
+      FileUtils.ln_sf "../versions/#{dir}", "../build/#{dir}"
+    end
+  end
+
+  def self.gnu_utils_build inst_dir
+    run "autoconf" unless test ?f, "configure"
+    run "./configure --enable-shared --prefix #{inst_dir}", "log.configure" unless
+      test ?f, "Makefile"
+    run "(nice make -j4; nice make)", "log.build"
+    run "make install", "log.install"
+  end
+
+  def self.help
+    puts HELP.join
+  end
+
+  def self.in_build_dir
+    Dir.chdir File.join(self.root_dir, "build") do
+      yield
+    end
+  end
+
+  def self.in_install_dir
+    Dir.chdir File.join(self.root_dir, "install") do
+      yield
+    end
+  end
+
+  def self.in_root_dir
+    Dir.chdir self.root_dir do
+      yield
+    end
+  end
+
+  def self.in_tmp_dir
+    Dir.chdir File.join(self.root_dir, "tmp") do
+      yield
+    end
+  end
+
+  def self.in_versions_dir
+    Dir.chdir File.join(self.root_dir, "versions") do
+      yield
+    end
+  end
+
+  def self.list
+    puts "Known versions:"
+    in_install_dir do
+      Dir["*"].sort.each do |d|
+        puts "  #{d}"
+      end
+    end
+  end
+
+  def self.merge_rubygems
+    in_install_dir do
+      gems = Dir["*/lib/ruby/gems"]
+
+      unless test ?d, "../gems" then
+        FileUtils.mv gems.first, ".."
+      end
+
+      gems.each do |d|
+        FileUtils.rm_rf d
+        FileUtils.ln_sf "../../../../gems", d
+      end
+    end
+  end
+
+  def self.mri_latest_tag v
+    Multiruby.tags.grep(/#{v}/).last
+  end
+
+  def self.rake_build inst_dir
+    run "rake", "log.build"
+    FileUtils.ln_sf "../build/#{File.basename Dir.pwd}", inst_dir
+  end
+
+  def self.rbx_ln dir
+    dir = File.expand_path dir
+    Multiruby.in_versions_dir do
+      FileUtils.ln_sf dir, "rubinius"
+      FileUtils.ln_sf "../versions/rubinius", "../install/rubinius"
+    end
+  end
+
+  def self.rm name
+    Multiruby.in_root_dir do
+      FileUtils.rm_rf Dir["*/#{name}"]
+      f = "versions/ruby-#{name}.tar.gz"
+      File.unlink f if test ?f, f
+    end
+  end
+
+  def self.root_dir
+    root_dir = File.expand_path(ENV['MULTIRUBY'] ||
+                                File.join(ENV['HOME'], ".multiruby"))
+
+    unless test ?d, root_dir then
+      puts "creating #{root_dir}"
+      Dir.mkdir root_dir, 0700
+    end
+
+    root_dir
+  end
+
+  def self.run base_cmd, log = nil
+    cmd = base_cmd
+    cmd += " > #{log} 2>&1" if log
+    puts "Running command: #{cmd}"
+    raise "ERROR: Command failed with exit code #{$?}" unless system cmd
+  end
+
+  def self.setup_dirs download = true
+    %w(build install versions tmp).each do |dir|
+      unless test ?d, dir then
+        puts "creating #{dir}"
+        Dir.mkdir dir
+        if dir == "versions" && download then
+          warn "  Downloading initial ruby tarballs to ~/.multiruby/versions:"
+          VERSIONS.each do |v|
+            self.fetch_tar v
+          end
+          warn "  ...done"
+          warn "  Put other ruby tarballs in ~/.multiruby/versions to use them."
+        end
+      end
+    end
+  end
+
+  def self.svn_co url, dir
+    Multiruby.in_versions_dir do
+      Multiruby.run "svn co #{url} #{dir}" unless File.directory? dir
+      FileUtils.ln_sf "../versions/#{dir}", "../build/#{dir}"
+    end
+  end
+
+  def self.tags
+    tags = nil
+    Multiruby.in_tmp_dir do
+      cache = "svn.tag.cache"
+      File.unlink cache if Time.now - File.mtime(cache) > 3600 rescue nil
+
+      File.open cache, "w" do |f|
+        f.write `svn ls #{MRI_SVN}/tags/`
+      end unless File.exist? cache
+
+      tags = File.read(cache).split(/\n/).grep(/^v/).reject {|s| s =~ /preview/}
+    end
+
+    tags = tags.sort_by { |s| s.scan(/\d+/).map { |s| s.to_i } }
+  end
+
+  def self.update
+    # TODO:
+    # update will look at the dir name and act accordingly rel_.* will
+    # figure out latest tag on that name and svn sw to it trunk and
+    # others will just svn update
+
+    clean = []
+
+    self.each_scm_build_dir do |style|
+      dir = File.basename(Dir.pwd)
+      warn dir
+
+      case style
+      when :svn then
+        case dir
+        when /mri_\d/ then
+          system "svn cleanup" # just in case
+          svn_up = `svn up`
+          in_build_dir do
+            if svn_up =~ /^[ADUCG] / then
+              clean << dir
+            else
+              warn "  no update"
+            end
+            FileUtils.ln_sf "../build/#{dir}", "../versions/#{dir}"
+          end
+        when /mri_rel_(.+)/ then
+          ver = $1
+          url = `svn info`[/^URL: (.*)/, 1]
+          latest = self.mri_latest_tag(ver).chomp('/')
+          new_url = File.join(File.dirname(url), latest)
+          if new_url != url then
+            run "svn sw #{new_url}"
+            clean << dir
+          else
+            warn "  no update"
+          end
+        else
+          warn "  update in this svn dir not supported yet: #{dir}"
+        end
+      when :git then
+        case dir
+        when /rubinius/ then
+          run "rake git:update build" # minor cheat by building here
+        else
+          warn "  update in this git dir not supported yet: #{dir}"
+        end
+      else
+        warn "  update in non-svn dir not supported yet: #{dir}"
+      end
+    end
+
+    in_install_dir do
+      clean.each do |dir|
+        warn "removing install/#{dir}"
+        FileUtils.rm_rf dir
+      end
+    end
+  end
+
+  def self.update_rubygems
+    warn "  Determining latest version for rubygems"
+    html = URI.parse(GEM_URL).read
+
+    versions = html.scan(/href="rubygems-update-(\d+(?:\.\d+)+).gem/i).flatten
+    latest = versions.sort_by { |s| s.scan(/\d+/).map { |s| s.to_i } }.last
+
+    Multiruby.in_versions_dir do
+      file = "rubygems-#{latest}.tgz"
+      unless File.file? file then
+        warn "    Fetching rubygems-#{latest}.tgz via HTTP."
+        File.unlink(*Dir["rubygems*"])
+        File.open file, 'w' do |f|
+          f.write URI.parse(GEM_URL+"/"+file).read
+        end
+      end
+    end
+
+    Multiruby.in_install_dir do
+      FileUtils.rm_rf Dir["*"]
+    end
+  end
+end

data/lib/zentest.rb

@@ -0,0 +1,576 @@
+
+$stdlib = {}
+ObjectSpace.each_object(Module) do |m|
+  $stdlib[m.name] = true if m.respond_to? :name
+end
+
+require 'zentest_mapping'
+
+$:.unshift( *$I.split(/:/) ) if defined? $I and String === $I
+$r = false unless defined? $r # reverse mapping for testclass names
+
+if $r then
+  # all this is needed because rails is retarded
+  $-w = false
+  $: << 'test'
+  $: << 'lib'
+  require 'config/environment'
+  f = './app/controllers/application.rb'
+  require f if test ?f, f
+end
+
+$TESTING = true
+
+class Module
+  def zentest
+    at_exit { ZenTest.autotest(self) }
+  end
+end
+
+##
+# ZenTest scans your target and unit-test code and writes your missing
+# code based on simple naming rules, enabling XP at a much quicker
+# pace. ZenTest only works with Ruby and Test::Unit.
+#
+# == RULES
+#
+# ZenTest uses the following rules to figure out what code should be
+# generated:
+#
+# * Definition:
+#   * CUT = Class Under Test
+#   * TC = Test Class (for CUT)
+# * TC's name is the same as CUT w/ "Test" prepended at every scope level.
+#   * Example: TestA::TestB vs A::B.
+# * CUT method names are used in CT, with "test_" prependend and optional "_ext" extensions for differentiating test case edge boundaries.
+#   * Example:
+#     * A::B#blah
+#     * TestA::TestB#test_blah_normal
+#     * TestA::TestB#test_blah_missing_file
+# * All naming conventions are bidirectional with the exception of test extensions.
+#
+# See ZenTestMapping for documentation on method naming.
+
+class ZenTest
+
+  VERSION = File.read( File.join(File.dirname(__FILE__),'..','VERSION') ).strip
+
+  include ZenTestMapping
+
+  if $TESTING then
+    attr_reader :missing_methods
+    attr_accessor :test_klasses
+    attr_accessor :klasses
+    attr_accessor :inherited_methods
+  else
+    def missing_methods; raise "Something is wack"; end
+  end
+
+  def initialize
+    @result = []
+    @test_klasses = {}
+    @klasses = {}
+    @error_count = 0
+    @inherited_methods = Hash.new { |h,k| h[k] = {} }
+    # key = klassname, val = hash of methods => true
+    @missing_methods = Hash.new { |h,k| h[k] = {} }
+  end
+
+  # load_file wraps require, skipping the loading of $0.
+  def load_file(file)
+    puts "# loading #{file} // #{$0}" if $DEBUG
+
+    unless file == $0 then
+      begin
+        require file
+      rescue LoadError => err
+        puts "Could not load #{file}: #{err}"
+      end
+    else
+      puts "# Skipping loading myself (#{file})" if $DEBUG
+    end
+  end
+
+  # obtain the class klassname, either from Module or
+  # using ObjectSpace to search for it.
+  def get_class(klassname)
+    begin
+      klass = Module.const_get(klassname.intern)
+      puts "# found class #{klass.name}" if $DEBUG
+    rescue NameError
+      ObjectSpace.each_object(Class) do |cls|
+        if cls.name =~ /(^|::)#{klassname}$/ then
+          klass = cls
+          klassname = cls.name
+          break
+        end
+      end
+      puts "# searched and found #{klass.name}" if klass and $DEBUG
+    end
+
+    if klass.nil? and not $TESTING then
+      puts "Could not figure out how to get #{klassname}..."
+      puts "Report to support-zentest@zenspider.com w/ relevant source"
+    end
+
+    return klass
+  end
+
+  # Get the public instance, class and singleton methods for
+  # class klass. If full is true, include the methods from
+  # Kernel and other modules that get included.  The methods
+  # suite, new, pretty_print, pretty_print_cycle will not
+  # be included in the resuting array.
+  def get_methods_for(klass, full=false)
+    klass = self.get_class(klass) if klass.kind_of? String
+
+    # WTF? public_instance_methods: default vs true vs false = 3 answers
+    # to_s on all results if ruby >= 1.9
+    public_methods = klass.public_instance_methods(false)
+    public_methods -= Kernel.methods unless full
+    public_methods.map! { |m| m.to_s }
+    public_methods -= %w(pretty_print pretty_print_cycle)
+
+    klass_methods = klass.singleton_methods(full)
+    klass_methods -= Class.public_methods(true)
+    klass_methods = klass_methods.map { |m| "self.#{m}" }
+    klass_methods  -= %w(self.suite new)
+
+    result = {}
+    (public_methods + klass_methods).each do |meth|
+      puts "# found method #{meth}" if $DEBUG
+      result[meth] = true
+    end
+
+    return result
+  end
+
+  # Return the methods for class klass, as a hash with the
+  # method nemas as keys, and true as the value for all keys.
+  # Unless full is true, leave out the methods for Object which
+  # all classes get.
+  def get_inherited_methods_for(klass, full)
+    klass = self.get_class(klass) if klass.kind_of? String
+
+    klassmethods = {}
+    if (klass.class.method_defined?(:superclass)) then
+      superklass = klass.superclass
+      if superklass then
+        the_methods = superklass.instance_methods(true)
+
+        # generally we don't test Object's methods...
+        unless full then
+          the_methods -= Object.instance_methods(true)
+          the_methods -= Kernel.methods # FIX (true) - check 1.6 vs 1.8
+        end
+
+        the_methods.each do |meth|
+          klassmethods[meth.to_s] = true
+        end
+      end
+    end
+    return klassmethods
+  end
+
+  # Check the class klass is a testing class
+  # (by inspecting its name).
+  def is_test_class(klass)
+    klass = klass.to_s
+    klasspath = klass.split(/::/)
+    a_bad_classpath = klasspath.find do |s| s !~ ($r ? /Test$/ : /^Test/) end
+    return a_bad_classpath.nil?
+  end
+
+  # Generate the name of a testclass from non-test class
+  # so that  Foo::Blah => TestFoo::TestBlah, etc. It the
+  # name is already a test class, convert it the other way.
+  def convert_class_name(name)
+    name = name.to_s
+
+    if self.is_test_class(name) then
+      if $r then
+        name = name.gsub(/Test($|::)/, '\1') # FooTest::BlahTest => Foo::Blah
+      else
+        name = name.gsub(/(^|::)Test/, '\1') # TestFoo::TestBlah => Foo::Blah
+      end
+    else
+      if $r then
+        name = name.gsub(/($|::)/, 'Test\1') # Foo::Blah => FooTest::BlahTest
+      else
+        name = name.gsub(/(^|::)/, '\1Test') # Foo::Blah => TestFoo::TestBlah
+      end
+    end
+
+    return name
+  end
+
+  # Does all the work of finding a class by name,
+  # obtaining its methods and those of its superclass.
+  # The full parameter determines if all the methods
+  # including those of Object and mixed in modules
+  # are obtained (true if they are, false by default).
+  def process_class(klassname, full=false)
+    klass = self.get_class(klassname)
+    raise "Couldn't get class for #{klassname}" if klass.nil?
+    klassname = klass.name # refetch to get full name
+
+    is_test_class = self.is_test_class(klassname)
+    target = is_test_class ? @test_klasses : @klasses
+
+    # record public instance methods JUST in this class
+    target[klassname] = self.get_methods_for(klass, full)
+
+    # record ALL instance methods including superclasses (minus Object)
+    # Only minus Object if full is true.
+    @inherited_methods[klassname] = self.get_inherited_methods_for(klass, full)
+    return klassname
+  end
+
+  # Work through files, collecting class names, method names
+  # and assertions. Detects ZenTest (SKIP|FULL) comments
+  # in the bodies of classes.
+  # For each class a count of methods and test methods is
+  # kept, and the ratio noted.
+  def scan_files(*files)
+    assert_count = Hash.new(0)
+    method_count = Hash.new(0)
+    klassname = nil
+
+    files.each do |path|
+      is_loaded = false
+
+      # if reading stdin, slurp the whole thing at once
+      file = (path == "-" ? $stdin.read : File.new(path))
+
+      file.each_line do |line|
+
+        if klassname then
+          case line
+          when /^\s*def/ then
+            method_count[klassname] += 1
+          when /assert|flunk/ then
+            assert_count[klassname] += 1
+          end
+        end
+
+        if line =~ /^\s*(?:class|module)\s+([\w:]+)/ then
+          klassname = $1
+
+          if line =~ /\#\s*ZenTest SKIP/ then
+            klassname = nil
+            next
+          end
+
+          full = false
+          if line =~ /\#\s*ZenTest FULL/ then
+            full = true
+          end
+
+          unless is_loaded then
+            unless path == "-" then
+              self.load_file(path)
+            else
+              eval file, TOPLEVEL_BINDING
+            end
+            is_loaded = true
+          end
+
+          begin
+            klassname = self.process_class(klassname, full)
+          rescue
+            puts "# Couldn't find class for name #{klassname}"
+            next
+          end
+
+          # Special Case: ZenTest is already loaded since we are running it
+          if klassname == "TestZenTest" then
+            klassname = "ZenTest"
+            self.process_class(klassname, false)
+          end
+
+        end # if /class/
+      end # IO.foreach
+    end # files
+
+    result = []
+    method_count.each_key do |classname|
+
+      entry = {}
+
+      next if is_test_class(classname)
+      testclassname = convert_class_name(classname)
+      a_count = assert_count[testclassname]
+      m_count = method_count[classname]
+      ratio = a_count.to_f / m_count.to_f * 100.0
+
+      entry['n'] = classname
+      entry['r'] = ratio
+      entry['a'] = a_count
+      entry['m'] = m_count
+
+      result.push entry
+    end
+
+    sorted_results = result.sort { |a,b| b['r'] <=> a['r'] }
+
+    @result.push sprintf("# %25s: %4s / %4s = %6s%%", "classname", "asrt", "meth", "ratio")
+    sorted_results.each do |e|
+      @result.push sprintf("# %25s: %4d / %4d = %6.2f%%", e['n'], e['a'], e['m'], e['r'])
+    end
+  end
+
+  # Adds a missing method to the collected results.
+  def add_missing_method(klassname, methodname)
+    @result.push "# ERROR method #{klassname}\##{methodname} does not exist (1)" if $DEBUG and not $TESTING
+    @error_count += 1
+    @missing_methods[klassname][methodname] = true
+  end
+
+  # looks up the methods and the corresponding test methods
+  # in the collection already built.  To reduce duplication
+  # and hide implementation details.
+  def methods_and_tests(klassname, testklassname)
+    return @klasses[klassname], @test_klasses[testklassname]
+  end
+
+  # Checks, for the given class klassname, that each method
+  # has a corrsponding test method. If it doesn't this is
+  # added to the information for that class
+  def analyze_impl(klassname)
+    testklassname = self.convert_class_name(klassname)
+    if @test_klasses[testklassname] then
+      methods, testmethods = methods_and_tests(klassname,testklassname)
+
+      # check that each method has a test method
+      @klasses[klassname].each_key do | methodname |
+        testmethodname = normal_to_test(methodname)
+        unless testmethods[testmethodname] then
+          begin
+            unless testmethods.keys.find { |m| m =~ /#{testmethodname}(_\w+)+$/ } then
+              self.add_missing_method(testklassname, testmethodname)
+            end
+          rescue RegexpError => e
+            puts "# ERROR trying to use '#{testmethodname}' as a regex. Look at #{klassname}.#{methodname}"
+          end
+        end # testmethods[testmethodname]
+      end # @klasses[klassname].each_key
+    else # ! @test_klasses[testklassname]
+      puts "# ERROR test class #{testklassname} does not exist" if $DEBUG
+      @error_count += 1
+
+      @klasses[klassname].keys.each do | methodname |
+        self.add_missing_method(testklassname, normal_to_test(methodname))
+      end
+    end # @test_klasses[testklassname]
+  end
+
+  # For the given test class testklassname, ensure that all
+  # the test methods have corresponding (normal) methods.
+  # If not, add them to the information about that class.
+  def analyze_test(testklassname)
+    klassname = self.convert_class_name(testklassname)
+
+    # CUT might be against a core class, if so, slurp it and analyze it
+    if $stdlib[klassname] then
+      self.process_class(klassname, true)
+      self.analyze_impl(klassname)
+    end
+
+    if @klasses[klassname] then
+      methods, testmethods = methods_and_tests(klassname,testklassname)
+
+      # check that each test method has a method
+      testmethods.each_key do | testmethodname |
+        if testmethodname =~ /^test_(?!integration_)/ then
+
+          # try the current name
+          methodname = test_to_normal(testmethodname, klassname)
+          orig_name = methodname.dup
+
+          found = false
+          until methodname == "" or methods[methodname] or @inherited_methods[klassname][methodname] do
+              # try the name minus an option (ie mut_opt1 -> mut)
+            if methodname.sub!(/_[^_]+$/, '') then
+              if methods[methodname] or @inherited_methods[klassname][methodname] then
+                found = true
+              end
+            else
+              break # no more substitutions will take place
+            end
+          end # methodname == "" or ...
+
+          unless found or methods[methodname] or methodname == "initialize" then
+            self.add_missing_method(klassname, orig_name)
+          end
+
+        else # not a test_.* method
+          unless testmethodname =~ /^util_/ then
+            puts "# WARNING Skipping #{testklassname}\##{testmethodname}" if $DEBUG
+          end
+        end # testmethodname =~ ...
+      end # testmethods.each_key
+    else # ! @klasses[klassname]
+      puts "# ERROR class #{klassname} does not exist" if $DEBUG
+      @error_count += 1
+
+      @test_klasses[testklassname].keys.each do |testmethodname|
+        @missing_methods[klassname][test_to_normal(testmethodname)] = true
+      end
+    end # @klasses[klassname]
+  end
+
+  def test_to_normal(_name, klassname=nil)
+    super do |name|
+      if defined? @inherited_methods then
+        known_methods = (@inherited_methods[klassname] || {}).keys.sort.reverse
+        known_methods_re = known_methods.map {|s| Regexp.escape(s) }.join("|")
+
+        name = name.sub(/^(#{known_methods_re})(_.*)?$/) { $1 } unless
+          known_methods_re.empty?
+
+        name
+      end
+    end
+  end
+
+  # create a given method at a given
+  # indentation. Returns an array containing
+  # the lines of the method.
+  def create_method(indentunit, indent, name)
+    meth = []
+    meth.push indentunit*indent + "def #{name}"
+    meth.last << "(*args)" unless name =~ /^test/
+    indent += 1
+    meth.push indentunit*indent + "raise NotImplementedError, 'Need to write #{name}'"
+    indent -= 1
+    meth.push indentunit*indent + "end"
+    return meth
+  end
+
+  # Walk each known class and test that each method has
+  # a test method
+  # Then do it in the other direction...
+  def analyze
+    # walk each known class and test that each method has a test method
+    @klasses.each_key do |klassname|
+      self.analyze_impl(klassname)
+    end
+
+    # now do it in the other direction...
+    @test_klasses.each_key do |testklassname|
+      self.analyze_test(testklassname)
+    end
+  end
+
+  # Using the results gathered during analysis
+  # generate skeletal code with methods raising
+  # NotImplementedError, so that they can be filled
+  # in later, and so the tests will fail to start with.
+  def generate_code
+    @result.unshift "# Code Generated by ZenTest v. #{VERSION}"
+
+    if $DEBUG then
+      @result.push "# found classes: #{@klasses.keys.join(', ')}"
+      @result.push "# found test classes: #{@test_klasses.keys.join(', ')}"
+    end
+
+    if @missing_methods.size > 0 then
+      @result.push ""
+      @result.push "require 'test/unit/testcase'"
+      @result.push "require 'test/unit' if $0 == __FILE__"
+      @result.push ""
+    end
+
+    indentunit = "  "
+
+    @missing_methods.keys.sort.each do |fullklasspath|
+
+      methods = @missing_methods[fullklasspath]
+      cls_methods = methods.keys.grep(/^(self\.|test_class_)/)
+      methods.delete_if {|k,v| cls_methods.include? k }
+
+      next if methods.empty? and cls_methods.empty?
+
+      indent = 0
+      is_test_class = self.is_test_class(fullklasspath)
+      klasspath = fullklasspath.split(/::/)
+      klassname = klasspath.pop
+
+      klasspath.each do | modulename |
+        m = self.get_class(modulename)
+        type = m.nil? ? "module" : m.class.name.downcase
+        @result.push indentunit*indent + "#{type} #{modulename}"
+        indent += 1
+      end
+      @result.push indentunit*indent + "class #{klassname}" + (is_test_class ? " < Test::Unit::TestCase" : '')
+      indent += 1
+
+      meths = []
+
+      cls_methods.sort.each do |method|
+        meth = create_method(indentunit, indent, method)
+        meths.push meth.join("\n")
+      end
+
+      methods.keys.sort.each do |method|
+        next if method =~ /pretty_print/
+        meth = create_method(indentunit, indent, method)
+        meths.push meth.join("\n")
+      end
+
+      @result.push meths.join("\n\n")
+
+      indent -= 1
+      @result.push indentunit*indent + "end"
+      klasspath.each do | modulename |
+        indent -= 1
+        @result.push indentunit*indent + "end"
+      end
+      @result.push ''
+    end
+
+    @result.push "# Number of errors detected: #{@error_count}"
+    @result.push ''
+  end
+
+  # presents results in a readable manner.
+  def result
+    return @result.join("\n")
+  end
+
+  # Runs ZenTest over all the supplied files so that
+  # they are analysed and the missing methods have
+  # skeleton code written.
+  def self.fix(*files)
+    zentest = ZenTest.new
+    zentest.scan_files(*files)
+    zentest.analyze
+    zentest.generate_code
+    return zentest.result
+  end
+
+  # Process all the supplied classes for methods etc,
+  # and analyse the results. Generate the skeletal code
+  # and eval it to put the methods into the runtime
+  # environment.
+  def self.autotest(*klasses)
+    zentest = ZenTest.new
+    klasses.each do |klass|
+      zentest.process_class(klass)
+    end
+
+    zentest.analyze
+
+    zentest.missing_methods.each do |klass,methods|
+      methods.each do |method,x|
+        warn "autotest generating #{klass}##{method}"
+      end
+    end
+
+    zentest.generate_code
+    code = zentest.result
+    puts code if $DEBUG
+
+    Object.class_eval code
+  end
+end