diff-lcs 1.1.2 → 1.1.3

data/spec/traverse_sequences_spec.rb

@@ -0,0 +1,83 @@
+# -*- ruby encoding: utf-8 -*-
+
+require 'spec_helper'
+
+describe "Diff::LCS.traverse_sequences" do
+  describe "callback with no finishers" do
+    before(:each) do
+      @callback_s1_s2 = simple_callback_no_finishers
+      Diff::LCS.traverse_sequences(seq1, seq2, @callback_s1_s2)
+
+      @callback_s2_s1 = simple_callback_no_finishers
+      Diff::LCS.traverse_sequences(seq2, seq1, @callback_s2_s1)
+    end
+
+    it "should have the correct LCS result on left-matches" do
+      @callback_s1_s2.matched_a.should == correct_lcs
+      @callback_s2_s1.matched_a.should == correct_lcs
+    end
+
+    it "should have the correct LCS result on right-matches" do
+      @callback_s1_s2.matched_b.should == correct_lcs
+      @callback_s2_s1.matched_b.should == correct_lcs
+    end
+
+    it "should have the correct skipped sequences for the left sequence" do
+      @callback_s1_s2.discards_a.should == skipped_seq1
+      @callback_s2_s1.discards_a.should == skipped_seq2
+    end
+
+    it "should have the correct skipped sequences for the right sequence" do
+      @callback_s1_s2.discards_b.should == skipped_seq2
+      @callback_s2_s1.discards_b.should == skipped_seq1
+    end
+
+    it "should not have anything done markers from the left or right sequences" do
+      @callback_s1_s2.done_a.should be_empty
+      @callback_s1_s2.done_b.should be_empty
+      @callback_s2_s1.done_a.should be_empty
+      @callback_s2_s1.done_b.should be_empty
+    end
+  end
+
+  describe "callback with finisher" do
+    before(:each) do
+      @callback_s1_s2 = simple_callback
+      Diff::LCS.traverse_sequences(seq1, seq2, @callback_s1_s2)
+      @callback_s2_s1 = simple_callback
+      Diff::LCS.traverse_sequences(seq2, seq1, @callback_s2_s1)
+    end
+
+    it "should have the correct LCS result on left-matches" do
+      @callback_s1_s2.matched_a.should == correct_lcs
+      @callback_s2_s1.matched_a.should == correct_lcs
+    end
+
+    it "should have the correct LCS result on right-matches" do
+      @callback_s1_s2.matched_b.should == correct_lcs
+      @callback_s2_s1.matched_b.should == correct_lcs
+    end
+
+    it "should have the correct skipped sequences for the left sequence" do
+      @callback_s1_s2.discards_a.should == skipped_seq1
+      @callback_s2_s1.discards_a.should == skipped_seq2
+    end
+
+    it "should have the correct skipped sequences for the right sequence" do
+      @callback_s1_s2.discards_b.should == skipped_seq2
+      @callback_s2_s1.discards_b.should == skipped_seq1
+    end
+
+    it "should have done markers differently-sized sequences" do
+      @callback_s1_s2.done_a.should == [[ "p", 9, "s", 10 ]]
+      @callback_s1_s2.done_b.should be_empty
+
+      # 20110731 I don't yet understand why this particular behaviour
+      # isn't transitive.
+      @callback_s2_s1.done_a.should be_empty
+      @callback_s2_s1.done_b.should be_empty
+    end
+  end
+end
+
+# vim: ft=ruby

metadata

@@ -1,66 +1,144 @@
 --- !ruby/object:Gem::Specification 
-rubygems_version: 0.8.1
-specification_version: 1
 name: diff-lcs
 version: !ruby/object:Gem::Version 
-  version: 1.1.2
-date: 2004-10-20
-summary: Provides a list of changes that represent the difference between two sequenced collections.
-require_paths: 
-  - lib
-author: Austin Ziegler
-email: diff-lcs@halostatue.ca
-homepage: http://rubyforge.org/projects/ruwiki/
-rubyforge_project: ruwiki
-description: "Diff::LCS is a port of Algorithm::Diff that uses the McIlroy-Hunt longest common subsequence (LCS) algorithm to compute intelligent differences between two sequenced enumerable containers. The implementation is based on Mario I. Wolczko's Smalltalk version (1.2, 1993) and Ned Konz's Perl version (Algorithm::Diff)."
-autorequire: diff/lcs
-default_executable: 
+  hash: 21
+  prerelease: 
+  segments: 
+  - 1
+  - 1
+  - 3
+  version: 1.1.3
+platform: ruby
+authors: 
+- Austin Ziegler
+autorequire: 
 bindir: bin
-has_rdoc: true
-required_ruby_version: !ruby/object:Gem::Version::Requirement 
-  requirements: 
-    - 
-      - ">="
+cert_chain: []
+
+date: 2011-08-28 00:00:00 Z
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
       - !ruby/object:Gem::Version 
-        version: 1.8.1
-  version: 
-platform: ruby
-files: 
-  - bin
-  - ChangeLog
-  - Install
-  - lib
-  - Rakefile
-  - README
-  - tests
-  - bin/htmldiff
-  - bin/ldiff
-  - lib/diff
-  - lib/diff/lcs
-  - lib/diff/lcs.rb
-  - lib/diff/lcs/array.rb
-  - lib/diff/lcs/block.rb
-  - lib/diff/lcs/callbacks.rb
-  - lib/diff/lcs/change.rb
-  - lib/diff/lcs/hunk.rb
-  - lib/diff/lcs/ldiff.rb
-  - lib/diff/lcs/string.rb
-  - tests/00test.rb
-test_files: 
-  - tests/00test.rb
-rdoc_options: 
-  - "--title"
-  - "Diff::LCS -- A Diff Algorithm"
-  - "--main"
-  - README
-  - "--line-numbers"
-extra_rdoc_files: 
-  - README
-  - ChangeLog
-  - Install
+        hash: 3
+        segments: 
+        - 2
+        - 0
+        version: "2.0"
+  type: :development
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: hoe
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 27
+        segments: 
+        - 2
+        - 12
+        version: "2.12"
+  type: :development
+  version_requirements: *id002
+description: |-
+  Diff::LCS is a port of Perl's Algorithm::Diff that uses the McIlroy-Hunt
+  longest common subsequence (LCS) algorithm to compute intelligent differences
+  between two sequenced enumerable containers. The implementation is based on
+  Mario I. Wolczko's {Smalltalk version 1.2}[ftp://st.cs.uiuc.edu/pub/Smalltalk/MANCHESTER/manchester/4.0/diff.st]
+  (1993) and Ned Konz's Perl version
+  {Algorithm::Diff 1.15}[http://search.cpan.org/~nedkonz/Algorithm-Diff-1.15/].
+  
+  This is release 1.1.3, fixing several small bugs found over the years. Version
+  1.1.0 added new features, including the ability to #patch and #unpatch changes
+  as well as a new contextual diff callback, Diff::LCS::ContextDiffCallbacks,
+  that should improve the context sensitivity of patching.
+  
+  This library is called Diff::LCS because of an early version of Algorithm::Diff
+  which was restrictively licensed. This version has seen a minor license change:
+  instead of being under Ruby's license as an option, the third optional license
+  is the MIT license.
+email: 
+- austin@rubyforge.org
 executables: 
-  - ldiff
-  - htmldiff
+- htmldiff
+- ldiff
 extensions: []
+
+extra_rdoc_files: 
+- Manifest.txt
+- docs/COPYING.txt
+- History.rdoc
+- License.rdoc
+- README.rdoc
+files: 
+- History.rdoc
+- License.rdoc
+- Manifest.txt
+- README.rdoc
+- Rakefile
+- bin/htmldiff
+- bin/ldiff
+- diff-lcs.gemspec
+- docs/COPYING.txt
+- docs/artistic.html
+- lib/diff-lcs.rb
+- lib/diff/lcs.rb
+- lib/diff/lcs/array.rb
+- lib/diff/lcs/block.rb
+- lib/diff/lcs/callbacks.rb
+- lib/diff/lcs/change.rb
+- lib/diff/lcs/htmldiff.rb
+- lib/diff/lcs/hunk.rb
+- lib/diff/lcs/ldiff.rb
+- lib/diff/lcs/string.rb
+- spec/diff_spec.rb
+- spec/lcs_spec.rb
+- spec/patch_spec.rb
+- spec/sdiff_spec.rb
+- spec/spec_helper.rb
+- spec/traverse_balanced_spec.rb
+- spec/traverse_sequences_spec.rb
+- .gemtest
+homepage: 
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --main
+- README.rdoc
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
 requirements: []
-dependencies: []
+
+rubyforge_project: ruwiki
+rubygems_version: 1.8.10
+signing_key: 
+specification_version: 3
+summary: Diff::LCS is a port of Perl's Algorithm::Diff that uses the McIlroy-Hunt longest common subsequence (LCS) algorithm to compute intelligent differences between two sequenced enumerable containers
+test_files: []
+

data/Install

@@ -1,6 +0,0 @@
-Installing this package is as simple as:
-
-% ruby install.rb
-
-Alternatively, you can use the RubyGem version of Diff::LCS available as
-diff-lcs-1.1.2.gem from the usual sources.

data/README

@@ -1,76 +0,0 @@
-Diff::LCS README
-================
-Diff::LCS is a port of Algorithm::Diff[1] that uses the McIlroy-Hunt
-longest common subsequence (LCS) algorithm to compute intelligent
-differences between two sequenced enumerable containers[2]. The
-implementation is based on Mario I. Wolczko's[3] Smalltalk version (1.2,
-1993)[4] and Ned Konz's[5] Perl version (Algorithm::Diff)[6].
-
-This release is version 1.1.2, fixing an htmldiff bug in 1.1.1. Version 1.1.0
-added new features, including the ability to #patch and #unpatch changes as
-well as a new contextual diff callback, Diff::LCS::ContextDiffCallbacks, that
-should improve the context sensitivity of patching.
-
-Using this module is quite simple. By default, Diff::LCS does not extend
-objects with the Diff::LCS interface, but will be called as if it were a
-function:
-
-  require 'diff/lcs'
-
-  seq1 = %w(a b c e h j l m n p)
-  seq2 = %w(b c d e f j k l m r s t)
-
-  lcs = Diff::LCS.LCS(seq1, seq2)
-  diffs = Diff::LCS.diff(seq1, seq2)
-  sdiff = Diff::LCS.sdiff(seq1, seq2)
-  seq = Diff::LCS.traverse_sequences(seq1, seq2, callback_obj)
-  bal = Diff::LCS.traverse_balanced(seq1, seq2, callback_obj)
-  seq2 == Diff::LCS.patch!(seq1, diffs)
-  seq1 == Diff::LCS.unpatch!(seq2, diffs)
-  seq2 == Diff::LCS.patch!(seq1, sdiff)
-  seq1 == Diff::LCS.unpatch!(seq2, sdiff)
-
-Objects can be extended with Diff::LCS:
-
-  seq1.extend(Diff::LCS)
-  lcs = seq1.lcs(seq2)
-  diffs = seq1.diff(seq2)
-  sdiff = seq1.sdiff(seq2)
-  seq = seq1.traverse_sequences(seq2, callback_obj)
-  bal = seq1.traverse_balanced(seq2, callback_obj)
-  seq2 == seq1.patch!(diffs)
-  seq1 == seq2.unpatch!(diffs)
-  seq2 == seq1.patch!(sdiff)
-  seq1 == seq2.unpatch!(sdiff)
-
-By requiring 'diff/lcs/array' or 'diff/lcs/string', Array or String will
-be extended for use this way.
-
-Copyright
-=========
-# Copyright 2004 Austin Ziegler <diff-lcs@halostatue.ca>
-#   adapted from:
-#     Algorithm::Diff (Perl) by Ned Konz <perl@bike-nomad.com>
-#     Smalltalk by Mario I. Wolczko <mario@wolczko.com>
-#   implements McIlroy-Hunt diff algorithm
-#
-# This program is free software. It may be redistributed and/or modified
-# under the terms of the GPL version 2 (or later), the Perl Artistic
-# licence, or the Ruby licence.
-# 
-# $Id: README,v 1.7 2004/10/17 20:31:10 austin Exp $
-
-Footnotes
-=========
-[1] This library is called Diff::LCS because there are multiple
-    Ruby libraries called Algorithm::Diff maintained by other authors.
-[2] By sequenced enumerable, I mean that the order of enumeration is
-    predictable and consistent for the same set of data. While it is
-    theoretically possible to generate a diff for unordereded hash, it
-    will only be meaningful if the enumeration of the hashes is
-    consistent. In general, this will mean that containers that behave
-    like String or Array will perform best.
-[3] mario@wolczko.com
-[4] ftp://st.cs.uiuc.edu/pub/Smalltalk/MANCHESTER/manchester/4.0/diff.st
-[5] perl@bike-nomad.com
-[6] http://search.cpan.org/~nedkonz/Algorithm-Diff-1.15/

data/tests/00test.rb

@@ -1,626 +0,0 @@
-#! /usr/bin/env ruby
-#
-$LOAD_PATH.unshift("#{File.dirname(__FILE__)}/../lib") if __FILE__ == $0
-
-require 'diff/lcs'
-require 'test/unit'
-require 'pp'
-require 'diff/lcs/array'
-
-module Diff::LCS::Tests
-  def __format_diffs(diffs)
-    diffs.map do |e|
-      if e.kind_of?(Array)
-        e.map { |f| f.to_a.join }.join(", ")
-      else
-        e.to_a.join
-      end
-    end.join("; ")
-  end
-
-  def __map_diffs(diffs, klass = Diff::LCS::ContextChange)
-    diffs.map do |chunks|
-      if klass == Diff::LCS::ContextChange
-        klass.from_a(chunks)
-      else
-        chunks.map { |changes| klass.from_a(changes) }
-      end
-    end
-  end
-
-  def __simple_callbacks
-    callbacks = Object.new
-    class << callbacks
-      attr_reader :matched_a
-      attr_reader :matched_b
-      attr_reader :discards_a
-      attr_reader :discards_b
-      attr_reader :done_a
-      attr_reader :done_b
-
-      def reset
-        @matched_a = []
-        @matched_b = []
-        @discards_a = []
-        @discards_b = []
-        @done_a = []
-        @done_b = []
-      end
-
-      def match(event)
-        @matched_a << event.old_element
-        @matched_b << event.new_element
-      end
-
-      def discard_b(event)
-        @discards_b << event.new_element
-      end
-
-      def discard_a(event)
-        @discards_a << event.old_element
-      end
-
-      def finished_a(event)
-        @done_a << [event.old_element, event.old_position]
-      end
-
-      def finished_b(event)
-        @done_b << [event.new_element, event.new_position]
-      end
-    end
-    callbacks.reset
-    callbacks
-  end
-
-  def __balanced_callback
-    cb = Object.new
-    class << cb
-      attr_reader :result
-
-      def reset
-        @result = ""
-      end
-
-      def match(event)
-        @result << "M#{event.old_position}#{event.new_position} "
-      end
-
-      def discard_a(event)
-        @result << "DA#{event.old_position}#{event.new_position} "
-      end
-
-      def discard_b(event)
-        @result << "DB#{event.old_position}#{event.new_position} "
-      end
-
-      def change(event)
-        @result << "C#{event.old_position}#{event.new_position} "
-      end
-    end
-    cb.reset
-    cb
-  end
-
-  def setup
-    @seq1 = %w(a b c e h j l m n p)
-    @seq2 = %w(b c d e f j k l m r s t)
-
-    @correct_lcs = %w(b c e j l m)
-
-    @skipped_seq1 = 'a h n p'
-    @skipped_seq2 = 'd f k r s t'
-
-    correct_diff = [
-      [ [ '-',  0, 'a' ] ],
-      [ [ '+',  2, 'd' ] ],
-      [ [ '-',  4, 'h' ],
-        [ '+',  4, 'f' ] ],
-      [ [ '+',  6, 'k' ] ],
-      [ [ '-',  8, 'n' ],
-        [ '-',  9, 'p' ],
-        [ '+',  9, 'r' ],
-        [ '+', 10, 's' ],
-        [ '+', 11, 't' ] ] ]
-    @correct_diff = __map_diffs(correct_diff, Diff::LCS::Change)
-  end
-end
-
-class TestLCS < Test::Unit::TestCase
-  include Diff::LCS::Tests
-
-  def test_lcs
-    res = ares = bres = nil
-    assert_nothing_raised { res = Diff::LCS.__lcs(@seq1, @seq2) }
-      # The result of the LCS (less the +nil+ values) must be as long as the
-      # correct result.
-    assert_equal(res.compact.size, @correct_lcs.size)
-    res.each_with_index { |ee, ii| assert(ee.nil? || (@seq1[ii] == @seq2[ee])) }
-    assert_nothing_raised { ares = (0...res.size).map { |ii| res[ii] ? @seq1[ii] : nil } }
-    assert_nothing_raised { bres = (0...res.size).map { |ii| res[ii] ? @seq2[res[ii]] : nil } }
-    assert_equal(@correct_lcs, ares.compact)
-    assert_equal(@correct_lcs, bres.compact)
-    assert_nothing_raised { res = Diff::LCS.LCS(@seq1, @seq2) }
-    assert_equal(res.compact, @correct_lcs)
-  end
-end
-
-class TestSequences < Test::Unit::TestCase
-  include Diff::LCS::Tests
-
-  def test_sequences
-    callbacks = nil
-    assert_nothing_raised do
-      callbacks = __simple_callbacks
-      class << callbacks
-        undef :finished_a
-        undef :finished_b
-      end
-      Diff::LCS.traverse_sequences(@seq1, @seq2, callbacks)
-    end
-    assert_equal(@correct_lcs.size, callbacks.matched_a.size)
-    assert_equal(@correct_lcs.size, callbacks.matched_b.size)
-    assert_equal(@skipped_seq1, callbacks.discards_a.join(" "))
-    assert_equal(@skipped_seq2, callbacks.discards_b.join(" "))
-    assert_nothing_raised do
-      callbacks = __simple_callbacks
-      Diff::LCS.traverse_sequences(@seq1, @seq2, callbacks)
-    end
-    assert_equal(@correct_lcs.size, callbacks.matched_a.size)
-    assert_equal(@correct_lcs.size, callbacks.matched_b.size)
-    assert_equal(@skipped_seq1, callbacks.discards_a.join(" "))
-    assert_equal(@skipped_seq2, callbacks.discards_b.join(" "))
-    assert_equal(9, callbacks.done_a[0][1])
-    assert_nil(callbacks.done_b[0])
-
-#   seqw = %w(abcd efgh ijkl mnopqrstuvwxyz)
-#   assert_nothing_raised do
-#     callbacks = __simple_callbacks
-#     class << callbacks
-#       undef :finished_a
-#       undef :finished_b
-#     end
-#     Diff::LCS.traverse_sequences(seqw, [], callbacks)
-#   end
-  end
-
-  def test_diff
-    diff = nil
-    assert_nothing_raised { diff = Diff::LCS.diff(@seq1, @seq2) }
-    assert_equal(__format_diffs(@correct_diff), __format_diffs(diff))
-    assert_equal(@correct_diff, diff)
-  end
-
-  def test_diff_empty
-    seqw = %w(abcd efgh ijkl mnopqrstuvwxyz)
-    correct_diff = [
-      [ [ '-', 0, 'abcd'           ],
-        [ '-', 1, 'efgh'           ],
-        [ '-', 2, 'ijkl'           ],
-        [ '-', 3, 'mnopqrstuvwxyz' ] ] ]
-    diff = nil
-
-    assert_nothing_raised { diff = Diff::LCS.diff(seqw, []) }
-    assert_equal(__format_diffs(correct_diff), __format_diffs(diff))
-
-    correct_diff = [
-      [ [ '+', 0, 'abcd'           ],
-        [ '+', 1, 'efgh'           ],
-        [ '+', 2, 'ijkl'           ],
-        [ '+', 3, 'mnopqrstuvwxyz' ] ] ]
-    assert_nothing_raised { diff = Diff::LCS.diff([], seqw) }
-    assert_equal(__format_diffs(correct_diff), __format_diffs(diff))
-  end
-end
-
-class TestBalanced < Test::Unit::TestCase
-  include Diff::LCS::Tests
-
-  def test_sdiff_a
-    sdiff = nil
-    seq1 = %w(abc def yyy xxx ghi jkl)
-    seq2 = %w(abc dxf xxx ghi jkl)
-    correct_sdiff = [
-      [ '=', [ 0, 'abc' ], [ 0, 'abc' ] ],
-      [ '!', [ 1, 'def' ], [ 1, 'dxf' ] ],
-      [ '-', [ 2, 'yyy' ], [ 2,  nil  ] ],
-      [ '=', [ 3, 'xxx' ], [ 2, 'xxx' ] ],
-      [ '=', [ 4, 'ghi' ], [ 3, 'ghi' ] ],
-      [ '=', [ 5, 'jkl' ], [ 4, 'jkl' ] ] ]
-    correct_sdiff = __map_diffs(correct_sdiff)
-    assert_nothing_raised { sdiff = Diff::LCS.sdiff(seq1, seq2) }
-    assert_equal(correct_sdiff, sdiff)
-  end
-
-  def test_sdiff_b
-    sdiff = nil
-    correct_sdiff = [
-      [ '-', [  0, 'a' ], [  0, nil ] ],
-      [ '=', [  1, 'b' ], [  0, 'b' ] ],
-      [ '=', [  2, 'c' ], [  1, 'c' ] ],
-      [ '+', [  3, nil ], [  2, 'd' ] ],
-      [ '=', [  3, 'e' ], [  3, 'e' ] ],
-      [ '!', [  4, 'h' ], [  4, 'f' ] ],
-      [ '=', [  5, 'j' ], [  5, 'j' ] ],
-      [ '+', [  6, nil ], [  6, 'k' ] ],
-      [ '=', [  6, 'l' ], [  7, 'l' ] ],
-      [ '=', [  7, 'm' ], [  8, 'm' ] ],
-      [ '!', [  8, 'n' ], [  9, 'r' ] ],
-      [ '!', [  9, 'p' ], [ 10, 's' ] ],
-      [ '+', [ 10, nil ], [ 11, 't' ] ] ]
-    correct_sdiff = __map_diffs(correct_sdiff)
-    assert_nothing_raised { sdiff = Diff::LCS.sdiff(@seq1, @seq2) }
-    assert_equal(correct_sdiff, sdiff)
-  end
-
-  def test_sdiff_c
-    sdiff = nil
-    seq1 = %w(a b c d e)
-    seq2 = %w(a e)
-    correct_sdiff = [
-      [ '=', [ 0, 'a' ], [ 0, 'a' ] ],
-      [ '-', [ 1, 'b' ], [ 1, nil ] ],
-      [ '-', [ 2, 'c' ], [ 1, nil ] ],
-      [ '-', [ 3, 'd' ], [ 1, nil ] ],
-      [ '=', [ 4, 'e' ], [ 1, 'e' ] ] ]
-    correct_sdiff = __map_diffs(correct_sdiff)
-    assert_nothing_raised { sdiff = Diff::LCS.sdiff(seq1, seq2) }
-    assert_equal(correct_sdiff, sdiff)
-  end
-
-  def test_sdiff_d
-    sdiff = nil
-    seq1 = %w(a e)
-    seq2 = %w(a b c d e)
-    correct_sdiff = [
-      [ '=', [ 0, 'a' ], [ 0, 'a' ] ],
-      [ '+', [ 1, nil ], [ 1, 'b' ] ],
-      [ '+', [ 1, nil ], [ 2, 'c' ] ],
-      [ '+', [ 1, nil ], [ 3, 'd' ] ],
-      [ '=', [ 1, 'e' ], [ 4, 'e' ] ] ]
-    correct_sdiff = __map_diffs(correct_sdiff)
-    assert_nothing_raised { sdiff = Diff::LCS.sdiff(seq1, seq2) }
-    assert_equal(correct_sdiff, sdiff)
-  end
-
-  def test_sdiff_e
-    sdiff = nil
-    seq1 = %w(v x a e)
-    seq2 = %w(w y a b c d e)
-    correct_sdiff = [
-      [ '!', [ 0, 'v' ], [ 0, 'w' ] ],
-      [ '!', [ 1, 'x' ], [ 1, 'y' ] ],
-      [ '=', [ 2, 'a' ], [ 2, 'a' ] ],
-      [ '+', [ 3, nil ], [ 3, 'b' ] ],
-      [ '+', [ 3, nil ], [ 4, 'c' ] ],
-      [ '+', [ 3, nil ], [ 5, 'd' ] ],
-      [ '=', [ 3, 'e' ], [ 6, 'e' ] ] ]
-    correct_sdiff = __map_diffs(correct_sdiff)
-    assert_nothing_raised { sdiff = Diff::LCS.sdiff(seq1, seq2) }
-    assert_equal(correct_sdiff, sdiff)
-  end
-
-  def test_sdiff_f
-    sdiff = nil
-    seq1 = %w(x a e)
-    seq2 = %w(a b c d e)
-    correct_sdiff = [
-      [ '-', [ 0, 'x' ], [ 0, nil ] ],
-      [ '=', [ 1, 'a' ], [ 0, 'a' ] ],
-      [ '+', [ 2, nil ], [ 1, 'b' ] ],
-      [ '+', [ 2, nil ], [ 2, 'c' ] ],
-      [ '+', [ 2, nil ], [ 3, 'd' ] ],
-      [ '=', [ 2, 'e' ], [ 4, 'e' ] ] ]
-    correct_sdiff = __map_diffs(correct_sdiff)
-    assert_nothing_raised { sdiff = Diff::LCS.sdiff(seq1, seq2) }
-    assert_equal(correct_sdiff, sdiff)
-  end
-
-  def test_sdiff_g
-    sdiff = nil
-    seq1 = %w(a e)
-    seq2 = %w(x a b c d e)
-    correct_sdiff = [
-      [ '+', [ 0, nil ], [ 0, 'x' ] ],
-      [ '=', [ 0, 'a' ], [ 1, 'a' ] ],
-      [ '+', [ 1, nil ], [ 2, 'b' ] ],
-      [ '+', [ 1, nil ], [ 3, 'c' ] ],
-      [ '+', [ 1, nil ], [ 4, 'd' ] ],
-      [ '=', [ 1, 'e' ], [ 5, 'e' ] ] ]
-    correct_sdiff = __map_diffs(correct_sdiff)
-    assert_nothing_raised { sdiff = Diff::LCS.sdiff(seq1, seq2) }
-    assert_equal(correct_sdiff, sdiff)
-  end
-
-  def test_sdiff_h
-    sdiff = nil
-    seq1 = %w(a e v)
-    seq2 = %w(x a b c d e w x)
-    correct_sdiff = [
-      [ '+', [ 0, nil ], [ 0, 'x' ] ],
-      [ '=', [ 0, 'a' ], [ 1, 'a' ] ],
-      [ '+', [ 1, nil ], [ 2, 'b' ] ],
-      [ '+', [ 1, nil ], [ 3, 'c' ] ],
-      [ '+', [ 1, nil ], [ 4, 'd' ] ],
-      [ '=', [ 1, 'e' ], [ 5, 'e' ] ],
-      [ '!', [ 2, 'v' ], [ 6, 'w' ] ],
-      [ '+', [ 3, nil ], [ 7, 'x' ] ] ]
-    correct_sdiff = __map_diffs(correct_sdiff)
-    assert_nothing_raised { sdiff = Diff::LCS.sdiff(seq1, seq2) }
-    assert_equal(correct_sdiff, sdiff)
-  end
-
-  def test_sdiff_i
-    sdiff = nil
-    seq1 = %w()
-    seq2 = %w(a b c)
-    correct_sdiff = [
-      [ '+', [ 0, nil ], [ 0, 'a' ] ],
-      [ '+', [ 0, nil ], [ 1, 'b' ] ],
-      [ '+', [ 0, nil ], [ 2, 'c' ] ] ]
-    correct_sdiff = __map_diffs(correct_sdiff)
-    assert_nothing_raised { sdiff = Diff::LCS.sdiff(seq1, seq2) }
-    assert_equal(correct_sdiff, sdiff)
-  end
-
-  def test_sdiff_j
-    sdiff = nil
-    seq1 = %w(a b c)
-    seq2 = %w()
-    correct_sdiff = [
-      [ '-', [ 0, 'a' ], [ 0, nil ] ],
-      [ '-', [ 1, 'b' ], [ 0, nil ] ],
-      [ '-', [ 2, 'c' ], [ 0, nil ] ] ]
-    correct_sdiff = __map_diffs(correct_sdiff)
-    assert_nothing_raised { sdiff = Diff::LCS.sdiff(seq1, seq2) }
-    assert_equal(correct_sdiff, sdiff)
-  end
-
-  def test_sdiff_k
-    sdiff = nil
-    seq1 = %w(a b c)
-    seq2 = %w(1)
-    correct_sdiff = [
-      [ '!', [ 0, 'a' ], [ 0, '1' ] ],
-      [ '-', [ 1, 'b' ], [ 1, nil ] ],
-      [ '-', [ 2, 'c' ], [ 1, nil ] ] ]
-    correct_sdiff = __map_diffs(correct_sdiff)
-    assert_nothing_raised { sdiff = Diff::LCS.sdiff(seq1, seq2) }
-    assert_equal(correct_sdiff, sdiff)
-  end
-
-  def test_sdiff_l
-    sdiff = nil
-    seq1 = %w(a b c)
-    seq2 = %w(c)
-    correct_sdiff = [
-      [ '-', [ 0, 'a' ], [ 0, nil ] ],
-      [ '-', [ 1, 'b' ], [ 0, nil ] ],
-      [ '=', [ 2, 'c' ], [ 0, 'c' ] ]
-    ]
-    correct_sdiff = __map_diffs(correct_sdiff)
-    assert_nothing_raised { sdiff = Diff::LCS.sdiff(seq1, seq2) }
-    assert_equal(correct_sdiff, sdiff)
-  end
-
-  def test_sdiff_m
-    sdiff = nil
-    seq1 = %w(abcd efgh ijkl mnop)
-    seq2 = []
-    correct_sdiff = [
-      [ '-', [ 0, 'abcd' ], [ 0, nil ] ],
-      [ '-', [ 1, 'efgh' ], [ 0, nil ] ],
-      [ '-', [ 2, 'ijkl' ], [ 0, nil ] ],
-      [ '-', [ 3, 'mnop' ], [ 0, nil ] ]
-    ]
-    correct_sdiff = __map_diffs(correct_sdiff)
-    assert_nothing_raised { sdiff = Diff::LCS.sdiff(seq1, seq2) }
-    assert_equal(correct_sdiff, sdiff)
-  end
-
-  def test_sdiff_n
-    sdiff = nil
-    seq1 = []
-    seq2 = %w(abcd efgh ijkl mnop)
-    correct_sdiff = [
-      [ '+', [ 0, nil ], [ 0, 'abcd' ] ],
-      [ '+', [ 0, nil ], [ 1, 'efgh' ] ],
-      [ '+', [ 0, nil ], [ 2, 'ijkl' ] ],
-      [ '+', [ 0, nil ], [ 3, 'mnop' ] ]
-    ]
-    correct_sdiff = __map_diffs(correct_sdiff)
-    assert_nothing_raised { sdiff = Diff::LCS.sdiff(seq1, seq2) }
-    assert_equal(correct_sdiff, sdiff)
-  end
-
-  def test_balanced_a
-    seq1 = %w(a b c)
-    seq2 = %w(a x c)
-    callback = nil
-    assert_nothing_raised { callback = __balanced_callback }
-    assert_nothing_raised { Diff::LCS.traverse_balanced(seq1, seq2, callback) }
-    assert_equal("M00 C11 M22 ", callback.result)
-  end
-
-  def test_balanced_b
-    seq1 = %w(a b c)
-    seq2 = %w(a x c)
-    callback = nil
-    assert_nothing_raised do
-      callback = __balanced_callback
-      class << callback
-        undef change
-      end
-    end
-    assert_nothing_raised { Diff::LCS.traverse_balanced(seq1, seq2, callback) }
-    assert_equal("M00 DA11 DB21 M22 ", callback.result)
-  end
-
-  def test_balanced_c
-    seq1 = %w(a x y c)
-    seq2 = %w(a v w c)
-    callback = nil
-    assert_nothing_raised { callback = __balanced_callback }
-    assert_nothing_raised { Diff::LCS.traverse_balanced(seq1, seq2, callback) }
-    assert_equal("M00 C11 C22 M33 ", callback.result)
-  end
-
-  def test_balanced_d
-    seq1 = %w(x y c)
-    seq2 = %w(v w c)
-    callback = nil
-    assert_nothing_raised { callback = __balanced_callback }
-    assert_nothing_raised { Diff::LCS.traverse_balanced(seq1, seq2, callback) }
-    assert_equal("C00 C11 M22 ", callback.result)
-  end
-
-  def test_balanced_e
-    seq1 = %w(a x y z)
-    seq2 = %w(b v w)
-    callback = nil
-    assert_nothing_raised { callback = __balanced_callback }
-    assert_nothing_raised { Diff::LCS.traverse_balanced(seq1, seq2, callback) }
-    assert_equal("C00 C11 C22 DA33 ", callback.result)
-  end
-
-  def test_balanced_f
-    seq1 = %w(a z)
-    seq2 = %w(a)
-    callback = nil
-    assert_nothing_raised { callback = __balanced_callback }
-    assert_nothing_raised { Diff::LCS.traverse_balanced(seq1, seq2, callback) }
-    assert_equal("M00 DA11 ", callback.result)
-  end
-
-  def test_balanced_g
-    seq1 = %w(z a)
-    seq2 = %w(a)
-    callback = nil
-    assert_nothing_raised { callback = __balanced_callback }
-    assert_nothing_raised { Diff::LCS.traverse_balanced(seq1, seq2, callback) }
-    assert_equal("DA00 M10 ", callback.result)
-  end
-
-  def test_balanced_h
-    seq1 = %w(a b c)
-    seq2 = %w(x y z)
-    callback = nil
-    assert_nothing_raised { callback = __balanced_callback }
-    assert_nothing_raised { Diff::LCS.traverse_balanced(seq1, seq2, callback) }
-    assert_equal("C00 C11 C22 ", callback.result)
-  end
-
-  def test_balanced_i
-    seq1 = %w(abcd efgh ijkl mnopqrstuvwxyz)
-    seq2 = []
-    callback = nil
-    assert_nothing_raised { callback = __balanced_callback }
-    assert_nothing_raised { Diff::LCS.traverse_balanced(seq1, seq2, callback) }
-    assert_equal("DA00 DA10 DA20 DA30 ", callback.result)
-  end
-
-  def test_balanced_j
-    seq1 = []
-    seq2 = %w(abcd efgh ijkl mnopqrstuvwxyz)
-    callback = nil
-    assert_nothing_raised { callback = __balanced_callback }
-    assert_nothing_raised { Diff::LCS.traverse_balanced(seq1, seq2, callback) }
-    assert_equal("DB00 DB01 DB02 DB03 ", callback.result)
-  end
-end
-
-class TestPatching < Test::Unit::TestCase
-  include Diff::LCS::Tests
-
-  def test_patch_diff
-    ps = ms1 = ms2 = ms3 = nil
-    assert_nothing_raised do
-      ps = Diff::LCS.diff(@seq1, @seq2)
-      ms1 = Diff::LCS.patch(@seq1, ps)
-      ms2 = Diff::LCS.patch(@seq2, ps, :unpatch)
-      ms3 = Diff::LCS.patch(@seq2, ps)
-    end
-    assert_equal(@seq2, ms1)
-    assert_equal(@seq1, ms2)
-    assert_equal(@seq1, ms3)
-    assert_nothing_raised do
-      ps = Diff::LCS.diff(@seq1, @seq2, Diff::LCS::ContextDiffCallbacks)
-      ms1 = Diff::LCS.patch(@seq1, ps)
-      ms2 = Diff::LCS.patch(@seq2, ps, :unpatch)
-      ms2 = Diff::LCS.patch(@seq2, ps)
-    end
-    assert_equal(@seq2, ms1)
-    assert_equal(@seq1, ms2)
-    assert_equal(@seq1, ms3)
-    assert_nothing_raised do
-      ps = Diff::LCS.diff(@seq1, @seq2, Diff::LCS::SDiffCallbacks)
-      ms1 = Diff::LCS.patch(@seq1, ps)
-      ms2 = Diff::LCS.patch(@seq2, ps, :unpatch)
-      ms3 = Diff::LCS.patch(@seq2, ps)
-    end
-    assert_equal(@seq2, ms1)
-    assert_equal(@seq1, ms2)
-    assert_equal(@seq1, ms3)
-  end
-
-    # Tests patch bug #891:
-    # http://rubyforge.org/tracker/?func=detail&atid=407&aid=891&group_id=84
-  def test_patch_bug891
-    s1 = s2 = s3 = s4 = s5 = ps = nil
-    assert_nothing_raised do
-      s1 = %w{a b c d   e f g h i j k }
-      s2 = %w{a b c d D e f g h i j k }
-      ps = Diff::LCS::diff(s1, s2)
-      s3 = Diff::LCS.patch(s1, ps, :patch)
-      ps = Diff::LCS::diff(s1, s2, Diff::LCS::ContextDiffCallbacks)
-      s4 = Diff::LCS.patch(s1, ps, :patch)
-      ps = Diff::LCS::diff(s1, s2, Diff::LCS::SDiffCallbacks)
-      s5 = Diff::LCS.patch(s1, ps, :patch)
-    end
-    assert_equal(s2, s3)
-    assert_equal(s2, s4)
-    assert_equal(s2, s5)
-
-    assert_nothing_raised do
-      ps = Diff::LCS::sdiff(s1, s2)
-      s3 = Diff::LCS.patch(s1, ps, :patch)
-      ps = Diff::LCS::diff(s1, s2, Diff::LCS::ContextDiffCallbacks)
-      s4 = Diff::LCS.patch(s1, ps, :patch)
-      ps = Diff::LCS::diff(s1, s2, Diff::LCS::DiffCallbacks)
-      s5 = Diff::LCS.patch(s1, ps, :patch)
-    end
-    assert_equal(s2, s3)
-    assert_equal(s2, s4)
-    assert_equal(s2, s5)
-  end
-
-  def test_patch_sdiff
-    ps = ms1 = ms2 = ms3 = nil
-    assert_nothing_raised do
-      ps = Diff::LCS.sdiff(@seq1, @seq2)
-      ms1 = Diff::LCS.patch(@seq1, ps)
-      ms2 = Diff::LCS.patch(@seq2, ps, :unpatch)
-      ms3 = Diff::LCS.patch(@seq2, ps)
-    end
-    assert_equal(@seq2, ms1)
-    assert_equal(@seq1, ms2)
-    assert_equal(@seq1, ms3)
-    assert_nothing_raised do
-      ps = Diff::LCS.sdiff(@seq1, @seq2, Diff::LCS::ContextDiffCallbacks)
-      ms1 = Diff::LCS.patch(@seq1, ps)
-      ms2 = Diff::LCS.patch(@seq2, ps, :unpatch)
-      ms3 = Diff::LCS.patch(@seq2, ps)
-    end
-    assert_equal(@seq2, ms1)
-    assert_equal(@seq1, ms2)
-    assert_equal(@seq1, ms3)
-    assert_nothing_raised do
-      ps = Diff::LCS.sdiff(@seq1, @seq2, Diff::LCS::DiffCallbacks)
-      ms1 = Diff::LCS.patch(@seq1, ps)
-      ms2 = Diff::LCS.patch(@seq2, ps, :unpatch)
-      ms3 = Diff::LCS.patch(@seq2, ps)
-    end
-    assert_equal(@seq2, ms1)
-    assert_equal(@seq1, ms2)
-    assert_equal(@seq1, ms3)
-  end
-end