ZenTest 3.4.3 → 3.5.1

data/lib/zentest_mapping.rb

@@ -0,0 +1,97 @@
+##
+# ZenTestMapping - mapping method names from impl to test.
+#
+# Method names are mapped bidirectionally in the following way:
+#
+#   method      test_method
+#   method?     test_method_eh          (too much exposure to Canadians :)
+#   method!     test_method_bang
+#   method=     test_method_equals
+#   []          test_index
+#   *           test_times
+#   ==          test_equals2
+#   ===         test_equals3
+#
+# Further, any of the test methods should be able to have arbitrary
+# extensions put on the name to distinguish edge cases:
+#
+#   method      test_method
+#   method      test_method_simple
+#   method      test_method_no_network
+#
+# To allow for unmapped test methods (ie, non-unit tests), name them:
+#
+#   test_integration_.*
+
+module ZenTestMapping
+
+  @@orig_method_map = {
+    '!'   => 'bang',
+    '%'   => 'percent',
+    '&'   => 'and',
+    '*'   => 'times',
+    '**'  => 'times2',
+    '+'   => 'plus',
+    '-'   => 'minus',
+    '/'   => 'div',
+    '<'   => 'lt',
+    '<='  => 'lte',
+    '<=>' => 'spaceship',
+    "<\<" => 'lt2',
+    '=='  => 'equals2',
+    '===' => 'equals3',
+    '=~'  => 'equalstilde',
+    '>'   => 'gt',
+    '>='  => 'ge',
+    '>>'  => 'gt2',
+    '+@'  => 'unary_plus',
+    '-@'  => 'unary_minus',
+    '[]'  => 'index',
+    '[]=' => 'index_equals',
+    '^'   => 'carat',
+    '|'   => 'or',
+    '~'   => 'tilde',
+  }
+
+  @@method_map = @@orig_method_map.merge(@@orig_method_map.invert)
+
+  # Generates a test method name from a normal method,
+  # taking into account names composed of metacharacters
+  # (used for arithmetic, etc
+  def normal_to_test(name)
+    name = name.dup # wtf?
+    is_cls_method = name.sub!(/^self\./, '')
+    name = @@method_map[name] if @@method_map.has_key? name
+    name = name.sub(/=$/, '_equals')
+    name = name.sub(/\?$/, '_eh')
+    name = name.sub(/\!$/, '_bang')
+    name = "class_" + name if is_cls_method
+    "test_#{name}"
+  end
+
+  # Converts a method name beginning with test to its
+  # corresponding normal method name, taking into account
+  # symbolic names which may have been anglicised by
+  # #normal_to_test().
+  def test_to_normal(name, klassname=nil)
+    known_methods = (@inherited_methods[klassname] || {}).keys.sort.reverse
+
+    mapped_re = @@orig_method_map.values.sort_by { |k| k.length }.map {|s| Regexp.escape(s)}.reverse.join("|")
+    known_methods_re = known_methods.map {|s| Regexp.escape(s)}.join("|")
+
+    name = name.sub(/^test_/, '')
+    name = name.sub(/_equals/, '=') unless name =~ /index/
+    name = name.sub(/_bang.*$/, '!') # FIX: deal w/ extensions separately
+    name = name.sub(/_eh/, '?')
+    is_cls_method = name.sub!(/^class_/, '')
+    name = name.sub(/^(#{mapped_re})(.*)$/) {$1}
+    name = name.sub(/^(#{known_methods_re})(.*)$/) {$1} unless known_methods_re.empty?
+
+    # look up in method map
+    name = @@method_map[name] if @@method_map.has_key? name
+
+    name = 'self.' + name if is_cls_method
+
+    name
+  end
+end

data/test/test_autotest.rb

@@ -172,19 +172,39 @@ test_fail2(#{@test_class}) [#{@test}:60]:
 test_error1(#{@test_class}):
   3) Error:
 test_error2(#{@test_class}):
+
+12 tests, 18 assertions, 2 failures, 2 errors
 "
 
     @a.handle_results(s2)
     expected = { @test => %w( test_fail1 test_fail2 test_error1 test_error2 ) }
     assert_equal expected, @a.files_to_test
+    assert @a.tainted
 
     @a.handle_results(s1)
     assert_equal empty, @a.files_to_test
-  end
 
-  # TODO BUG /usr/local/bin/ruby -I.:lib:test test/test_rails_autotest.rb -n "/^(test_hooks)$/" | unit_diff -u; /usr/local/bin/ruby -I.:lib:test test/test_autotest.rb -n "/^(test_hooks|test_hooks)$/" | unit_diff -u
+    s3 = '
+/opt/bin/ruby -I.:lib:test -rtest/unit -e "%w[#{@test}].each { |f| require f }" | unit_diff -u
+-e:1:in `require\': ./#{@test}:23: parse error, unexpected tIDENTIFIER, expecting \'}\' (SyntaxError)
+    settings_fields.each {|e| assert_equal e, version.send e.intern}
+                                                            ^   from -e:1
+        from -e:1:in `each\'
+        from -e:1
+'
+    @a.files_to_test[@test] = Time.at(42)
+    @a.files[@test] = []
+    expected = { @test => Time.at(42) }
+    assert_equal expected, @a.files_to_test
+    @a.handle_results(s3)
+    assert_equal expected, @a.files_to_test
+    assert @a.tainted
+    @a.tainted = false
 
-  # TODO BUG /usr/local/bin/ruby -I.:lib:test test/test_rails_autotest.rb -n "/^(test_hook|test_hooks)$/" | unit_diff -u; /usr/local/bin/ruby -I.:lib:test test/test_autotest.rb -n "/^(test_hooks|test_hooks)$/" | unit_diff -u
+    @a.handle_results(s1)
+    assert_equal empty, @a.files_to_test
+    assert ! @a.tainted
+  end
 
   def test_hook_overlap
     Autotest.clear_hooks

data/test/test_help.rb

@@ -1,8 +1,8 @@
 # ActionPack
 module ActionController; end
 module ActionController::Flash; end
-class ActionController::Flash::FlashHash; end
-class ActionController::TestSession < Hash; end
+class ActionController::Flash::FlashHash < Hash; end
+class ActionController::TestSession; end
 
 class ActionController::TestRequest
   attr_accessor :session
@@ -15,16 +15,22 @@ module ActionView; end
 module ActionView::Helpers; end
 module ActionView::Helpers::ActiveRecordHelper; end
 module ActionView::Helpers::TagHelper; end
+module ActionView::Helpers::TextHelper; end
 module ActionView::Helpers::FormTagHelper; end
 module ActionView::Helpers::FormOptionsHelper; end
 module ActionView::Helpers::FormHelper; end
 module ActionView::Helpers::UrlHelper; end
 module ActionView::Helpers::AssetTagHelper; end
 
-# ActionMailer
+class << Test::Unit::TestCase
+  attr_accessor :use_transactional_fixtures
+  attr_accessor :use_instantiated_fixtures
+end
 
+# ActionMailer
 module ActionMailer; end
 class ActionMailer::Base
-  def self.deliveries=(arg); end
+  def self.deliveries=(arg); end unless defined? @@defined
+  @@defined = true
 end
 

data/test/test_rails_autotest.rb

@@ -1,5 +1,5 @@
 require 'test/unit' if $0 == __FILE__
-require 'test_autotest'
+require 'test/test_autotest'
 require 'rails_autotest'
 
 class TestRailsAutotest < TestAutotest
@@ -77,8 +77,9 @@ class TestRailsAutotest < TestAutotest
                         'test/functional/admin/themes_controller_test.rb')
 
     util_tests_for_file('app/controllers/application.rb',
-                        'test/controllers/dummy_controller_test.rb',
-                        'test/functional/dummy_controller_test.rb')
+                        @rails_controller_tests,
+                        @rails_view_tests,
+                        @rails_functional_tests)
 
     util_tests_for_file('app/controllers/route_controller.rb',
                         'test/controllers/route_controller_test.rb',
@@ -88,7 +89,8 @@ class TestRailsAutotest < TestAutotest
 
     # helpers
     util_tests_for_file('app/helpers/application_helper.rb',
-                        @rails_view_tests + @rails_functional_tests)
+                        @rails_view_tests,
+                        @rails_functional_tests)
 
     util_tests_for_file('app/helpers/route_helper.rb',
                         'test/views/route_view_test.rb',

data/test/test_rails_controller_test_case.rb

@@ -13,7 +13,7 @@ class TRController < ApplicationController
 end if $TESTING_RTC
 
 class TestRailsControllerTestCase < Test::Rails::ControllerTestCase
-  
+
   def setup
     @controller_class_name = 'TRController'
     super
@@ -31,9 +31,17 @@ class TestRailsControllerTestCase < Test::Rails::ControllerTestCase
       assert_assigned :no_ivar
     end
 
-    assert_raise Test::Unit::AssertionFailedError do
+    e = assert_raise Test::Unit::AssertionFailedError do
       assert_assigned :ivar, 'bad_value'
     end
+
+    expected = <<-EOF.strip
+assert_assigned :ivar.
+<\"bad_value\"> expected but was
+<\"value\">.
+    EOF
+
+    assert_equal expected, e.message
   end
 
   def test_deny_assigned

data/test/test_ruby_fork.rb

@@ -50,18 +50,6 @@ class TestRubyFork < Test::Unit::TestCase
     assert_equal expected, settings
   end
 
-  def test_parse_server_args_execute
-    expected = util_make_settings [], ['foo']
-
-    settings = RubyFork.parse_server_args ['-e', 'foo']
-    assert_equal expected, settings
-
-    expected = util_make_settings [], ['foo', 'bar']
-
-    settings = RubyFork.parse_server_args ['-e', 'foo', '-e', 'bar']
-    assert_equal expected, settings
-  end
-
   def test_parse_server_args_include
     expected = util_make_settings nil, nil, ['lib'], nil, false
 
@@ -102,6 +90,18 @@ class TestRubyFork < Test::Unit::TestCase
   end
 
   def test_parse_server_args_execute
+    expected = util_make_settings [], ['foo'], nil, nil, false
+
+    settings = RubyFork.parse_server_args ['-e', 'foo']
+    assert_equal expected, settings
+
+    expected = util_make_settings [], ['foo', 'bar'], nil, nil, false
+
+    settings = RubyFork.parse_server_args ['-e', 'foo', '-e', 'bar']
+    assert_equal expected, settings
+  end
+
+  def test_parse_server_args_execute_duplicate_test? # FIX
     expected = util_make_settings ['zentest'], nil, nil, nil, false
 
     settings = RubyFork.parse_server_args ['-r', 'zentest']

data/test/test_unit_diff.rb

@@ -1,6 +1,7 @@
 #!/usr/local/bin/ruby -w
 
 require 'test/unit'
+require 'stringio'
 
 $TESTING = true
 
@@ -13,25 +14,21 @@ class TestUnitDiff < Test::Unit::TestCase
   end
 
   def test_input
-    input = "Loaded suite ./blah\nStarted\nFF\nFinished in 0.035332 seconds.\n\n  1) Failure:\ntest_test1(TestBlah) [./blah.rb:25]:\n<\"line1\\nline2\\nline3\\n\"> expected but was\n<\"line4\\nline5\\nline6\\n\">.\n\n  2) Failure:\ntest_test2(TestBlah) [./blah.rb:29]:\n<\"line1\"> expected but was\n<\"line2\\nline3\\n\\n\">.\n\n2 tests, 2 assertions, 2 failures, 0 errors\n"
+    header = "Loaded suite ./blah\nStarted\nFF\nFinished in 0.035332 seconds.\n\n"
+    input = "#{header}  1) Failure:\ntest_test1(TestBlah) [./blah.rb:25]:\n<\"line1\\nline2\\nline3\\n\"> expected but was\n<\"line4\\nline5\\nline6\\n\">.\n\n  2) Failure:\ntest_test2(TestBlah) [./blah.rb:29]:\n<\"line1\"> expected but was\n<\"line2\\nline3\\n\\n\">.\n\n2 tests, 2 assertions, 2 failures, 0 errors\n"
 
     # TODO: I think I'd like a separate footer array as well
-    expected = [
-                ["Loaded suite ./blah\n", "Started\n", "FF\n", "Finished in 0.035332 seconds.\n"],
-                [
-                 ["  1) Failure:\n", "test_test1(TestBlah) [./blah.rb:25]:\n", "<\"line1\\nline2\\nline3\\n\"> expected but was\n", "<\"line4\\nline5\\nline6\\n\">.\n"],
-                 ["  2) Failure:\n", "test_test2(TestBlah) [./blah.rb:29]:\n", "<\"line1\"> expected but was\n", "<\"line2\\nline3\\n\\n\">.\n"],
-                 ],
-                ["\n", "2 tests, 2 assertions, 2 failures, 0 errors\n"]
-               ]
+    expected = [[["  1) Failure:\n", "test_test1(TestBlah) [./blah.rb:25]:\n", "<\"line1\\nline2\\nline3\\n\"> expected but was\n", "<\"line4\\nline5\\nline6\\n\">.\n"],
+                 ["  2) Failure:\n", "test_test2(TestBlah) [./blah.rb:29]:\n", "<\"line1\"> expected but was\n", "<\"line2\\nline3\\n\\n\">.\n"]],
+                ["\n", "2 tests, 2 assertions, 2 failures, 0 errors\n"]]
 
-    assert_equal expected, @diff.input(input)
+    util_unit_diff(header, input, expected, :parse_input)
   end
 
   def test_unit_diff_empty # simulates broken pipe at the least
     input = ""
     expected = ""
-    assert_equal expected, @diff.unit_diff(input)
+    util_unit_diff("", "", "")
   end
 
   def test_parse_diff_angles
@@ -112,52 +109,59 @@ class TestUnitDiff < Test::Unit::TestCase
   end
 
   def test_unit_diff_angles
-    input = "Loaded suite ./blah\nStarted\nF\nFinished in 0.035332 seconds.\n\n  1) Failure:\ntest_test1(TestBlah) [./blah.rb:25]:\n<\"<html>\"> expected but was\n<\"<body>\">.\n\n1 tests, 1 assertions, 1 failures, 0 errors\n"
-
-    expected = "Loaded suite ./blah\nStarted\nF\nFinished in 0.035332 seconds.\n\n1) Failure:\ntest_test1(TestBlah) [./blah.rb:25]:\n1c1\n< <html>\n---\n> <body>\n\n1 tests, 1 assertions, 1 failures, 0 errors"
+    header = "Loaded suite ./blah\nStarted\nF\nFinished in 0.035332 seconds.\n\n"
+    input = "#{header}  1) Failure:\ntest_test1(TestBlah) [./blah.rb:25]:\n<\"<html>\"> expected but was\n<\"<body>\">.\n\n1 tests, 1 assertions, 1 failures, 0 errors\n"
+    expected = "1) Failure:\ntest_test1(TestBlah) [./blah.rb:25]:\n1c1\n< <html>\n---\n> <body>\n\n1 tests, 1 assertions, 1 failures, 0 errors"
 
-    assert_equal expected, @diff.unit_diff(input)
+    util_unit_diff(header, input, expected)
   end
 
   def test_unit_diff1
-    input = "Loaded suite ./blah\nStarted\nF\nFinished in 0.035332 seconds.\n\n  1) Failure:\ntest_test1(TestBlah) [./blah.rb:25]:\n<\"line1\\nline2\\nline3\\n\"> expected but was\n<\"line4\\nline5\\nline6\\n\">.\n\n1 tests, 1 assertions, 1 failures, 0 errors\n"
+    header = "Loaded suite ./blah\nStarted\nF\nFinished in 0.035332 seconds.\n\n"
+    input = "#{header}  1) Failure:\ntest_test1(TestBlah) [./blah.rb:25]:\n<\"line1\\nline2\\nline3\\n\"> expected but was\n<\"line4\\nline5\\nline6\\n\">.\n\n1 tests, 1 assertions, 1 failures, 0 errors\n"
+    expected = "1) Failure:\ntest_test1(TestBlah) [./blah.rb:25]:\n1,3c1,3\n< line1\n< line2\n< line3\n---\n> line4\n> line5\n> line6\n\n1 tests, 1 assertions, 1 failures, 0 errors"
 
-    expected = "Loaded suite ./blah\nStarted\nF\nFinished in 0.035332 seconds.\n\n1) Failure:\ntest_test1(TestBlah) [./blah.rb:25]:\n1,3c1,3\n< line1\n< line2\n< line3\n---\n> line4\n> line5\n> line6\n\n1 tests, 1 assertions, 1 failures, 0 errors"
-
-    assert_equal expected, @diff.unit_diff(input)
+    util_unit_diff(header, input, expected)
   end
 
   def test_unit_diff2
-    input = "Loaded suite ./blah\nStarted\nFF\nFinished in 0.035332 seconds.\n\n  1) Failure:\ntest_test1(TestBlah) [./blah.rb:25]:\n<\"line1\\nline2\\nline3\\n\"> expected but was\n<\"line4\\nline5\\nline6\\n\">.\n\n  2) Failure:\ntest_test2(TestBlah) [./blah.rb:29]:\n<\"line1\"> expected but was\n<\"line2\\nline3\\n\\n\">.\n\n2 tests, 2 assertions, 2 failures, 0 errors\n"
-
-    expected = "Loaded suite ./blah\nStarted\nFF\nFinished in 0.035332 seconds.\n\n1) Failure:\ntest_test1(TestBlah) [./blah.rb:25]:\n1,3c1,3\n< line1\n< line2\n< line3\n---\n> line4\n> line5\n> line6\n\n2) Failure:\ntest_test2(TestBlah) [./blah.rb:29]:\n1c1,4\n< line1\n---\n> line2\n> line3\n> \n> \n\n2 tests, 2 assertions, 2 failures, 0 errors"
+    header = "Loaded suite ./blah\nStarted\nFF\nFinished in 0.035332 seconds.\n\n"
+    input = "#{header}  1) Failure:\ntest_test1(TestBlah) [./blah.rb:25]:\n<\"line1\\nline2\\nline3\\n\"> expected but was\n<\"line4\\nline5\\nline6\\n\">.\n\n  2) Failure:\ntest_test2(TestBlah) [./blah.rb:29]:\n<\"line1\"> expected but was\n<\"line2\\nline3\\n\\n\">.\n\n2 tests, 2 assertions, 2 failures, 0 errors\n"
+    expected = "1) Failure:\ntest_test1(TestBlah) [./blah.rb:25]:\n1,3c1,3\n< line1\n< line2\n< line3\n---\n> line4\n> line5\n> line6\n\n2) Failure:\ntest_test2(TestBlah) [./blah.rb:29]:\n1c1,4\n< line1\n---\n> line2\n> line3\n> \n> \n\n2 tests, 2 assertions, 2 failures, 0 errors"
 
-    assert_equal expected, @diff.unit_diff(input)
+    util_unit_diff(header, input, expected)
   end
 
   def test_unit_diff3
+    header = ""
     input = " 13) Failure:\ntest_case_stmt(TestRubyToRubyC) [./r2ctestcase.rb:1198]:\nUnknown expected data.\n<false> is not true.\n"
-
     expected = "13) Failure:\ntest_case_stmt(TestRubyToRubyC) [./r2ctestcase.rb:1198]:\nUnknown expected data.\n<false> is not true."
 
-    assert_equal expected, @diff.unit_diff(input)
+    util_unit_diff(header, input, expected)
   end
 
   def test_unit_diff_suspect_equals
-    input = ".............................................F............................................\nFinished in 0.834671 seconds.\n\n  1) Failure:\ntest_unit_diff_suspect_equals(TestUnitDiff) [./test/test_unit_diff.rb:122]:\n<\"out\"> expected but was\n<\"out\">.\n\n90 tests, 241 assertions, 1 failures, 0 errors"
-
-    expected = ".............................................F............................................\nFinished in 0.834671 seconds.\n\n1) Failure:\ntest_unit_diff_suspect_equals(TestUnitDiff) [./test/test_unit_diff.rb:122]:\n[no difference--suspect ==]\n\n90 tests, 241 assertions, 1 failures, 0 errors"
+    header   = "Loaded suite ./blah\nStarted\n.............................................F............................................\nFinished in 0.834671 seconds.\n\n"
+    footer   = "90 tests, 241 assertions, 1 failures, 0 errors"
+    input    = "#{header}  1) Failure:\ntest_unit_diff_suspect_equals(TestUnitDiff) [./test/test_unit_diff.rb:122]:\n<\"out\"> expected but was\n<\"out\">.\n\n#{footer}"
+    expected = "1) Failure:\ntest_unit_diff_suspect_equals(TestUnitDiff) [./test/test_unit_diff.rb:122]:\n[no difference--suspect ==]\n\n#{footer}"
 
-    assert_equal expected, @diff.unit_diff(input)
+    util_unit_diff(header, input, expected)
   end
 
   def test_unit_diff_NOT_suspect_equals
-    input = ".\nFinished in 0.0 seconds.\n\n  1) Failure:\ntest_blah(TestBlah)\n<\"out\"> expected but was\n<\"out\\n\">.\n\n1 tests, 1 assertions, 1 failures, 0 errors"
+    header   = "Loaded suite ./blah\nStarted\n.\nFinished in 0.0 seconds.\n\n"
+    input    = "#{header}  1) Failure:\ntest_blah(TestBlah)\n<\"out\"> expected but was\n<\"out\\n\">.\n\n1 tests, 1 assertions, 1 failures, 0 errors"
+    expected = "1) Failure:\ntest_blah(TestBlah)\n1a2\n> \n\n1 tests, 1 assertions, 1 failures, 0 errors"
 
-    expected = ".\nFinished in 0.0 seconds.\n\n1) Failure:\ntest_blah(TestBlah)\n1a2\n> \n\n1 tests, 1 assertions, 1 failures, 0 errors"
-
-    assert_equal expected, @diff.unit_diff(input)
+    util_unit_diff(header, input, expected)
   end
 
+  def util_unit_diff(header, input, expected, msg=:unit_diff)
+    output = StringIO.new("")
+    actual = @diff.send(msg, StringIO.new(input), output)
+    assert_equal header, output.string
+    assert_equal expected, actual
+  end
 end
 

data/test/test_zentest.rb

@@ -10,25 +10,25 @@ require 'zentest' unless defined? $ZENTEST
 # These are just classes set up for quick testing.
 # TODO: need to test a compound class name Mod::Cls
 
-class Cls1				# ZenTest SKIP
+class Cls1              # ZenTest SKIP
   def meth1; end
   def self.meth2; end
 end
 
-class TestCls1				# ZenTest SKIP
+class TestCls1              # ZenTest SKIP
   def setup; end
   def teardown; end
   def test_meth1; end
   def test_meth2; assert(true, "something"); end
 end
 
-class SuperDuper			# ZenTest SKIP
+class SuperDuper            # ZenTest SKIP
   def self.cls_inherited; end
   def inherited; end
   def overridden; end
 end
 
-class LowlyOne < SuperDuper		# ZenTest SKIP
+class LowlyOne < SuperDuper     # ZenTest SKIP
   def self.cls_extended; end
   def overridden; end
   def extended; end
@@ -235,20 +235,20 @@ end
   def test_is_test_class
     # classes
     assert(@tester.is_test_class(TestCls1),
-	   "All test classes must start with Test")
+       "All test classes must start with Test")
     assert(!@tester.is_test_class(Cls1),
-	   "Classes not starting with Test must not be test classes")
+       "Classes not starting with Test must not be test classes")
     # strings
     assert(@tester.is_test_class("TestCls1"),
-	   "All test classes must start with Test")
+       "All test classes must start with Test")
     assert(@tester.is_test_class("TestMod::TestCls1"),
-	   "All test modules must start with test as well")
+       "All test modules must start with test as well")
     assert(!@tester.is_test_class("Cls1"),
-	   "Classes not starting with Test must not be test classes")
+       "Classes not starting with Test must not be test classes")
     assert(!@tester.is_test_class("NotTestMod::TestCls1"),
-	   "Modules not starting with Test must not be test classes")
+       "Modules not starting with Test must not be test classes")
     assert(!@tester.is_test_class("NotTestMod::NotTestCls1"),
-	   "All names must start with Test to be test classes")
+       "All names must start with Test to be test classes")
   end
 
   def test_is_test_class_reversed
@@ -272,9 +272,9 @@ end
     assert_equal('TestCls1', @tester.convert_class_name('Cls1'))
 
     assert_equal('TestModule::TestCls1',
-		 @tester.convert_class_name('Module::Cls1'))
+         @tester.convert_class_name('Module::Cls1'))
     assert_equal('Module::Cls1',
-		 @tester.convert_class_name('TestModule::TestCls1'))
+         @tester.convert_class_name('TestModule::TestCls1'))
   end
 
   def test_convert_class_name_reversed
@@ -288,9 +288,9 @@ end
     assert_equal('Cls1Test', @tester.convert_class_name('Cls1'))
 
     assert_equal('ModuleTest::Cls1Test',
-		 @tester.convert_class_name('Module::Cls1'))
+         @tester.convert_class_name('Module::Cls1'))
     assert_equal('Module::Cls1',
-		 @tester.convert_class_name('ModuleTest::Cls1Test'))
+         @tester.convert_class_name('ModuleTest::Cls1Test'))
     $r = old
   end
 
@@ -452,130 +452,6 @@ end
     assert_equal({}, @tester.inherited_methods["SuperDuper"])
   end
 
-  def test_normal_to_test
-    self.util_simple_setup
-    assert_equal("test_method1",        @tester.normal_to_test("method1"))
-    assert_equal("test_method1_bang",   @tester.normal_to_test("method1!"))
-    assert_equal("test_method1_eh",     @tester.normal_to_test("method1?"))
-    assert_equal("test_method1_equals", @tester.normal_to_test("method1="))
-  end
-
-  def test_normal_to_test_cls
-    self.util_simple_setup
-    assert_equal("test_class_method1",        @tester.normal_to_test("self.method1"))
-    assert_equal("test_class_method1_bang",   @tester.normal_to_test("self.method1!"))
-    assert_equal("test_class_method1_eh",     @tester.normal_to_test("self.method1?"))
-    assert_equal("test_class_method1_equals", @tester.normal_to_test("self.method1="))
-  end
-
-  def test_normal_to_test_operators
-    self.util_simple_setup
-    assert_equal("test_and",     @tester.normal_to_test("&"))
-    assert_equal("test_bang",    @tester.normal_to_test("!"))
-    assert_equal("test_carat",   @tester.normal_to_test("^"))
-    assert_equal("test_div",     @tester.normal_to_test("/"))
-    assert_equal("test_equalstilde", @tester.normal_to_test("=~"))
-    assert_equal("test_minus",   @tester.normal_to_test("-"))
-    assert_equal("test_or",      @tester.normal_to_test("|"))
-    assert_equal("test_percent", @tester.normal_to_test("%"))
-    assert_equal("test_plus",    @tester.normal_to_test("+"))
-    assert_equal("test_tilde",   @tester.normal_to_test("~"))
-  end
-
-  def test_normal_to_test_overlap
-    self.util_simple_setup
-    assert_equal("test_equals2",       @tester.normal_to_test("=="))
-    assert_equal("test_equals3",       @tester.normal_to_test("==="))
-    assert_equal("test_ge",            @tester.normal_to_test(">="))
-    assert_equal("test_gt",            @tester.normal_to_test(">"))
-    assert_equal("test_gt2",           @tester.normal_to_test(">>"))
-    assert_equal("test_index",         @tester.normal_to_test("[]"))
-    assert_equal("test_index_equals",  @tester.normal_to_test("[]="))
-    assert_equal("test_lt",            @tester.normal_to_test("<"))
-    assert_equal("test_lt2",           @tester.normal_to_test("<\<"))
-    assert_equal("test_lte",           @tester.normal_to_test("<="))
-    assert_equal("test_method",        @tester.normal_to_test("method"))
-    assert_equal("test_method_equals", @tester.normal_to_test("method="))
-    assert_equal("test_spaceship",     @tester.normal_to_test("<=>"))
-    assert_equal("test_times",         @tester.normal_to_test("*"))
-    assert_equal("test_times2",        @tester.normal_to_test("**"))
-    assert_equal("test_unary_minus",   @tester.normal_to_test("-@"))
-    assert_equal("test_unary_plus",    @tester.normal_to_test("+@"))
-    assert_equal("test_class_index",   @tester.normal_to_test("self.[]"))
-  end
-
-  def test_test_to_normal
-    self.util_simple_setup
-    assert_equal("method1!", @tester.test_to_normal("test_method1_bang", "Something"))
-    assert_equal("method1",  @tester.test_to_normal("test_method1", "Something"))
-    assert_equal("method1=", @tester.test_to_normal("test_method1_equals", "Something"))
-    assert_equal("method1?", @tester.test_to_normal("test_method1_eh", "Something"))
-  end
-
-  def test_test_to_normal_cls
-    self.util_simple_setup
-    assert_equal("self.method1",  @tester.test_to_normal("test_class_method1"))
-    assert_equal("self.method1!", @tester.test_to_normal("test_class_method1_bang"))
-    assert_equal("self.method1?", @tester.test_to_normal("test_class_method1_eh"))
-    assert_equal("self.method1=", @tester.test_to_normal("test_class_method1_equals"))
-    assert_equal("self.[]", @tester.test_to_normal("test_class_index"))
-  end
-
-  def test_test_to_normal_extended
-    self.util_simple_setup
-    assert_equal("equal?",  @tester.test_to_normal("test_equal_eh_extension", "Something"))
-    assert_equal("equal?",  @tester.test_to_normal("test_equal_eh_extension_again", "Something"))
-    assert_equal("method1", @tester.test_to_normal("test_method1_extension", "Something"))
-    assert_equal("method1", @tester.test_to_normal("test_method1_extension_again", "Something"))
-  end
-
-  def test_test_to_normal_mapped
-    self.util_simple_setup
-    assert_equal("*",   @tester.test_to_normal("test_times"))
-    assert_equal("*",   @tester.test_to_normal("test_times_ext"))
-    assert_equal("==",  @tester.test_to_normal("test_equals2"))
-    assert_equal("==",  @tester.test_to_normal("test_equals2_ext"))
-    assert_equal("===", @tester.test_to_normal("test_equals3"))
-    assert_equal("===", @tester.test_to_normal("test_equals3_ext"))
-    assert_equal("[]",  @tester.test_to_normal("test_index"))
-    assert_equal("[]",  @tester.test_to_normal("test_index_ext"))
-    assert_equal("[]=", @tester.test_to_normal("test_index_equals"))
-    assert_equal("[]=", @tester.test_to_normal("test_index_equals_ext"))
-  end
-
-  def test_test_to_normal_operators
-    self.util_simple_setup
-    assert_equal("&",  @tester.test_to_normal("test_and"))
-    assert_equal("!",  @tester.test_to_normal("test_bang"))
-    assert_equal("^",  @tester.test_to_normal("test_carat"))
-    assert_equal("/",  @tester.test_to_normal("test_div"))
-    assert_equal("=~", @tester.test_to_normal("test_equalstilde"))
-    assert_equal("-",  @tester.test_to_normal("test_minus"))
-    assert_equal("|",  @tester.test_to_normal("test_or"))
-    assert_equal("%",  @tester.test_to_normal("test_percent"))
-    assert_equal("+",  @tester.test_to_normal("test_plus"))
-    assert_equal("~",  @tester.test_to_normal("test_tilde"))
-  end
-
-  def test_test_to_normal_overlap
-    self.util_simple_setup
-    assert_equal("==",  @tester.test_to_normal("test_equals2"))
-    assert_equal("===", @tester.test_to_normal("test_equals3"))
-    assert_equal(">=",  @tester.test_to_normal("test_ge"))
-    assert_equal(">",   @tester.test_to_normal("test_gt"))
-    assert_equal(">>",  @tester.test_to_normal("test_gt2"))
-    assert_equal("[]",  @tester.test_to_normal("test_index"))
-    assert_equal("[]=", @tester.test_to_normal("test_index_equals"))
-    assert_equal("<",   @tester.test_to_normal("test_lt"))
-    assert_equal("<\<", @tester.test_to_normal("test_lt2"))
-    assert_equal("<=",  @tester.test_to_normal("test_lte"))
-    assert_equal("<=>", @tester.test_to_normal("test_spaceship"))
-    assert_equal("*",   @tester.test_to_normal("test_times"))
-    assert_equal("**",  @tester.test_to_normal("test_times2"))
-    assert_equal("-@",  @tester.test_to_normal("test_unary_minus"))
-    assert_equal("+@",  @tester.test_to_normal("test_unary_plus"))
-  end
-
   def test_klasses_equals
     self.util_simple_setup
     assert_equal({"Something"=> {
@@ -662,6 +538,4 @@ assert_equal expected, util_testcase("Something2::Blah2", "TestSomething2::TestB
 
     assert_equal expected, util_testcase("TestTrueClass")
   end
-
 end
-