test-unit 2.0.3 → 2.0.4

data/History.txt

@@ -1,3 +1,25 @@
+=== 2.0.4 / 2009-10-17
+
+* 4 major enhancements
+  * use ~/.test-unit.yml as global configuration file.
+  * add TAP runner. (--runner tap)
+  * support colorized diff:
+    http://test-unit.rubyforge.org/svn/trunk/images/color-diff.png
+  * add Test::Unit::AutoRunner.default_runner= to specify default test runner.
+
+* 4 minor enchancements
+  * improve verbose mode output format. (use indent)
+  * support NOT_PASS_THROUGH_EXCEPTIONS.
+  * support arguments option in #{runner}_options.
+  * TC_ -> Test in sample test case name.
+
+* 1 bug fixes
+  * [#27195] test-unit-2.0.3 + ruby-1.9.1 cannot properly test
+    DelegateClass subclasses [Mike Pomraning]
+
+* Thanks
+  * Mike Pomraning
+
 === 2.0.3 / 2009-07-19
 
 * 6 major enhancements

data/Manifest.txt

@@ -8,6 +8,7 @@ html/classic.html
 html/index.html
 html/index.html.ja
 html/test-unit-classic.png
+images/color-diff.png
 lib/test/unit.rb
 lib/test/unit/assertionfailederror.rb
 lib/test/unit/assertions.rb
@@ -31,12 +32,14 @@ lib/test/unit/pending.rb
 lib/test/unit/priority.rb
 lib/test/unit/runner/console.rb
 lib/test/unit/runner/emacs.rb
+lib/test/unit/runner/tap.rb
 lib/test/unit/testcase.rb
 lib/test/unit/testresult.rb
 lib/test/unit/testsuite.rb
 lib/test/unit/ui/console/outputlevel.rb
 lib/test/unit/ui/console/testrunner.rb
 lib/test/unit/ui/emacs/testrunner.rb
+lib/test/unit/ui/tap/testrunner.rb
 lib/test/unit/ui/testrunner.rb
 lib/test/unit/ui/testrunnermediator.rb
 lib/test/unit/ui/testrunnerutilities.rb
@@ -47,10 +50,9 @@ lib/test/unit/util/procwrapper.rb
 lib/test/unit/version.rb
 sample/adder.rb
 sample/subtracter.rb
-sample/tc_adder.rb
-sample/tc_subtracter.rb
+sample/test_adder.rb
+sample/test_subtracter.rb
 sample/test_user.rb
-sample/ts_examples.rb
 test/collector/test-descendant.rb
 test/collector/test-load.rb
 test/collector/test_dir.rb

data/README.txt

@@ -7,7 +7,7 @@
 Test::Unit 2.x - Improved version of Test::Unit bundled in
 Ruby 1.8.x.
 
-Ruby 1.9.x bundles miniunit not Test::Unit. Test::Unit
+Ruby 1.9.x bundles minitest not Test::Unit. Test::Unit
 bundled in Ruby 1.8.x had not been improved but unbundled
 Test::Unit (Test::Unit 2.x) will be improved actively.
 
@@ -50,3 +50,4 @@ This software is distributed under the same terms as ruby.
 * Bill Lear: A suggestion.
 * Diego Pettenò: A bug report.
 * Angelo Lakra: A bug report.
+* Mike Pomraning: A bug report.

data/lib/test/unit.rb

@@ -179,7 +179,7 @@ module Test # :nodoc:
   #
   #     require 'test/unit'
   #     
-  #     class TC_MyTest < Test::Unit::TestCase
+  #     class MyTest < Test::Unit::TestCase
   #       # def setup
   #       # end
   #     
@@ -194,21 +194,17 @@ module Test # :nodoc:
   #
   # == Test Runners
   #
-  # So, now you have this great test class, but you still need a way to
-  # run it and view any failures that occur during the run. This is
-  # where Test::Unit::UI::Console::TestRunner (and others, such as
-  # Test::Unit::UI::GTK::TestRunner) comes into play. The console test
-  # runner is automatically invoked for you if you require 'test/unit'
-  # and simply run the file. To use another runner, or to manually
-  # invoke a runner, simply call its run class method and pass in an
-  # object that responds to the suite message with a
-  # Test::Unit::TestSuite. This can be as simple as passing in your
-  # TestCase class (which has a class suite method). It might look
-  # something like this:
-  #
-  #    require 'test/unit/ui/console/testrunner'
-  #    Test::Unit::UI::Console::TestRunner.run(TC_MyTest)
+  # So, now you have this great test class, but you still
+  # need a way to run it and view any failures that occur
+  # during the run. There are some test runner; console test
+  # runner, GTK+ test runner and so on. The console test
+  # runner is automatically invoked for you if you require
+  # 'test/unit' and simply run the file. To use another
+  # runner simply set default test runner ID to
+  # Test::Unit::AutoRunner:
   #
+  #    require 'test/unit'
+  #    Test::Unit::AutoRunner.default_runner = "gtk2"
   #
   # == Test Suite
   #
@@ -220,33 +216,17 @@ module Test # :nodoc:
   # in response to a suite method. The TestSuite can, in turn, contain
   # other TestSuites or individual tests (typically created by a
   # TestCase). In other words, you can easily wrap up a group of
-  # TestCases and TestSuites like this:
-  #
-  #  require 'test/unit/testsuite'
-  #  require 'tc_myfirsttests'
-  #  require 'tc_moretestsbyme'
-  #  require 'ts_anothersetoftests'
-  #
-  #  class TS_MyTests
-  #    def self.suite
-  #      suite = Test::Unit::TestSuite.new
-  #      suite << TC_MyFirstTests.suite
-  #      suite << TC_MoreTestsByMe.suite
-  #      suite << TS_AnotherSetOfTests.suite
-  #      return suite
-  #    end
-  #  end
-  #  Test::Unit::UI::Console::TestRunner.run(TS_MyTests)
-  #
-  # Now, this is a bit cumbersome, so Test::Unit does a little bit more
-  # for you, by wrapping these up automatically when you require
-  # 'test/unit'. What does this mean? It means you could write the above
-  # test case like this instead:
+  # TestCases and TestSuites.
+  #
+  # Test::Unit does a little bit more for you, by wrapping
+  # these up automatically when you require
+  # 'test/unit'. What does this mean? It means you could
+  # write the above test case like this instead:
   #
   #  require 'test/unit'
-  #  require 'tc_myfirsttests'
-  #  require 'tc_moretestsbyme'
-  #  require 'ts_anothersetoftests'
+  #  require 'test_myfirsttests'
+  #  require 'test_moretestsbyme'
+  #  require 'test_anothersetoftests'
   #
   # Test::Unit is smart enough to find all the test cases existing in
   # the ObjectSpace and wrap them up into a suite for you. It then runs

data/lib/test/unit/assertionfailederror.rb

@@ -9,6 +9,17 @@ module Test
 
     # Thrown by Test::Unit::Assertions when an assertion fails.
     class AssertionFailedError < StandardError
+      attr_accessor :expected, :actual, :user_message
+      attr_accessor :inspected_expected, :inspected_actual
+      def initialize(message=nil, options=nil)
+        options ||= {}
+        @expected = options[:expected]
+        @actual = options[:actual]
+        @inspected_expected = options[:inspected_expected]
+        @inspected_actual = options[:inspected_actual]
+        @user_message = options[:user_message]
+        super(message)
+      end
     end
   end
 end

data/lib/test/unit/assertions.rb

@@ -84,7 +84,16 @@ module Test
 <?> expected but was
 <?>.?
 EOT
-        assert_block(full_message) { expected == actual }
+        begin
+          assert_block(full_message) { expected == actual }
+        rescue AssertionFailedError => failure
+          failure.expected = expected
+          failure.actual = actual
+          failure.inspected_expected = AssertionMessage.convert(expected)
+          failure.inspected_actual = AssertionMessage.convert(actual)
+          failure.user_message = message
+          raise
+        end
       end
 
       ##
@@ -880,7 +889,7 @@ EOT
             MaybeContainer.new(value, &formatter)
           end
 
-          MAX_DIFF_TARGET_STRING_SIZE = 300
+          MAX_DIFF_TARGET_STRING_SIZE = 1000
           def diff_target_string?(string)
             if string.respond_to?(:bytesize)
               string.bytesize < MAX_DIFF_TARGET_STRING_SIZE
@@ -889,15 +898,24 @@ EOT
             end
           end
 
+          def prepare_for_diff(from, to)
+            if !from.is_a?(String) or !to.is_a?(String)
+              from = convert(from)
+              to = convert(to)
+            end
+
+            if diff_target_string?(from) and diff_target_string?(to)
+              [from, to]
+            else
+              [nil, nil]
+            end
+          end
+
           def delayed_diff(from, to)
             delayed_literal do
-              if !from.is_a?(String) or !to.is_a?(String)
-                from = convert(from)
-                to = convert(to)
-              end
+              from, to = prepare_for_diff(from, to)
 
-              diff = nil
-              diff = "" if !diff_target_string?(from) or !diff_target_string?(to)
+              diff = "" if from.nil? or to.nil?
               diff ||= Diff.readable(from, to)
               if /^[-+]/ !~ diff
                 diff = ""
@@ -930,7 +948,10 @@ EOM
               if use_pp
                 begin
                   require 'pp' unless defined?(PP)
-                  return PP.pp(object, '').chomp
+                  begin
+                    return PP.pp(object, '').chomp
+                  rescue NameError
+                  end
                 rescue LoadError
                   self.use_pp = false
                 end

data/lib/test/unit/autorunner.rb

@@ -18,6 +18,15 @@ module Test
           RUNNERS[id.to_s]
         end
 
+        @@default_runner = nil
+        def default_runner
+          runner(@@default_runner)
+        end
+
+        def default_runner=(id)
+          @@default_runner = id
+        end
+
         def register_collector(id, collector_builder=Proc.new)
           COLLECTORS[id] = collector_builder
           COLLECTORS[id.to_s] = collector_builder
@@ -102,15 +111,23 @@ module Test
         @to_run = []
         @color_scheme = ColorScheme.default
         @runner_options = {}
+        @default_arguments = []
         @workdir = nil
-        default_config_file = "test-unit.yml"
-        load_config(default_config_file) if File.exist?(default_config_file)
+        config_file = "test-unit.yml"
+        if File.exist?(config_file)
+          load_config(config_file)
+        else
+          global_config_file = File.expand_path("~/.test-unit.xml")
+          load_config(global_config_file) if File.exist?(global_config_file)
+        end
         yield(self) if block_given?
       end
 
       def process_args(args = ARGV)
+        default_arguments = @default_arguments.dup
         begin
-          options.order!(args) {|arg| @to_run << arg}
+          @default_arguments.concat(args)
+          options.order!(@default_arguments) {|arg| @to_run << arg}
         rescue OptionParser::ParseError => e
           puts e
           puts options
@@ -119,6 +136,8 @@ module Test
           @filters << proc{false} unless(@filters.empty?)
         end
         not @to_run.empty?
+      ensure
+        @default_arguments = default_arguments
       end
 
       def options
@@ -304,18 +323,24 @@ module Test
         (config["#{runner_name}_options"] || {}).each do |key, value|
           key = key.to_sym
           value = ColorScheme[value] if key == :color_scheme
-          runner_options[key.to_sym] = value
+          if key == :arguments
+            @default_arguments.concat(value.split)
+          else
+            runner_options[key.to_sym] = value
+          end
         end
         @runner_options = @runner_options.merge(runner_options)
       end
 
       private
       def default_runner
+        runner = self.class.default_runner
         if ENV["EMACS"] == "t"
-          self.class.runner(:emacs)
+          runner ||= self.class.runner(:emacs)
         else
-          self.class.runner(:console)
+          runner ||= self.class.runner(:console)
         end
+        runner
       end
 
       def default_collector
@@ -327,3 +352,4 @@ end
 
 require 'test/unit/runner/console'
 require 'test/unit/runner/emacs'
+require 'test/unit/runner/tap'

data/lib/test/unit/collector/load.rb

@@ -76,7 +76,9 @@ module Test
               sub_test_suites << sub_test_suite unless sub_test_suite.empty?
             end
           else
-            collect_file(path, sub_test_suites, already_gathered)
+            unless excluded_file?(path.basename.to_s)
+              collect_file(path, sub_test_suites, already_gathered)
+            end
           end
 
           test_suite = TestSuite.new(path.basename.to_s)

data/lib/test/unit/color-scheme.rb

@@ -14,7 +14,23 @@ module Test
                             "omission" => Color.new("blue", :bold => true),
                             "notification" => Color.new("cyan", :bold => true),
                             "error" => Color.new("yellow", :bold => true) +
-                                       Color.new("black", :foreground => false))
+                                       Color.new("black", :foreground => false),
+                            "case" => Color.new("white", :bold => true) +
+                                       Color.new("blue", :foreground => false),
+                            "suite" => Color.new("white", :bold => true) +
+                                       Color.new("green", :foreground => false),
+                            "diff-inserted-tag" =>
+                               Color.new("red", :bold => true),
+                            "diff-deleted-tag" =>
+                               Color.new("green", :bold => true),
+                            "diff-difference-tag" =>
+                               Color.new("cyan", :bold => true),
+                            "diff-inserted" =>
+                               Color.new("red", :foreground => false) +
+                               Color.new("white", :bold => true),
+                            "diff-deleted" =>
+                               Color.new("green", :foreground => false) +
+                               Color.new("white", :bold => true))
         end
 
         @@schemes = {}

data/lib/test/unit/diff.rb

@@ -35,7 +35,7 @@ module Test
 
         def grouped_operations(context_size=nil)
           context_size ||= 3
-          _operations = operations
+          _operations = operations.dup
           _operations = [[:equal, 0, 0, 0, 0]] if _operations.empty?
           expand_edge_equal_operations!(_operations, context_size)
 
@@ -266,29 +266,187 @@ module Test
         end
       end
 
+      class UTF8Line
+        class << self
+          # from http://unicode.org/reports/tr11/
+          WIDE_CHARACTERS =
+            [0x1100..0x1159, 0x115F..0x115F, 0x2329..0x232A,
+             0x2E80..0x2E99, 0x2E9B..0x2EF3, 0x2F00..0x2FD5,
+             0x2FF0..0x2FFB, 0x3000..0x303E, 0x3041..0x3096,
+             0x3099..0x30FF, 0x3105..0x312D, 0x3131..0x318E,
+             0x3190..0x31B7, 0x31C0..0x31E3, 0x31F0..0x321E,
+             0x3220..0x3243, 0x3250..0x32FE, 0x3300..0x4DB5,
+             0x4E00..0x9FC3, 0xA000..0xA48C, 0xA490..0xA4C6,
+             0xAC00..0xD7A3, 0xF900..0xFA2D, 0xFA30..0xFA6A,
+             0xFA70..0xFAD9, 0xFE10..0xFE19, 0xFE30..0xFE52,
+             0xFE54..0xFE66, 0xFE68..0xFE6B, 0xFF01..0xFF60,
+             0xFFE0..0xFFE6, 0x20000..0x2FFFD, 0x30000..0x3FFFD,
+            ]
+
+          AMBIGUOUS =
+            [0x00A1..0x00A1, 0x00A4..0x00A4, 0x00A7..0x00A8,
+             0x00AA..0x00AA, 0x00AD..0x00AE, 0x00B0..0x00B4,
+             0x00B6..0x00BA, 0x00BC..0x00BF, 0x00C6..0x00C6,
+             0x00D0..0x00D0, 0x00D7..0x00D8, 0x00DE..0x00E1,
+             0x00E6..0x00E6, 0x00E8..0x00EA, 0x00EC..0x00ED,
+             0x00F0..0x00F0, 0x00F2..0x00F3, 0x00F7..0x00FA,
+             0x00FC..0x00FC, 0x00FE..0x00FE, 0x0101..0x0101,
+             0x0111..0x0111, 0x0113..0x0113, 0x011B..0x011B,
+             0x0126..0x0127, 0x012B..0x012B, 0x0131..0x0133,
+             0x0138..0x0138, 0x013F..0x0142, 0x0144..0x0144,
+             0x0148..0x014B, 0x014D..0x014D, 0x0152..0x0153,
+             0x0166..0x0167, 0x016B..0x016B, 0x01CE..0x01CE,
+             0x01D0..0x01D0, 0x01D2..0x01D2, 0x01D4..0x01D4,
+             0x01D6..0x01D6, 0x01D8..0x01D8, 0x01DA..0x01DA,
+             0x01DC..0x01DC, 0x0251..0x0251, 0x0261..0x0261,
+             0x02C4..0x02C4, 0x02C7..0x02C7, 0x02C9..0x02CB,
+             0x02CD..0x02CD, 0x02D0..0x02D0, 0x02D8..0x02DB,
+             0x02DD..0x02DD, 0x02DF..0x02DF, 0x0300..0x036F,
+             0x0391..0x03A1, 0x03A3..0x03A9, 0x03B1..0x03C1,
+             0x03C3..0x03C9, 0x0401..0x0401, 0x0410..0x044F,
+             0x0451..0x0451, 0x2010..0x2010, 0x2013..0x2016,
+             0x2018..0x2019, 0x201C..0x201D, 0x2020..0x2022,
+             0x2024..0x2027, 0x2030..0x2030, 0x2032..0x2033,
+             0x2035..0x2035, 0x203B..0x203B, 0x203E..0x203E,
+             0x2074..0x2074, 0x207F..0x207F, 0x2081..0x2084,
+             0x20AC..0x20AC, 0x2103..0x2103, 0x2105..0x2105,
+             0x2109..0x2109, 0x2113..0x2113, 0x2116..0x2116,
+             0x2121..0x2122, 0x2126..0x2126, 0x212B..0x212B,
+             0x2153..0x2154, 0x215B..0x215E, 0x2160..0x216B,
+             0x2170..0x2179, 0x2190..0x2199, 0x21B8..0x21B9,
+             0x21D2..0x21D2, 0x21D4..0x21D4, 0x21E7..0x21E7,
+             0x2200..0x2200, 0x2202..0x2203, 0x2207..0x2208,
+             0x220B..0x220B, 0x220F..0x220F, 0x2211..0x2211,
+             0x2215..0x2215, 0x221A..0x221A, 0x221D..0x2220,
+             0x2223..0x2223, 0x2225..0x2225, 0x2227..0x222C,
+             0x222E..0x222E, 0x2234..0x2237, 0x223C..0x223D,
+             0x2248..0x2248, 0x224C..0x224C, 0x2252..0x2252,
+             0x2260..0x2261, 0x2264..0x2267, 0x226A..0x226B,
+             0x226E..0x226F, 0x2282..0x2283, 0x2286..0x2287,
+             0x2295..0x2295, 0x2299..0x2299, 0x22A5..0x22A5,
+             0x22BF..0x22BF, 0x2312..0x2312, 0x2460..0x24E9,
+             0x24EB..0x254B, 0x2550..0x2573, 0x2580..0x258F,
+             0x2592..0x2595, 0x25A0..0x25A1, 0x25A3..0x25A9,
+             0x25B2..0x25B3, 0x25B6..0x25B7, 0x25BC..0x25BD,
+             0x25C0..0x25C1, 0x25C6..0x25C8, 0x25CB..0x25CB,
+             0x25CE..0x25D1, 0x25E2..0x25E5, 0x25EF..0x25EF,
+             0x2605..0x2606, 0x2609..0x2609, 0x260E..0x260F,
+             0x2614..0x2615, 0x261C..0x261C, 0x261E..0x261E,
+             0x2640..0x2640, 0x2642..0x2642, 0x2660..0x2661,
+             0x2663..0x2665, 0x2667..0x266A, 0x266C..0x266D,
+             0x266F..0x266F, 0x273D..0x273D, 0x2776..0x277F,
+             0xE000..0xF8FF, 0xFE00..0xFE0F, 0xFFFD..0xFFFD,
+             0xE0100..0xE01EF, 0xF0000..0xFFFFD, 0x100000..0x10FFFD,
+            ]
+
+          def wide_character?(character)
+            binary_search_ranges(character, WIDE_CHARACTERS) or
+              binary_search_ranges(character, AMBIGUOUS)
+          end
+
+          private
+          def binary_search_ranges(character, ranges)
+            if ranges.size.zero?
+              false
+            elsif ranges.size == 1
+              ranges[0].include?(character)
+            else
+              half = ranges.size / 2
+              range = ranges[half]
+              if range.include?(character)
+                true
+              elsif character < range.begin
+                binary_search_ranges(character, ranges[0...half])
+              else
+                binary_search_ranges(character, ranges[(half + 1)..-1])
+              end
+            end
+          end
+        end
+
+        def initialize(line)
+          @line = line
+          @characters = @line.unpack("U*")
+        end
+
+        def [](*args)
+          result = @characters[*args]
+          if result.respond_to?(:pack)
+            result.pack("U*")
+          else
+            result
+          end
+        end
+
+        def each(&block)
+          @characters.each(&block)
+        end
+
+        def size
+          @characters.size
+        end
+
+        def to_s
+          @line
+        end
+
+        def compute_width(start, _end)
+          width = 0
+          start.upto(_end - 1) do |i|
+            if self.class.wide_character?(@characters[i])
+              width += 2
+            else
+              width += 1
+            end
+          end
+          width
+        end
+      end
+
       class ReadableDiffer < Differ
         def diff(options={})
-          result = []
-          matcher = SequenceMatcher.new(@from, @to)
-          matcher.operations.each do |args|
-            tag, from_start, from_end, to_start, to_end = args
+          @result = []
+          operations.each do |tag, from_start, from_end, to_start, to_end|
             case tag
             when :replace
-              result.concat(diff_lines(from_start, from_end, to_start, to_end))
+              diff_lines(from_start, from_end, to_start, to_end)
             when :delete
-              result.concat(tag_deleted(@from[from_start...from_end]))
+              tag_deleted(@from[from_start...from_end])
             when :insert
-              result.concat(tag_inserted(@to[to_start...to_end]))
+              tag_inserted(@to[to_start...to_end])
             when :equal
-              result.concat(tag_equal(@from[from_start...from_end]))
+              tag_equal(@from[from_start...from_end])
             else
               raise "unknown tag: #{tag}"
             end
           end
-          result
+          @result
         end
 
         private
+        def operations
+          @operations ||= nil
+          if @operations.nil?
+            matcher = SequenceMatcher.new(@from, @to)
+            @operations = matcher.operations
+          end
+          @operations
+        end
+
+        def default_ratio
+          0.74
+        end
+
+        def cut_off_ratio
+          0.75
+        end
+
+        def tag(mark, contents)
+          contents.each do |content|
+            @result << "#{mark}#{content}"
+          end
+        end
+
         def tag_deleted(contents)
           tag("- ", contents)
         end
@@ -306,7 +464,7 @@ module Test
         end
 
         def find_diff_line_info(from_start, from_end, to_start, to_end)
-          best_ratio = 0.74
+          best_ratio = default_ratio
           from_equal_index = to_equal_index = nil
           from_best_index = to_best_index = nil
 
@@ -334,30 +492,29 @@ module Test
         end
 
         def diff_lines(from_start, from_end, to_start, to_end)
-          cut_off = 0.75
-
           info = find_diff_line_info(from_start, from_end, to_start, to_end)
           best_ratio, from_equal_index, to_equal_index, *info = info
           from_best_index, to_best_index = info
 
-          if best_ratio < cut_off
+          if best_ratio < cut_off_ratio
             if from_equal_index.nil?
-              tagged_from = tag_deleted(@from[from_start...from_end])
-              tagged_to = tag_inserted(@to[to_start...to_end])
               if to_end - to_start < from_end - from_start
-                return tagged_to + tagged_from
+                tag_inserted(@to[to_start...to_end])
+                tag_deleted(@from[from_start...from_end])
               else
-                return tagged_from + tagged_to
+                tag_deleted(@from[from_start...from_end])
+                tag_inserted(@to[to_start...to_end])
               end
+              return
             end
             from_best_index = from_equal_index
             to_best_index = to_equal_index
             best_ratio = 1.0
           end
 
-          _diff_lines(from_start, from_best_index, to_start, to_best_index) +
-            diff_line(@from[from_best_index], @to[to_best_index]) +
-            _diff_lines(from_best_index + 1, from_end, to_best_index + 1, to_end)
+          _diff_lines(from_start, from_best_index, to_start, to_best_index)
+          diff_line(@from[from_best_index], @to[to_best_index])
+          _diff_lines(from_best_index + 1, from_end, to_best_index + 1, to_end)
         end
 
         def _diff_lines(from_start, from_end, to_start, to_end)
@@ -372,26 +529,54 @@ module Test
           end
         end
 
+        def line_operations(from_line, to_line)
+          if !from_line.respond_to?(:force_encoding) and $KCODE == "UTF8"
+            from_line = UTF8Line.new(from_line)
+            to_line = UTF8Line.new(to_line)
+          end
+          matcher = SequenceMatcher.new(from_line, to_line,
+                                        &method(:space_character?))
+          [from_line, to_line, matcher.operations]
+        end
+
+        def compute_width(line, start, _end)
+          if line.respond_to?(:encoding) and
+              Encoding.compatible?(Encoding::UTF_8, line.encoding)
+            utf8_line = line[start..._end].encode(Encoding::UTF_8)
+            width = 0
+            utf8_line.each_codepoint do |unicode_codepoint|
+              if UTF8Line.wide_character?(unicode_codepoint)
+                width += 2
+              else
+                width += 1
+              end
+            end
+            width
+          elsif line.is_a?(UTF8Line)
+            line.compute_width(start, _end)
+          else
+            _end - start
+          end
+        end
+
         def diff_line(from_line, to_line)
           from_tags = ""
           to_tags = ""
-          matcher = SequenceMatcher.new(from_line, to_line,
-                                        &method(:space_character?))
-          operations = matcher.operations
-          operations.each do |tag, from_start, from_end, to_start, to_end|
-            from_length = from_end - from_start
-            to_length = to_end - to_start
+          from_line, to_line, _operations = line_operations(from_line, to_line)
+          _operations.each do |tag, from_start, from_end, to_start, to_end|
+            from_width = compute_width(from_line, from_start, from_end)
+            to_width = compute_width(to_line, to_start, to_end)
             case tag
             when :replace
-              from_tags << "^" * from_length
-              to_tags << "^" * to_length
+              from_tags << "^" * from_width
+              to_tags << "^" * to_width
             when :delete
-              from_tags << "-" * from_length
+              from_tags << "-" * from_width
             when :insert
-              to_tags << "+" * to_length
+              to_tags << "+" * to_width
             when :equal
-              from_tags << " " * from_length
-              to_tags << " " * to_length
+              from_tags << " " * from_width
+              to_tags << " " * to_width
             else
               raise "unknown tag: #{tag}"
             end
@@ -409,13 +594,12 @@ module Test
 
           result = tag_deleted([from_line])
           unless from_tags.empty?
-            result.concat(tag_difference(["#{"\t" * common}#{from_tags}"]))
+            tag_difference(["#{"\t" * common}#{from_tags}"])
           end
-          result.concat(tag_inserted([to_line]))
+          tag_inserted([to_line])
           unless to_tags.empty?
-            result.concat(tag_difference(["#{"\t" * common}#{to_tags}"]))
+            tag_difference(["#{"\t" * common}#{to_tags}"])
           end
-          result
         end
 
         def n_leading_characters(string, character)