rcodetools 0.7.0.0 → 0.8.0.0

data/test/test_functional.rb

@@ -1,79 +1,47 @@
 require 'test/unit'
-
-module TestFunctional
-  DIR = File.expand_path(File.dirname(__FILE__))
-  LIBDIR = File.expand_path(DIR + '/../lib')
-  
-  module DefineFunctionalTests
-    def define_functional_tests(exec, tests)
-      tests.each_pair do |test, opts|
-        define_method("test_#{test}") do
-          
-          output = `ruby -I#{LIBDIR} #{exec} #{opts.join(" ")} #{DIR}/data/#{test}-input.rb`
-          outputfile = "#{DIR}/data/#{test}-output.rb"
-          assert_equal(File.read(outputfile), output)
-        end
-      end 
+require 'tempfile'
+class TestFunctional < Test::Unit::TestCase
+  def self.parse_taf(filename)
+    open(filename) do |io|
+      delimiter=Regexp.union(io.gets)
+      io.read.split(delimiter)
     end
   end
 
-  class TestXmpfilter < Test::Unit::TestCase
-    extend DefineFunctionalTests
-    tests = {
-      :simple_annotation => [], :unit_test => ["-u"], :rspec => ["-s"],
-      :no_warnings => ["--no-warnings"], :bindings => ["--poetry", "-u"],
-      :add_markers => ["-m"], :unit_test_rbtest => ["-u", "--rbtest"],
-      :unit_test_detect_rbtest => ["-u", "--detect-rbtest"],
-      :unit_test_detect_rbtest2 => ["--detect-rbtest"],
-    }
-    define_functional_tests File.expand_path(DIR + '/../bin/xmpfilter'), tests
-  end
-
-  class TestRctComplete < Test::Unit::TestCase
-    extend DefineFunctionalTests
-    tests = {
-      :completion_rbtest => [ "--rbtest", "--line=6" ],
-      :completion_detect_rbtest => [ "--detect-rbtest", "--line=6" ],
-      :completion_detect_rbtest2 => [ "--detect-rbtest", "--line=1" ],
-    }
-    define_functional_tests File.expand_path(DIR + '/../bin/rct-complete'), tests
-  end
-
-  class TestRctDoc < Test::Unit::TestCase
-    extend DefineFunctionalTests
-    tests = {
-      :doc_rbtest => [ "--rbtest", "--line=6" ],
-      :doc_detect_rbtest => [ "--detect-rbtest", "--line=1" ],
-      :doc_detect_rbtest2 => [ "--detect-rbtest", "--line=6" ],
-    }
-    define_functional_tests File.expand_path(DIR + '/../bin/rct-doc'), tests
+  def tempfile_with_contents(contents)
+    input = Tempfile.new("rct-test")
+    input.write(contents)
+    input.close
+    input.path
   end
 
+  DIR = File.expand_path(File.dirname(__FILE__))
+  LIBDIR = File.expand_path(DIR + '/../lib')
+  BINDIR = File.expand_path(DIR + '/../bin')
 
-  # Other tests are in test_run.rb
-  class TestRctCompleteTDC < Test::Unit::TestCase
-    test = :completion_in_method
-    inputfile = "#{DIR}/data/#{test}-input.rb"
-    outputfile = "#{DIR}/data/#{test}-output.rb"
-    test_script = "#{DIR}/data/#{test}-test.rb"
-    common_opts = ["--filename #{inputfile}", "--line 2"]
-    right_output = File.read(outputfile)
-    wrong_output = "\n"
-
-    tests = {
-      :completion_in_method__testscript =>
-        [ common_opts + ["-t #{test_script}"], right_output ],
-      :completion_in_method__testmethod =>
-        [ common_opts + ["-t #{test_script}@test_fooz"], right_output ],
-      :completion_in_method__wrong_testmethod =>
-        [ common_opts + ["-t #{test_script}@test_NOT_FOUND"], wrong_output ],
-    }
-    exec = File.expand_path(DIR + '/../bin/rct-complete')
-    tests.each_pair do |test, (opts, expected)|
-      define_method("test_#{test}") do 
-        output = `ruby -I#{LIBDIR} #{exec} #{opts.join(" ")} #{inputfile}`
-        assert_equal(expected, output)
+  # rct-complete-TDC 
+  %w[xmpfilter rct-complete rct-doc].each do |subdir|
+    Dir["#{DIR}/data/#{subdir}/*.taf"].each do |taf|
+      desc, cmdline, input, output = parse_taf(taf)
+      [desc, cmdline].each{|x| x.chomp! }
+      define_method("test_#{desc}") do
+        inputfile = tempfile_with_contents(input)
+        actual_output = `ruby -I#{LIBDIR} #{BINDIR}/#{cmdline} #{inputfile}`
+        assert_equal output, actual_output
       end
     end
   end
+  
+  # TODO
+  Dir["#{DIR}/data/rct-complete-TDC/*.taf"].each do |taf|
+    desc, cmdline, input, output, test = parse_taf(taf)
+    [desc, cmdline].each{|x| x.chomp! }
+    define_method("test_#{desc}") do
+      inputfile = tempfile_with_contents(input)
+      testfile = tempfile_with_contents(test)
+      actual_output = `ruby -I#{LIBDIR} #{BINDIR}/#{cmdline % [inputfile, testfile]} #{inputfile}`
+      assert_equal output, actual_output
+    end
+  end
+
 end

data/test/test_method_analyzer.rb

@@ -9,7 +9,7 @@ end
 class MethodAnalyzerTextOutput < Test::Unit::TestCase
   include ScriptConfig
 
-# test (find-sh "ruby -r../method_analyzer data/method_analyzer-data.rb")
+  # test (find-sh "ruby -r../method_analyzer data/method_analyzer-data.rb")
 
   # attr_accessor is actually Module#attr_accessor.
   # But `f?ri Module.attr_accessor' answers correctly.
@@ -68,17 +68,6 @@ class MethodAnalyzerMarshalOutput < Test::Unit::TestCase
   METHOD_ANALYSIS = File.join(DIR, "method_analysis")
   at_exit { File.unlink METHOD_ANALYSIS rescue nil}
 
-  def setup
-    ENV['METHOD_ANALYZER_FORMAT'] = 'marshal'
-    @pwd = Dir.pwd
-    Dir.chdir DIR
-  end
-
-  def teardown
-    ENV['METHOD_ANALYZER_FORMAT'] = nil
-    Dir.chdir @pwd
-  end
-
   def write_temp_file(str, file)
     file.replace File.expand_path(file)
     at_exit { File.unlink file }
@@ -86,14 +75,33 @@ class MethodAnalyzerMarshalOutput < Test::Unit::TestCase
   end
 
   def test_marshal_merged
-    a = write_temp_file "z=1+2", "mergeA.rb"
-    b = write_temp_file "[].empty?", "mergeB.rb"
-
-    system "ruby -r#{SCRIPT} mergeA.rb"
-    system "ruby -r#{SCRIPT} mergeB.rb"
+    begin
+      ENV['METHOD_ANALYZER_FORMAT'] = 'marshal'
+      @pwd = Dir.pwd
+      Dir.chdir DIR
+      a = write_temp_file "z=1+2", "mergeA.rb"
+      system "ruby -r#{SCRIPT} mergeA.rb"
+      method_analysis = Marshal.load(File.read(METHOD_ANALYSIS))
+      assert_equal ["Fixnum#+"],     method_analysis[File.join(DIR, "mergeA.rb")][1]
+    ensure
+      ENV.delete 'METHOD_ANALYZER_FORMAT'
+      Dir.chdir @pwd
+    end
+  end
 
-    method_analysis = Marshal.load(File.read(METHOD_ANALYSIS))
-    assert_equal ["Fixnum#+"],     method_analysis[File.join(DIR, "mergeA.rb")][1]
-    assert_equal ["Array#empty?"], method_analysis[File.join(DIR, "mergeB.rb")][1]
+  def test_marshal_merged
+    begin
+      ENV['METHOD_ANALYZER_FORMAT'] = 'marshal'
+      @pwd = Dir.pwd
+      Dir.chdir DIR
+      
+      b = write_temp_file "[].empty?", "mergeB.rb"
+      system "ruby -r#{SCRIPT} mergeB.rb"
+      method_analysis = Marshal.load(File.read(METHOD_ANALYSIS))
+      assert_equal ["Array#empty?"], method_analysis[File.join(DIR, "mergeB.rb")][1]
+    ensure
+      ENV.delete 'METHOD_ANALYZER_FORMAT'
+      Dir.chdir @pwd
+    end
   end
 end

data/test/test_ruby_toggle_file.rb

@@ -7,105 +7,148 @@ class TestRubyToggleFile < Test::Unit::TestCase
   WORK_DIR = "#{Dir.tmpdir}/zdsfwfwejiotest".freeze
   FileUtils.rm_rf WORK_DIR
 
-  FILE_MAP = {
-    :zero  => %w[lib/zero.rb     test/test_zero.rb],
-    :one   => %w[lib/one/one.rb  test/one/test_one.rb],
-    :two   => %w[lib/two/two.rb  test/test_two.rb],
-    :three => %w[three.rb        test_three.rb],
-    :four  => %w[four.rb],
-    :five  => %w[lib/five.rb],
-    :six   => %w[lib/six/six/six.rb],
-    :seven => %w[                test_seven.rb],
-    :eight => %w[                test/test_eight.rb],
-    :nine  => %w[                test/nine/nine/nine.rb],
-
-    # Rails
-    :rcontrollers => %w[app/controllers/c.rb   test/functional/c_test.rb],
-    :rmodels      => %w[app/models/m.rb        test/unit/m_test.rb],
-    :rlib         => %w[lib/l.rb               test/unit/test_l.rb app/models/m.rb],
-  }
-
-  def use_file_map(key, &block)
-    Dir.mkdir(WORK_DIR)
-    Dir.chdir(WORK_DIR) do
-      FILE_MAP[key].each do |file|
-        FileUtils.mkpath(File.dirname(file))
-        open(file, "w"){}
-      end
-    end
+  def teardown
+    FileUtils.rm_rf WORK_DIR
+  end
 
-    begin
-      yield
-    ensure
-      FileUtils.rm_rf WORK_DIR
+  def create(*files)
+    for file in files.map{|f| _(f) }
+      FileUtils.mkpath(File.dirname(file))
+      open(file,"w"){}
     end
   end
 
-  def setup
-    @x = RubyToggleFile.new
+  def _(path)                   # make full path
+    WORK_DIR + "/" + path
   end
 
-  def _(path)
-    WORK_DIR + "/" + path
+  ###########################################################################
+  # naming convention                                                       #
+  # test_METHOD__EXISTP__IMPLEMENTDIR_TESTDIR                               #
+  ###########################################################################
+  def test_test_file__exist__lib_test
+    create "lib/zero.rb", "test/test_zero.rb"
+    rtf = RubyToggleFile.new
+    assert_equal _("test/test_zero.rb"), rtf.ruby_toggle_file(_("lib/zero.rb"))
   end
 
-  def check(after, before)
-    assert_equal _(after), @x.ruby_toggle_file(_(before))
+  def test_test_file__exist__libone_testone
+    create "lib/one/one.rb", "test/one/test_one.rb"
+    rtf = RubyToggleFile.new
+    assert_equal _("test/one/test_one.rb"), rtf.ruby_toggle_file(_("lib/one/one.rb"))
   end
 
-  def test_test_file_file_exist
-    use_file_map(:zero)  { check "test/test_zero.rb",    "lib/zero.rb"    }
-    use_file_map(:one)   { check "test/one/test_one.rb", "lib/one/one.rb" }
-    use_file_map(:two)   { check "test/test_two.rb",     "lib/two/two.rb" }
-    use_file_map(:three) { check "test_three.rb",        "three.rb"       }
-    end
+  def test_test_file__exist__libtwo_test
+    create "lib/two/two.rb", "test/test_two.rb"
+    rtf = RubyToggleFile.new
+    assert_equal _("test/test_two.rb"), rtf.ruby_toggle_file(_("lib/two/two.rb"))
+  end
+
+  def test_test_file__exist__top_test
+    create "three.rb", "test_three.rb"
+    rtf = RubyToggleFile.new
+    assert_equal _("test_three.rb"), rtf.ruby_toggle_file(_("three.rb"))
+  end
+
+  def test_test_file__not_exist__top
+    create "four.rb"
+    rtf = RubyToggleFile.new
+    assert_equal _("test_four.rb"), rtf.ruby_toggle_file(_("four.rb"))
+  end
+
+  def test_test_file__not_exist__lib
+    create "lib/five.rb"
+    rtf = RubyToggleFile.new
+    assert_equal _("test/test_five.rb"), rtf.ruby_toggle_file(_("lib/five.rb"))
+  end
 
-  def test_test_file_file_not_exist
-    use_file_map(:four) { check "test_four.rb",             "four.rb"            }
-    use_file_map(:five) { check "test/test_five.rb",        "lib/five.rb"        }
-    use_file_map(:six)  { check "test/six/six/test_six.rb", "lib/six/six/six.rb" }
+  def test_test_file__not_exist__libsixsix
+    create "lib/six/six/six.rb"
+    rtf = RubyToggleFile.new
+    assert_equal _("test/six/six/test_six.rb"), rtf.ruby_toggle_file(_("lib/six/six/six.rb"))
   end
 
-  def test_implementation_file_file_exist
-    use_file_map(:zero)  { check "lib/zero.rb",    "test/test_zero.rb"    }
-    use_file_map(:one)   { check "lib/one/one.rb", "test/one/test_one.rb" }
-    use_file_map(:two)   { check "lib/two/two.rb", "test/test_two.rb"     }
-    use_file_map(:three) { check "three.rb",       "test_three.rb"        }
+  def test_implementation_file__exist__lib_test
+    create "lib/zero.rb", "test/test_zero.rb"
+    rtf = RubyToggleFile.new
+    assert_equal _("lib/zero.rb"), rtf.ruby_toggle_file(_("test/test_zero.rb"))
   end
 
-  def test_implementation_file_file_not_exist
-    use_file_map(:seven) { check "seven.rb",     "test_seven.rb"      }
-    use_file_map(:eight) { check "lib/eight.rb", "test/test_eight.rb" }
-    use_file_map(:nine)  { check "lib/nine/nine/nine.rb", "test/nine/nine/test_nine.rb" }
+  def test_implementation_file__exist__libone_testone
+    create "lib/one/one.rb", "test/one/test_one.rb"
+    rtf = RubyToggleFile.new
+    assert_equal _("lib/one/one.rb"), rtf.ruby_toggle_file(_("test/one/test_one.rb"))
   end
 
-#  Rails test
-  def test_test_file_rails_controllers
-    use_file_map(:rcontrollers) { check "test/functional/c_test.rb", "app/controllers/c.rb" }
+  def test_implementation_file__exist__libtwo_test
+    create "lib/two/two.rb", "test/test_two.rb"
+    rtf = RubyToggleFile.new
+    assert_equal _("lib/two/two.rb"), rtf.ruby_toggle_file(_("test/test_two.rb"))
   end
 
-  def test_test_file_rails_models
-    use_file_map(:rmodels) { check "test/unit/m_test.rb", "app/models/m.rb" }
+  def test_implementation_file__exist__top_test
+    create "three.rb", "test_three.rb"
+    rtf = RubyToggleFile.new
+    assert_equal _("three.rb"), rtf.ruby_toggle_file(_("test_three.rb"))
   end
 
-  def test_test_file_rails_lib
-    use_file_map(:rlib) { check "test/unit/test_l.rb", "lib/l.rb" }
+  def test_implementation_file__not_exist__none_top
+    create "test_seven.rb"
+    rtf = RubyToggleFile.new
+    assert_equal _("seven.rb"), rtf.ruby_toggle_file(_("test_seven.rb"))
   end
 
+  def test_implementation_file__not_exist__none_test
+    create "test/test_eight.rb"
+    rtf = RubyToggleFile.new
+    assert_equal _("lib/eight.rb"), rtf.ruby_toggle_file(_("test/test_eight.rb"))
+  end
+
+  def test_implementation_file__not_exist__none_testninenine
+    create "test/nine/nine/nine.rb"
+    rtf = RubyToggleFile.new
+    assert_equal _("lib/nine/nine/nine.rb"), rtf.ruby_toggle_file(_("test/nine/nine/test_nine.rb"))
+  end
 
-  def test_implementation_file_rails_controllers
-    use_file_map(:rcontrollers) { check "app/controllers/c.rb", "test/functional/c_test.rb" }
+  ###########################################################################
+  # Rails test                                                              #
+  ###########################################################################
+  def test_test_file__rails_controllers
+    create "app/controllers/c.rb", "test/functional/c_test.rb"
+    rtf = RubyToggleFile.new
+    assert_equal _("test/functional/c_test.rb"), rtf.ruby_toggle_file(_("app/controllers/c.rb"))
   end
 
-  def test_implementation_file_rails_models
-    use_file_map(:rmodels) { check "app/models/m.rb", "test/unit/m_test.rb" }
+  def test_test_file__rails_models
+    create "app/models/m.rb", "test/unit/m_test.rb"
+    rtf = RubyToggleFile.new
+    assert_equal _("test/unit/m_test.rb"), rtf.ruby_toggle_file(_("app/models/m.rb"))
   end
 
-  def test_implementation_file_rails_lib
-    use_file_map(:rlib) { check "lib/l.rb", "test/unit/test_l.rb" }
+  def test_test_file__rails_lib
+    create "lib/l.rb", "test/unit/test_l.rb", "app/models/m.rb"
+    rtf = RubyToggleFile.new
+    assert_equal _("test/unit/test_l.rb"), rtf.ruby_toggle_file(_("lib/l.rb"))
+  end
+
+
+  def test_implementation_file__rails_controllers
+    create "app/controllers/c.rb", "test/functional/c_test.rb"
+    rtf = RubyToggleFile.new
+    assert_equal _("app/controllers/c.rb"), rtf.ruby_toggle_file(_("test/functional/c_test.rb"))
   end
 
+  def test_implementation_file__rails_models
+    create "app/models/m.rb", "test/unit/m_test.rb"
+    rtf = RubyToggleFile.new
+    assert_equal _("app/models/m.rb"), rtf.ruby_toggle_file(_("test/unit/m_test.rb"))
+  end
 
+  def test_implementation_file__rails_lib
+    create "lib/l.rb", "test/unit/test_l.rb", "app/models/m.rb"
+    rtf = RubyToggleFile.new
+    assert_equal _("lib/l.rb"), rtf.ruby_toggle_file(_("test/unit/test_l.rb"))
+  end
 end
 
 
@@ -117,9 +160,15 @@ class TestRunHooksWithArgsUntilSuccess < Test::Unit::TestCase
   def m004(x) 200 end
 
   public
-  def test_run_hooks_with_args_until_success
+  def test_run_hooks_with_args_until_success__m003
     assert_equal 1000, run_hooks_with_args_until_success(/^m\d+$/, 10)
+  end
+
+  def test_run_hooks_with_args_until_success__m001
     assert_nil   run_hooks_with_args_until_success(/^m001$/, 10)
+  end
+
+  def test_run_hooks_with_args_until_success__m004
     assert_equal 200, run_hooks_with_args_until_success(/^m004$/, 10)
   end
 end

data/test/test_xmpfilter.rb

@@ -2,29 +2,56 @@
 require 'test/unit'
 $: << ".." << "../lib"
 require "rcodetools/xmpfilter"
+require 'rubygems'
+require 'mocha'
 
 class TestXMPFilter < Test::Unit::TestCase
   include Rcodetools
-  def setup
-    @xmp = XMPFilter.new
-    @marker = XMPFilter::MARKER
-    @testdir = File.dirname(__FILE__)
+  def test_extract_data__results
+    marker = XMPFilter::MARKER
+    str = <<-EOF
+#{marker}[1] => Fixnum 42
+#{marker}[1] => Fixnum 0
+#{marker}[1] ==> var
+#{marker}[1] ==> var2
+#{marker}[4] ==> var3
+#{marker}[2] ~> some exception
+#{marker}[10] => Fixnum 42
+    EOF
+    xmp = XMPFilter.new
+    data = xmp.extract_data(str)
+    assert_equal([[1, [["Fixnum", "42"], ["Fixnum", "0"]]], [10, [["Fixnum", "42"]]]], data.results.sort)
   end
 
-  def test_extract_data
+  def test_extract_data__exceptions
+    marker = XMPFilter::MARKER
     str = <<-EOF
-#{@marker}[1] => Fixnum 42
-#{@marker}[1] => Fixnum 0
-#{@marker}[1] ==> var
-#{@marker}[1] ==> var2
-#{@marker}[4] ==> var3
-#{@marker}[2] ~> some exception
-#{@marker}[10] => Fixnum 42
+#{marker}[1] => Fixnum 42
+#{marker}[1] => Fixnum 0
+#{marker}[1] ==> var
+#{marker}[1] ==> var2
+#{marker}[4] ==> var3
+#{marker}[2] ~> some exception
+#{marker}[10] => Fixnum 42
     EOF
-    data = @xmp.extract_data(str)
-    assert_kind_of(XMPFilter::RuntimeData, data)
-    assert_equal([[1, [["Fixnum", "42"], ["Fixnum", "0"]]], [10, [["Fixnum", "42"]]]], data.results.sort)
+    xmp = XMPFilter.new
+    data = xmp.extract_data(str)
     assert_equal([[2, ["some exception"]]], data.exceptions.sort)
+  end
+
+  def test_extract_data__bindings
+    marker = XMPFilter::MARKER
+    str = <<-EOF
+#{marker}[1] => Fixnum 42
+#{marker}[1] => Fixnum 0
+#{marker}[1] ==> var
+#{marker}[1] ==> var2
+#{marker}[4] ==> var3
+#{marker}[2] ~> some exception
+#{marker}[10] => Fixnum 42
+    EOF
+    xmp = XMPFilter.new
+    data = xmp.extract_data(str)
     assert_equal([[1, ["var", "var2"]], [4, ["var3"]]], data.bindings.sort)
   end
 
@@ -34,13 +61,9 @@ class TestXMPFilter < Test::Unit::TestCase
   end
 
   def test_interpreter_command_detect_rct_fork
-    begin
-      def Fork::run?() true end
-      xmp = XMPFilter.new(:interpreter=>"ruby", :detect_rct_fork => true)
-      assert_equal(%w[ruby -S rct-fork-client], xmp.interpreter_command)
-    ensure
-      def Fork::run?() false end
-    end
+    Fork.stubs(:run?).returns true
+    xmp = XMPFilter.new(:interpreter=>"ruby", :detect_rct_fork => true)
+    assert_equal(%w[ruby -S rct-fork-client], xmp.interpreter_command)
   end
 
   def test_interpreter_command_use_rbtest
@@ -49,7 +72,8 @@ class TestXMPFilter < Test::Unit::TestCase
   end
 
   def test_initialize__test_script_1
-    @xmp = XMPFilter.new(:test_script=>"/path/to/test/test_ruby_toggle_file.rb",
+    XMPFilter.any_instance.stubs(:safe_require_code).returns("require 'test/unit'")
+    xmp = XMPFilter.new(:test_script=>"/path/to/test/test_ruby_toggle_file.rb",
                          :test_method=>"test_implementation_file_file_exist",
                          :filename=>"/path/to/lib/ruby_toggle_file.rb")
 
@@ -59,11 +83,12 @@ class TestXMPFilter < Test::Unit::TestCase
       %q!load "/path/to/test/test_ruby_toggle_file.rb"!,
       %q!Test::Unit::AutoRunner.run(false, nil, ["-n", "test_implementation_file_file_exist"])!
     ]
-    assert_equal evals_expected, @xmp.instance_variable_get(:@evals)
+    assert_equal evals_expected, xmp.instance_variable_get(:@evals)
   end
 
   def test_initialize__test_script_2
-    @xmp = XMPFilter.new(:test_script=>"/path/to/test_ruby_toggle_file.rb",
+    XMPFilter.any_instance.stubs(:safe_require_code).returns("require 'test/unit'")
+    xmp = XMPFilter.new(:test_script=>"/path/to/test_ruby_toggle_file.rb",
                          :test_method=>"test_implementation_file_file_exist",
                          :filename=>"/path/to/ruby_toggle_file.rb")
 
@@ -73,13 +98,14 @@ class TestXMPFilter < Test::Unit::TestCase
       %q!load "/path/to/test_ruby_toggle_file.rb"!,
       %q!Test::Unit::AutoRunner.run(false, nil, ["-n", "test_implementation_file_file_exist"])!
     ]
-    assert_equal evals_expected, @xmp.instance_variable_get(:@evals)
+    assert_equal evals_expected, xmp.instance_variable_get(:@evals)
   end
 
   def test_initialize__test_script_3
-    test_script = File.join(@testdir, "data/sample_test_script.rb")
-    filename = File.join(@testdir, "data/sample.rb")
-    @xmp = XMPFilter.new(:test_script=>test_script, :test_method=>"4", :filename=>filename)
+    test_script = File.join(File.dirname(__FILE__), "data/sample_test_script.rb")
+    filename = File.join(File.dirname(__FILE__), "data/sample.rb")
+    XMPFilter.any_instance.stubs(:safe_require_code).returns("require 'test/unit'")
+    xmp = XMPFilter.new(:test_script=>test_script, :test_method=>"4", :filename=>filename)
 
     evals_expected = [
       %q!$LOADED_FEATURES << "sample.rb"!,
@@ -87,33 +113,34 @@ class TestXMPFilter < Test::Unit::TestCase
       %Q!load #{test_script.dump}!,
       %q!Test::Unit::AutoRunner.run(false, nil, ["-n", "test_sample0"])!
     ]
-    assert_equal evals_expected, @xmp.instance_variable_get(:@evals)
+    assert_equal evals_expected, xmp.instance_variable_get(:@evals)
   end
 
   def test_initialize__test_script__filename_eq_test_script
-    test_script = File.join(@testdir, "data/sample_test_script.rb")
+    test_script = File.join(File.dirname(__FILE__), "data/sample_test_script.rb")
     filename = test_script
-    @xmp = XMPFilter.new(:test_script=>test_script, :test_method=>"4", :filename=>filename)
+    xmp = XMPFilter.new(:test_script=>test_script, :test_method=>"4", :filename=>filename)
 
     evals_expected = [
       %q!Test::Unit::AutoRunner.run(false, nil, ["-n", "test_sample0"])!
     ]
-    assert_equal evals_expected, @xmp.instance_variable_get(:@evals)
+    assert_equal evals_expected, xmp.instance_variable_get(:@evals)
   end
 
   def test_get_test_method_from_lineno
-    file = File.join(@testdir, "data/sample_test_script.rb")
-    assert_equal("test_sample0", @xmp.get_test_method_from_lineno(file, 4))
-    assert_equal("test_sample1", @xmp.get_test_method_from_lineno(file, 7))
-    assert_equal("test_sample1", @xmp.get_test_method_from_lineno(file, 8))
-    assert_equal(nil, @xmp.get_test_method_from_lineno(file, 1))
+    file = File.join(File.dirname(__FILE__), "data/sample_test_script.rb")
+    xmp = XMPFilter.new
+    assert_equal("test_sample0", xmp.get_test_method_from_lineno(file, 4))
+    assert_equal("test_sample1", xmp.get_test_method_from_lineno(file, 7))
+    assert_equal("test_sample1", xmp.get_test_method_from_lineno(file, 8))
+    assert_equal(nil, xmp.get_test_method_from_lineno(file, 1))
   end
 
-  def test_s_detect_rbtest
-    # Use variable to avoid confusing syntax highlighting
-    beg = "=begin"
-    ed  = "=end"
-
+  # Use methods to avoid confusing syntax highlighting
+  def beg() "=begin" end
+  def ed()  "=end"   end
+  
+  def test_s_detect_rbtest_1
     rbtest_script_1 = <<XXX
 #{beg} test_0
 assert f(10)
@@ -130,9 +157,9 @@ XXX
     opts = {:detect_rbtest => false, :use_rbtest => true}
     assert_equal true, XMPFilter.detect_rbtest(rbtest_script_1, opts)
     assert_equal true, opts[:use_rbtest]
+  end
 
-
-
+  def test_s_detect_rbtest_2
     rbtest_script_2 = <<XXX
 def f(x) x*100 end
 #{beg} test_0
@@ -145,8 +172,9 @@ XXX
     opts = {:detect_rbtest => false}
     assert_equal false, XMPFilter.detect_rbtest(rbtest_script_2, opts)
     assert_equal false, opts[:use_rbtest]
-
-
+  end
+  
+  def test_s_detect_rbtest_3
     no_rbtest_script = <<XXX
 def f(x) x*100 end
 XXX