test-unit-ext 0.1.0 → 0.2.0

data/lib/test-unit-ext/priority.rb

@@ -150,14 +150,14 @@ module Test
         end
       end
 
-      alias_method :original_run, :run
+      alias_method :run_without_priority_support, :run
       def run(*args, &block)
         priority_mode = @@priority_mode
         if priority_mode
           @original_tests = @tests
           apply_priority
         end
-        original_run(*args, &block)
+        run_without_priority_support(*args, &block)
       ensure
         @tests = @original_tests if priority_mode
       end

data/lib/test-unit-ext/version.rb

@@ -1,3 +1,3 @@
 module TestUnitExt
-  VERSION = "0.1.0"
+  VERSION = "0.2.0"
 end

data/lib/test-unit-ext/xml-report.rb

@@ -0,0 +1,226 @@
+require "erb"
+require "test/unit/failure"
+require "test/unit/error"
+require "test/unit/testresult"
+require "test/unit/testsuite"
+require "test/unit/autorunner"
+
+module Test
+  module Unit
+    module XMLReportable
+      include ERB::Util
+
+      def to_xml
+        <<-XML.gsub(/\s*(\n  <result>|\n<\/test_log>)/m, "\\1")
+<test_log>
+  <test_case>
+    <name>#{h(@test.class.name)}</name>
+    <description/>
+  </test_case>
+  <name>#{h(@test.method_name)}</name>
+  <description/>
+#{metadata_xml}
+  <result>
+    <status>#{h(status_name)}</status>
+    <detail>#{h(message)}</detail>
+    <elapsed>#{h(elapsed_time)}</elapsed>
+  </result>
+#{backtrace_xml}
+</test_log>
+XML
+      end
+
+      private
+      def metadata_xml
+        return "" if @test.metadata.empty?
+        item = @test.metadata.collect do |key, value|
+          <<-XML
+    <item>
+      <name>#{h(key)}</name>
+      <value>#{h(value)}</value>
+    </item>
+XML
+        end
+        "  <metadata>\n#{item.join()}  </metadata>"
+      end
+
+      def backtrace_xml
+        entries = backtrace_entries_xml
+        if entries.empty?
+          ""
+        else
+          <<-XML
+  <backtrace>
+#{entries.join.rstrip}
+  </backtrace>
+XML
+        end
+      end
+
+      def backtrace_entries_xml
+        location.collect do |location|
+          file, line, info = location.split(/:(\d+):/)
+          <<-XML
+    <entry>
+      <file>#{h(file)}</file>
+      <line>#{h(line)}</line>
+      <info>#{h(info.to_s.strip)}</info>
+    </entry>
+XML
+        end
+      end
+    end
+
+    class Success
+      include XMLReportable
+
+      attr_reader :test, :elapsed_time
+      def initialize(test, elapsed_time)
+        @test = test
+        @elapsed_time = elapsed_time
+      end
+
+      def message
+        nil
+      end
+
+      def location
+        []
+      end
+
+      def test_name
+        @test.name
+      end
+
+      def test_case_name
+        /\((.*)\)\z/ =~ test_name
+        $1
+      end
+
+      def status_name
+        "success"
+      end
+    end
+
+    class Failure
+      include XMLReportable
+
+      attr_accessor :test, :elapsed_time
+
+      def status_name
+        "failure"
+      end
+    end
+
+    class Error
+      include XMLReportable
+
+      attr_accessor :test, :elapsed_time
+
+      def status_name
+        "error"
+      end
+
+      def location
+        filter_backtrace(@exception.backtrace)
+      end
+    end
+
+    class TestCase
+      alias_method(:run_without_success_notify, :run)
+      def run(result, &block)
+        @_start_time = Time.now
+        run_result = run_without_success_notify(result, &block)
+        result.add_success(Success.new(self, Time.now - @_start_time)) if passed?
+        run_result
+      end
+
+      alias_method(:add_failure_without_test_case_set, :add_failure)
+      def add_failure(*args)
+        add_failure_without_test_case_set(*args)
+        failure = @_result.failures.last
+        failure.test = self
+        failure.elapsed_time = Time.now - @_start_time
+      end
+
+      alias_method(:add_error_without_test_case_set, :add_error)
+      def add_error(*args)
+        add_error_without_test_case_set(*args)
+        error = @_result.errors.last
+        error.test = self
+        error.elapsed_time = Time.now - @_start_time
+      end
+    end
+
+    class TestResult
+      attr_reader :failures, :errors
+
+      alias_method(:initialize_without_successes, :initialize)
+      def initialize
+        initialize_without_successes
+        @successes = []
+        @logs = []
+      end
+
+      def add_success(success)
+        @logs << success
+        @successes << success
+      end
+
+      alias_method(:add_failure_without_logs_store, :add_failure)
+      def add_failure(failure)
+        @logs << failure
+        add_failure_without_logs_store(failure)
+      end
+
+      alias_method(:add_error_without_logs_store, :add_error)
+      def add_error(error)
+        @logs << error
+        add_error_without_logs_store(error)
+      end
+
+      def to_xml
+        return "<test_logs/>" if @logs.empty?
+        xml = @logs.collect {|log| log.to_xml.gsub(/^/, "  ")}.join
+        "<test_logs>\n#{xml}</test_logs>\n"
+      end
+    end
+
+    class TestSuite
+      attr_reader :result
+
+      alias_method(:run_without_keep_result, :run)
+      def run(result, &block)
+        @result = result
+        run_without_keep_result(result, &block)
+      end
+    end
+
+    class AutoRunner
+      alias_method(:options_without_xml_report_support, :options)
+      def options
+        opt = options_without_xml_report_support
+        @xml_report_support_option_added ||= false
+        unless @xml_report_support_option_added
+          @xml_report_file = nil
+          opt.on('--xml-report=FILE',
+                 "Output test report in XML to FILE.") do |file|
+            @xml_report_file = file
+          end
+        end
+        opt
+      end
+
+      alias_method(:run_without_xml_report_support, :run)
+      def run
+        passed = run_without_xml_report_support
+        if @xml_report_file
+          File.open(@xml_report_file, "w") do |f|
+            f.print(@suite.result.to_xml)
+          end
+        end
+        passed
+      end
+    end
+  end
+end

data/test/test_diff.rb

@@ -1,9 +1,10 @@
-require 'test-unit-ext'
-
 class TestDiff < Test::Unit::TestCase
   def test_to_indexes
     assert_to_indexes({"abc def" => [0, 2], "abc" => [1]},
                       ["abc def", "abc", "abc def"])
+
+    assert_to_indexes({?a => [0, 3], ?b => [1], ?c => [2], ?d => [4]},
+                      "abcad")
   end
 
   def test_longest_match
@@ -19,46 +20,221 @@ class TestDiff < Test::Unit::TestCase
     assert_longest_match([1, 0, 2],
                          %w(q a b x c d), %w(a b y c d f),
                          0, 5, 0, 5)
+    assert_longest_match([4, 3, 2],
+                         %w(q a b x c d), %w(a b y c d f),
+                         3, 5, 2, 5)
+
+    assert_longest_match([1, 0, 2], "qabxcd", "abycdf", 0, 5, 0, 5)
+    assert_longest_match([0, 0, 1], "efg", "eg", 0, 2, 0, 1)
+    assert_longest_match([2, 1, 1], "efg", "eg", 1, 2, 1, 1)
   end
 
-  def _test_matching_blocks
-    assert_matching_blocks([[0, 0, 2],
-                            [3, 2, 2],
-                            [5, 4, 0]],
-                           %w(a b x c d), %w(a b c d))
-    assert_matching_blocks([[1, 0, 2],
-                            [4, 3, 2],
-                            [6, 6, 0]],
-                           %w(q a b x c d), %q(a b y c d f))
+  def test_longest_match_with_junk_filter
+    assert_longest_match([0, 4, 5], " abcd", "abcd abcd", 0, 4, 0, 8)
+    assert_longest_match([1, 0, 4], " abcd", "abcd abcd", 0, 4, 0, 8) do |x|
+      x == ' '[0]
+    end
+  end
+
+  def test_blocks
+    assert_blocks([[0, 0, 2],
+                   [3, 2, 2],
+                   [5, 4, 0]],
+                  %w(a b x c d), %w(a b c d))
+    assert_blocks([[1, 0, 2],
+                   [4, 3, 2],
+                   [6, 6, 0]],
+                  %w(q a b x c d), %w(a b y c d f))
+
+    assert_blocks([[1, 0, 2],
+                   [4, 3, 2],
+                   [6, 6, 0]],
+                  "qabxcd", "abycdf")
+    assert_blocks([[0, 0, 1],
+                   [2, 1, 1],
+                   [3, 2, 0]],
+                  "efg", "eg")
   end
 
   def test_operations
+    assert_operations([], %w(), %w())
+
     assert_operations([[:delete, 0, 1, 0, 0],
                        [:equal, 1, 3, 0, 2],
                        [:replace, 3, 4, 2, 3],
                        [:equal, 4, 6, 3, 5],
                        [:insert, 6, 6, 5, 6]],
                       %w(q a b x c d), %w(a b y c d f))
+
+    assert_operations([[:delete, 0, 1, 0, 0],
+                       [:equal, 1, 3, 0, 2],
+                       [:replace, 3, 4, 2, 3],
+                       [:equal, 4, 6, 3, 5],
+                       [:insert, 6, 6, 5, 6]],
+                      "qabxcd", "abycdf")
+  end
+
+  def test_grouped_operations
+    assert_grouped_operations([[[:equal, 0, 0, 0, 0]]],
+                              %w(),
+                              %w())
+
+    assert_grouped_operations([[[:equal, 0, 3, 0, 3]]],
+                              %w(a b c),
+                              %w(a b c))
+
+    assert_grouped_operations([[[:equal, 0, 1, 0, 1],
+                                [:replace, 1, 2, 1, 2],
+                                [:equal, 2, 5, 2, 5]],
+                               [[:equal, 8, 11, 8, 11],
+                                [:replace, 11, 12, 11, 12],
+                                [:equal, 12, 13, 12, 13],
+                                [:delete, 13, 16, 13, 13],
+                                [:equal, 16, 17, 13, 14],
+                                [:replace, 17, 18, 14, 15],
+                                [:equal, 18, 20, 15, 17]]],
+                              %w(1 2 3 4 5 6 7 8 9 a b c d e f g h i j k),
+                              %w(1 i 3 4 5 6 7 8 9 a b cX d h iX j k))
+  end
+
+  def test_ratio
+    assert_ratio(0.75, "abcd", "bcde")
+    assert_ratio(0.80, "efg", "eg")
+  end
+
+  def test_same_contents_readable_diff
+    assert_readable_diff("  aaa", ["aaa"], ["aaa"])
+    assert_readable_diff("  aaa\n" \
+                         "  bbb",
+                         ["aaa", "bbb"], ["aaa", "bbb"])
+  end
+
+  def test_deleted_readable_diff
+    assert_readable_diff("  aaa\n" \
+                         "- bbb",
+                         ["aaa", "bbb"], ["aaa"])
+    assert_readable_diff("  aaa\n" \
+                         "- bbb\n" \
+                         "- ccc\n" \
+                         "- ddd",
+                         ["aaa", "bbb", "ccc", "ddd"], ["aaa"])
+  end
+
+  def test_inserted_readable_diff
+    assert_readable_diff("  aaa\n" \
+                         "+ bbb\n" \
+                         "+ ccc\n" \
+                         "+ ddd",
+                         ["aaa"], ["aaa", "bbb", "ccc", "ddd"])
+  end
+
+  def test_replace_readable_diff
+    assert_readable_diff("  aaa\n" \
+                         "- bbb\n" \
+                         "+ BbB\n" \
+                         "  ccc\n" \
+                         "- ddd\n" \
+                         "- efg\n" \
+                         "?  -\n" \
+                         "+ eg",
+                         ["aaa", "bbb", "ccc", "ddd", "efg"],
+                         ["aaa", "BbB", "ccc", "eg"])
+
+    assert_readable_diff("-  abcd xyz abc\n" \
+                         "? -\n" \
+                         "+ abcd abcd xyz abc\n" \
+                         "?      +++++",
+                         [" abcd xyz abc"],
+                         ["abcd abcd xyz abc"])
+  end
+
+  def test_complex_readable_diff
+    assert_readable_diff("  aaa\n" \
+                         "- bbb\n" \
+                         "- ccc\n" \
+                         "+ \n" \
+                         "+   # \n" \
+                         "  ddd",
+                         ["aaa", "bbb", "ccc", "ddd"],
+                         ["aaa", "", "  # ", "ddd"])
+
+    assert_readable_diff("- one1\n" \
+                         "?  ^\n" \
+                         "+ ore1\n" \
+                         "?  ^\n" \
+                         "- two2\n" \
+                         "- three3\n" \
+                         "?  -   -\n" \
+                         "+ tree\n" \
+                         "+ emu",
+                         ["one1", "two2", "three3"],
+                         ["ore1", "tree", "emu"])
+  end
+
+  def test_unified_diff
+    assert_unified_diff("",
+                        ["one", "two", "three"],
+                        ["one", "two", "three"],
+                        "content 1",
+                        "content 2")
+
+    assert_unified_diff("--- Original Sat Jan 26 23:30:50 1991\n" \
+                        "+++ Current Fri Jun 06 10:20:52 2003\n" \
+                        "@@ -1,4 +1,4 @@\n" \
+                        "+zero\n" \
+                        " one\n" \
+                        "-two\n" \
+                        "-three\n" \
+                        "+tree\n" \
+                        " four",
+                        ["one", "two", "three", "four"],
+                        ["zero", "one", "tree", "four"],
+                        "Original Sat Jan 26 23:30:50 1991",
+                        "Current Fri Jun 06 10:20:52 2003",
+                        :show_context => false)
+
+    from = File.read(__FILE__).split(/\n/)
+    to = from.dup
+    target_line = __LINE__
+    to[target_line - 1, 1] = []
+    context = "  def test_unified_diff"
+    summary = "@@ -#{target_line - 3},7 +#{target_line - 3},6 @@ #{context}"
+    assert_unified_diff((["--- revision 10",
+                          "+++ revision 11",
+                          summary] +
+                         from[target_line - 4, 3].collect {|line| " #{line}"} +
+                         ["-#{from[target_line - 1]}"] +
+                         from[target_line, 3].collect {|line| " #{line}"}
+                         ).join("\n"),
+                        from, to,
+                        "revision 10",
+                        "revision 11")
   end
 
-  def test_same_contents
-    assert_ndiff("  aaa", ["aaa"], ["aaa"])
-    assert_ndiff("  aaa\n" \
-                 "  bbb",
-                 ["aaa", "bbb"], ["aaa", "bbb"])
+  def test_diff_lines
+    assert_diff_lines(["- ddd",
+                       "- efg",
+                       "?  -",
+                       "+ eg"],
+                      ["aaa", "bbb", "ccc", "ddd", "efg"],
+                      ["aaa", "BbB", "ccc", "eg"],
+                      3, 5, 3, 4)
   end
 
-  def test_deleted
-    assert_ndiff("  aaa\n" \
-                 "  bbb\n" \
-                 "- bbb",
-                 ["aaa", "bbb"], ["aaa"])
-    assert_ndiff("  aaa\n" \
-                 "  bbb\n" \
-                 "- bbb\n" \
-                 "- ccc\n" \
-                 "- ddd",
-                 ["aaa", "bbb", "ccc", "ddd"], ["aaa"])
+  def test_diff_line
+    assert_diff_line(["- abcDefghiJkl",
+                      "?    ^  ^  ^",
+                      "+ abcdefGhijkl",
+                      "?    ^  ^  ^"],
+                     "abcDefghiJkl",
+                     "abcdefGhijkl")
+
+    assert_diff_line(["- bcDefghiJklx",
+                      "?   ^  ^  ^  -",
+                      "+ abcdefGhijkl",
+                      "? +  ^  ^  ^"],
+                     "bcDefghiJklx",
+                     "abcdefGhijkl")
   end
 
   def test_format_diff_point
@@ -70,6 +246,33 @@ class TestDiff < Test::Unit::TestCase
                              "\t\tabcdefGhijkl",
                              "  ^ ^  ^      ",
                              "+  ^ ^  ^      ")
+    assert_format_diff_point(["- efg",
+                              "?  ^",
+                              "+ eg"],
+                             "efg",
+                             "eg",
+                             " ^",
+                             "")
+  end
+
+  def test_interesting_line
+    from = ["class X",
+            "  def find(x=0)",
+            "    body",
+            "  end",
+            "end"]
+    to = ["def xxx",
+          "  raise 'not call me'",
+          "end"]
+    assert_interesting_line("  def find(x=0)",
+                            from, to,
+                            2, 1)
+    assert_interesting_line("def xxx",
+                            from, to,
+                            2, 0)
+    assert_interesting_line("class X",
+                            from, to,
+                            0, 0)
   end
 
   private
@@ -80,15 +283,15 @@ class TestDiff < Test::Unit::TestCase
 
   def assert_longest_match(expected, from, to,
                            from_start, from_end,
-                           to_start, to_end)
-    matcher = Test::Diff::SequenceMatcher.new(from, to)
+                           to_start, to_end, &junk_predicate)
+    matcher = Test::Diff::SequenceMatcher.new(from, to, &junk_predicate)
     assert_equal(expected, matcher.longest_match(from_start, from_end,
                                                  to_start, to_end))
   end
 
-  def assert_matching_blocks(expected, from, to)
+  def assert_blocks(expected, from, to)
     matcher = Test::Diff::SequenceMatcher.new(from, to)
-    assert_equal(expected, matcher.matching_blocks)
+    assert_equal(expected, matcher.blocks)
   end
 
   def assert_operations(expected, from, to)
@@ -96,14 +299,52 @@ class TestDiff < Test::Unit::TestCase
     assert_equal(expected, matcher.operations)
   end
 
-  def assert_ndiff(expected, from, to)
-    assert_equal(expected, Test::Diff.ndiff(from, to))
+  def assert_grouped_operations(expected, from, to)
+    matcher = Test::Diff::SequenceMatcher.new(from, to)
+    assert_equal(expected, matcher.grouped_operations)
+  end
+
+  def assert_ratio(expected, from, to)
+    matcher = Test::Diff::SequenceMatcher.new(from, to)
+    assert_in_delta(expected, 0.001, matcher.ratio)
+  end
+
+  def assert_readable_diff(expected, from, to)
+    assert_equal(expected, Test::Diff.readable(from.join("\n"), to.join("\n")))
+  end
+
+  def assert_unified_diff(expected, from, to, from_label, to_label, options={})
+    options = options.merge(:from_label => from_label,
+                            :to_label => to_label)
+    assert_equal(expected, Test::Diff.unified(from.join("\n"), to.join("\n"),
+                                              options))
+  end
+
+  def assert_diff_lines(expected, from, to,
+                        from_start, from_end,
+                        to_start, to_end)
+    differ = Test::Diff::ReadableDiffer.new(from, to)
+    assert_equal(expected, differ.send(:diff_lines,
+                                       from_start, from_end,
+                                       to_start, to_end))
+  end
+
+  def assert_diff_line(expected, from_line, to_line)
+    differ = Test::Diff::ReadableDiffer.new([""], [""])
+    assert_equal(expected, differ.send(:diff_line, from_line, to_line))
   end
 
   def assert_format_diff_point(expected, from_line, to_line, from_tags, to_tags)
-    differ = Test::Diff::Differ.new([""], [""])
+    differ = Test::Diff::ReadableDiffer.new([""], [""])
     assert_equal(expected, differ.send(:format_diff_point,
                                        from_line, to_line,
                                        from_tags, to_tags))
   end
+
+  def assert_interesting_line(expected, from, to, from_start, to_start)
+    differ = Test::Diff::UnifiedDiffer.new(from, to)
+    assert_equal(expected, differ.send(:find_interesting_line,
+                                       from_start, to_start,
+                                       :define_line?))
+  end
 end