dxruby_rp5 0.0.1

data/spec/vendor/diff-lcs-1.2.5/lib/diff-lcs.rb

@@ -0,0 +1,3 @@
+# -*- ruby encoding: utf-8 -*-
+
+require 'diff/lcs'

data/spec/vendor/diff-lcs-1.2.5/spec/change_spec.rb

@@ -0,0 +1,65 @@
+# -*- ruby encoding: utf-8 -*-
+
+require 'spec_helper'
+
+describe Diff::LCS::Change do
+  describe "an add" do
+    subject { described_class.new('+', 0, 'element') }
+    it { should_not be_deleting   }
+    it { should     be_adding     }
+    it { should_not be_unchanged  }
+    it { should_not be_changed    }
+    it { should_not be_finished_a }
+    it { should_not be_finished_b }
+  end
+
+  describe "a delete" do
+    subject { described_class.new('-', 0, 'element') }
+    it { should     be_deleting   }
+    it { should_not be_adding     }
+    it { should_not be_unchanged  }
+    it { should_not be_changed    }
+    it { should_not be_finished_a }
+    it { should_not be_finished_b }
+  end
+
+  describe "an unchanged" do
+    subject { described_class.new('=', 0, 'element') }
+    it { should_not be_deleting   }
+    it { should_not be_adding     }
+    it { should     be_unchanged  }
+    it { should_not be_changed    }
+    it { should_not be_finished_a }
+    it { should_not be_finished_b }
+  end
+
+  describe "a changed" do
+    subject { described_class.new('!', 0, 'element') }
+    it { should_not be_deleting   }
+    it { should_not be_adding     }
+    it { should_not be_unchanged  }
+    it { should     be_changed    }
+    it { should_not be_finished_a }
+    it { should_not be_finished_b }
+  end
+
+  describe "a finished_a" do
+    subject { described_class.new('>', 0, 'element') }
+    it { should_not be_deleting   }
+    it { should_not be_adding     }
+    it { should_not be_unchanged  }
+    it { should_not be_changed    }
+    it { should     be_finished_a }
+    it { should_not be_finished_b }
+  end
+
+  describe "a finished_b" do
+    subject { described_class.new('<', 0, 'element') }
+    it { should_not be_deleting   }
+    it { should_not be_adding     }
+    it { should_not be_unchanged  }
+    it { should_not be_changed    }
+    it { should_not be_finished_a }
+    it { should     be_finished_b }
+  end
+end

data/spec/vendor/diff-lcs-1.2.5/spec/diff_spec.rb

@@ -0,0 +1,47 @@
+# -*- ruby encoding: utf-8 -*-
+
+require 'spec_helper'
+
+describe "Diff::LCS.diff" do
+  include Diff::LCS::SpecHelper::Matchers
+
+  it "should correctly diff seq1 to seq2" do
+    diff_s1_s2 = Diff::LCS.diff(seq1, seq2)
+    change_diff(correct_forward_diff).should == diff_s1_s2
+  end
+
+  it "should correctly diff seq2 to seq1" do
+    diff_s2_s1 = Diff::LCS.diff(seq2, seq1)
+    change_diff(correct_backward_diff).should == diff_s2_s1
+  end
+
+  it "should correctly diff against an empty sequence" do
+    diff = Diff::LCS.diff(word_sequence, [])
+    correct_diff = [
+      [ [ '-', 0, 'abcd'           ],
+        [ '-', 1, 'efgh'           ],
+        [ '-', 2, 'ijkl'           ],
+        [ '-', 3, 'mnopqrstuvwxyz' ] ]
+    ]
+
+    change_diff(correct_diff).should == diff
+
+    diff = Diff::LCS.diff([], word_sequence)
+    correct_diff.each { |hunk| hunk.each { |change| change[0] = '+' } }
+    change_diff(correct_diff).should == diff
+  end
+
+  it "should correctly diff 'xx' and 'xaxb'" do
+    left = 'xx'
+    right = 'xaxb'
+    Diff::LCS.patch(left, Diff::LCS.diff(left, right)).should == right
+  end
+
+  it "should return an empty diff with (hello, hello)" do
+    Diff::LCS.diff(hello, hello).should == []
+  end
+
+  it "should return an empty diff with (hello_ary, hello_ary)" do
+    Diff::LCS.diff(hello_ary, hello_ary).should == []
+  end
+end

data/spec/vendor/diff-lcs-1.2.5/spec/hunk_spec.rb

@@ -0,0 +1,72 @@
+# -*- ruby encoding: utf-8 -*-
+
+require 'spec_helper'
+
+def h(v)
+  v.to_s.bytes.to_a.map { |e| "%02x" % e }.join
+end
+
+describe "Diff::LCS::Hunk" do
+  if String.method_defined?(:encoding)
+
+    let(:old_data) { ["Tu avec carté {count} itém has".encode('UTF-16LE')] }
+    let(:new_data) { ["Tu avec carte {count} item has".encode('UTF-16LE')] }
+    let(:pieces)   { Diff::LCS.diff old_data, new_data }
+    let(:hunk)     { Diff::LCS::Hunk.new(old_data, new_data, pieces[0], 3, 0) }
+
+    it 'should be able to produce a unified diff from the two pieces' do
+      expected = (<<-EOD.gsub(/^\s+/,'').encode('UTF-16LE').chomp)
+        @@ -1,2 +1,2 @@
+        -Tu avec carté {count} itém has
+        +Tu avec carte {count} item has
+      EOD
+      expect(hunk.diff(:unified).to_s == expected).to eql true
+    end
+
+    it 'should be able to produce a context diff from the two pieces' do
+      expected = (<<-EOD.gsub(/^\s+/,'').encode('UTF-16LE').chomp)
+        ***************
+        *** 1,2 ****
+        !Tu avec carté {count} itém has
+        --- 1,2 ----
+        !Tu avec carte {count} item has
+      EOD
+
+      expect(hunk.diff(:context).to_s == expected).to eql true
+    end
+
+    it 'should be able to produce an old diff from the two pieces' do
+      expected = (<<-EOD.gsub(/^ +/,'').encode('UTF-16LE').chomp)
+        1,2c1,2
+        < Tu avec carté {count} itém has
+        ---
+        > Tu avec carte {count} item has
+
+      EOD
+      expect(hunk.diff(:old).to_s == expected).to eql true
+    end
+
+    it 'should be able to produce a reverse ed diff from the two pieces' do
+      expected = (<<-EOD.gsub(/^ +/,'').encode('UTF-16LE').chomp)
+        c1,2
+        Tu avec carte {count} item has
+        .
+
+      EOD
+      expect(hunk.diff(:reverse_ed).to_s == expected).to eql true
+    end
+
+    context 'with empty first data set' do
+      let(:old_data) { [] }
+
+      it 'should be able to produce a unified diff' do
+        expected = (<<-EOD.gsub(/^\s+/,'').encode('UTF-16LE').chomp)
+          @@ -1 +1,2 @@
+          +Tu avec carte {count} item has
+        EOD
+        expect(hunk.diff(:unified).to_s == expected).to eql true
+      end
+    end
+
+  end
+end

data/spec/vendor/diff-lcs-1.2.5/spec/issues_spec.rb

@@ -0,0 +1,24 @@
+# -*- ruby encoding: utf-8 -*-
+
+require 'spec_helper'
+
+describe "Diff::LCS Issues" do
+  include Diff::LCS::SpecHelper::Matchers
+
+  it "should not fail to provide a simple patchset (issue 1)" do
+    s1, s2 = *%W(aX bXaX)
+    correct_forward_diff = [
+      [ [ '+', 0, 'b' ],
+        [ '+', 1, 'X' ] ],
+    ]
+
+    diff_s1_s2 = Diff::LCS.diff(s1, s2)
+    change_diff(correct_forward_diff).should == diff_s1_s2
+    expect do
+      Diff::LCS.patch(s1, diff_s1_s2).should == s2
+    end.to_not raise_error(RuntimeError, /provided patchset/)
+    expect do
+      Diff::LCS.patch(s2, diff_s1_s2).should == s1
+    end.to_not raise_error(RuntimeError, /provided patchset/)
+  end
+end

data/spec/vendor/diff-lcs-1.2.5/spec/lcs_spec.rb

@@ -0,0 +1,54 @@
+# -*- ruby encoding: utf-8 -*-
+
+require 'spec_helper'
+
+describe "Diff::LCS::Internals.lcs" do
+  include Diff::LCS::SpecHelper::Matchers
+
+  it "should return a meaningful LCS array with (seq1, seq2)" do
+    res = Diff::LCS::Internals.lcs(seq1, seq2)
+    # The result of the LCS (less the +nil+ values) must be as long as the
+    # correct result.
+    res.compact.size.should == correct_lcs.size
+    res.should correctly_map_sequence(seq1).to_other_sequence(seq2)
+
+    # Compact these transformations and they should be the correct LCS.
+    x_seq1 = (0...res.size).map { |ix| res[ix] ? seq1[ix] : nil }.compact
+    x_seq2 = (0...res.size).map { |ix| res[ix] ? seq2[res[ix]] : nil }.compact
+
+    x_seq1.should == correct_lcs
+    x_seq2.should == correct_lcs
+  end
+
+  it "should return all indexes with (hello, hello)" do
+    Diff::LCS::Internals.lcs(hello, hello).should == (0...hello.size).to_a
+  end
+
+  it "should return all indexes with (hello_ary, hello_ary)" do
+    Diff::LCS::Internals.lcs(hello_ary, hello_ary).should == (0...hello_ary.size).to_a
+  end
+end
+
+describe "Diff::LCS.LCS" do
+  include Diff::LCS::SpecHelper::Matchers
+
+  it "should return the correct compacted values from Diff::LCS.LCS" do
+    res = Diff::LCS.LCS(seq1, seq2)
+    res.should == correct_lcs
+    res.compact.should == res
+  end
+
+  it "should be transitive" do
+    res = Diff::LCS.LCS(seq2, seq1)
+    res.should == correct_lcs
+    res.compact.should == res
+  end
+
+  it "should return %W(h e l l o) with (hello, hello)" do
+    Diff::LCS.LCS(hello, hello).should == hello.split(//)
+  end
+
+  it "should return hello_ary with (hello_ary, hello_ary)" do
+    Diff::LCS.LCS(hello_ary, hello_ary).should == hello_ary
+  end
+end

data/spec/vendor/diff-lcs-1.2.5/spec/patch_spec.rb

@@ -0,0 +1,414 @@
+# -*- ruby encoding: utf-8 -*-
+
+require 'spec_helper'
+
+describe "Diff::LCS.patch" do
+  include Diff::LCS::SpecHelper::Matchers
+
+  shared_examples "patch sequences correctly" do
+    it "should correctly patch left-to-right (patch autodiscovery)" do
+      Diff::LCS.patch(s1, patch_set).should == s2
+    end
+
+    it "should correctly patch left-to-right (explicit patch)" do
+      Diff::LCS.patch(s1, patch_set, :patch).should == s2
+      Diff::LCS.patch!(s1, patch_set).should == s2
+    end
+
+    it "should correctly patch right-to-left (unpatch autodiscovery)" do
+      Diff::LCS.patch(s2, patch_set).should == s1
+    end
+
+    it "should correctly patch right-to-left (explicit unpatch)" do
+      Diff::LCS.patch(s2, patch_set, :unpatch).should == s1
+      Diff::LCS.unpatch!(s2, patch_set).should == s1
+    end
+  end
+
+  describe "using a Diff::LCS.diff patchset" do
+    describe "an empty patchset returns the source" do
+      it "works on a string (hello)" do
+        Diff::LCS::patch(hello, Diff::LCS.diff(hello, hello)).should == hello
+      end
+
+      it "works on an array %W(h e l l o)" do
+        Diff::LCS::patch(hello_ary, Diff::LCS.diff(hello_ary, hello_ary)).should == hello_ary
+      end
+    end
+
+    describe "with default diff callbacks (DiffCallbacks)" do
+      describe "forward (s1 -> s2)" do
+        it_has_behavior "patch sequences correctly" do
+          let(:s1) { seq1 }
+          let(:s2) { seq2 }
+          let(:patch_set) { Diff::LCS.diff(seq1, seq2) }
+        end
+      end
+
+      describe "reverse (s2 -> s1)" do
+        it_has_behavior "patch sequences correctly" do
+          let(:s1) { seq2 }
+          let(:s2) { seq1 }
+          let(:patch_set) { Diff::LCS.diff(seq2, seq1) }
+        end
+      end
+    end
+
+    describe "with context diff callbacks (ContextDiffCallbacks)" do
+      describe "forward (s1 -> s2)" do
+        it_has_behavior "patch sequences correctly" do
+          let(:s1) { seq1 }
+          let(:s2) { seq2 }
+          let(:patch_set) {
+            Diff::LCS.diff(seq1, seq2, Diff::LCS::ContextDiffCallbacks)
+          }
+        end
+      end
+
+      describe "reverse (s2 -> s1)" do
+        it_has_behavior "patch sequences correctly" do
+          let(:s1) { seq2 }
+          let(:s2) { seq1 }
+          let(:patch_set) {
+            Diff::LCS.diff(seq2, seq1, Diff::LCS::ContextDiffCallbacks)
+          }
+        end
+      end
+    end
+
+    describe "with sdiff callbacks (SDiffCallbacks)" do
+      describe "forward (s1 -> s2)" do
+        it_has_behavior "patch sequences correctly" do
+          let(:s1) { seq1 }
+          let(:s2) { seq2 }
+          let(:patch_set) {
+            Diff::LCS.diff(seq1, seq2, Diff::LCS::SDiffCallbacks)
+          }
+        end
+      end
+
+      describe "reverse (s2 -> s1)" do
+        it_has_behavior "patch sequences correctly" do
+          let(:s1) { seq2 }
+          let(:s2) { seq1 }
+          let(:patch_set) {
+            Diff::LCS.diff(seq2, seq1, Diff::LCS::SDiffCallbacks)
+          }
+        end
+      end
+    end
+  end
+
+  describe "using a Diff::LCS.sdiff patchset" do
+    describe "an empty patchset returns the source" do
+      it "works on a string (hello)" do
+        Diff::LCS::patch(hello, Diff::LCS.sdiff(hello, hello)).should == hello
+      end
+
+      it "works on an array %W(h e l l o)" do
+        Diff::LCS::patch(hello_ary, Diff::LCS.sdiff(hello_ary, hello_ary)).should == hello_ary
+      end
+    end
+
+    describe "with default diff callbacks (DiffCallbacks)" do
+      describe "forward (s1 -> s2)" do
+        it_has_behavior "patch sequences correctly" do
+          let(:s1) { seq1 }
+          let(:s2) { seq2 }
+          let(:patch_set) {
+            Diff::LCS.sdiff(seq1, seq2, Diff::LCS::DiffCallbacks)
+          }
+        end
+      end
+
+      describe "reverse (s2 -> s1)" do
+        it_has_behavior "patch sequences correctly" do
+          let(:s1) { seq2 }
+          let(:s2) { seq1 }
+          let(:patch_set) {
+            Diff::LCS.sdiff(seq2, seq1, Diff::LCS::DiffCallbacks)
+          }
+        end
+      end
+    end
+
+    describe "with context diff callbacks (DiffCallbacks)" do
+      describe "forward (s1 -> s2)" do
+        it_has_behavior "patch sequences correctly" do
+          let(:s1) { seq1 }
+          let(:s2) { seq2 }
+          let(:patch_set) {
+            Diff::LCS.sdiff(seq1, seq2, Diff::LCS::ContextDiffCallbacks)
+          }
+        end
+      end
+
+      describe "reverse (s2 -> s1)" do
+        it_has_behavior "patch sequences correctly" do
+          let(:s1) { seq2 }
+          let(:s2) { seq1 }
+          let(:patch_set) {
+            Diff::LCS.sdiff(seq2, seq1, Diff::LCS::ContextDiffCallbacks)
+          }
+        end
+      end
+    end
+
+    describe "with sdiff callbacks (SDiffCallbacks)" do
+      describe "forward (s1 -> s2)" do
+        it_has_behavior "patch sequences correctly" do
+          let(:s1) { seq1 }
+          let(:s2) { seq2 }
+          let(:patch_set) { Diff::LCS.sdiff(seq1, seq2) }
+        end
+      end
+
+      describe "reverse (s2 -> s1)" do
+        it_has_behavior "patch sequences correctly" do
+          let(:s1) { seq2 }
+          let(:s2) { seq1 }
+          let(:patch_set) { Diff::LCS.sdiff(seq2, seq1) }
+        end
+      end
+    end
+  end
+
+  # Note: because of the error in autodiscovery ("does not autodiscover s1
+  # to s2 patches"), this cannot use the "patch sequences correctly" shared
+  # set. Once the bug in autodiscovery is fixed, this can be converted as
+  # above.
+  describe "fix bug 891: patchsets do not contain the last equal part" do
+    before(:each) 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)
+    end
+
+    describe "using Diff::LCS.diff with default diff callbacks" do
+      before(:each) do
+        @patch_set_s1_s2 = Diff::LCS.diff(@s1, @s2)
+        @patch_set_s2_s1 = Diff::LCS.diff(@s2, @s1)
+      end
+
+      it "should autodiscover s1 to s2 patches" do
+        expect do
+          Diff::LCS.patch(@s1, @patch_set_s1_s2).should == @s2
+        end.to_not raise_error(RuntimeError, /provided patchset/)
+      end
+
+      it "should autodiscover s2 to s1 patches" do
+        expect do
+          Diff::LCS.patch(@s1, @patch_set_s2_s1).should == @s2
+        end.to_not raise_error(RuntimeError, /provided patchset/)
+      end
+
+      it "should autodiscover s2 to s1 the left-to-right patches" do
+        Diff::LCS.patch(@s2, @patch_set_s2_s1).should == @s1
+        Diff::LCS.patch(@s2, @patch_set_s1_s2).should == @s1
+      end
+
+      it "should correctly patch left-to-right (explicit patch)" do
+        Diff::LCS.patch(@s1, @patch_set_s1_s2, :patch).should == @s2
+        Diff::LCS.patch(@s2, @patch_set_s2_s1, :patch).should == @s1
+        Diff::LCS.patch!(@s1, @patch_set_s1_s2).should == @s2
+        Diff::LCS.patch!(@s2, @patch_set_s2_s1).should == @s1
+      end
+
+      it "should correctly patch right-to-left (explicit unpatch)" do
+        Diff::LCS.patch(@s2, @patch_set_s1_s2, :unpatch).should == @s1
+        Diff::LCS.patch(@s1, @patch_set_s2_s1, :unpatch).should == @s2
+        Diff::LCS.unpatch!(@s2, @patch_set_s1_s2).should == @s1
+        Diff::LCS.unpatch!(@s1, @patch_set_s2_s1).should == @s2
+      end
+    end
+
+    describe "using Diff::LCS.diff with context diff callbacks" do
+      before(:each) do
+        @patch_set_s1_s2 = Diff::LCS.diff(@s1, @s2, Diff::LCS::ContextDiffCallbacks)
+        @patch_set_s2_s1 = Diff::LCS.diff(@s2, @s1, Diff::LCS::ContextDiffCallbacks)
+      end
+
+      it "should autodiscover s1 to s2 patches" do
+        expect do
+          Diff::LCS.patch(@s1, @patch_set_s1_s2).should == @s2
+        end.to_not raise_error(RuntimeError, /provided patchset/)
+      end
+
+      it "should autodiscover s2 to s1 patches" do
+        expect do
+          Diff::LCS.patch(@s1, @patch_set_s2_s1).should == @s2
+        end.to_not raise_error(RuntimeError, /provided patchset/)
+      end
+
+      it "should autodiscover s2 to s1 the left-to-right patches" do
+        Diff::LCS.patch(@s2, @patch_set_s2_s1).should == @s1
+        Diff::LCS.patch(@s2, @patch_set_s1_s2).should == @s1
+      end
+
+      it "should correctly patch left-to-right (explicit patch)" do
+        Diff::LCS.patch(@s1, @patch_set_s1_s2, :patch).should == @s2
+        Diff::LCS.patch(@s2, @patch_set_s2_s1, :patch).should == @s1
+        Diff::LCS.patch!(@s1, @patch_set_s1_s2).should == @s2
+        Diff::LCS.patch!(@s2, @patch_set_s2_s1).should == @s1
+      end
+
+      it "should correctly patch right-to-left (explicit unpatch)" do
+        Diff::LCS.patch(@s2, @patch_set_s1_s2, :unpatch).should == @s1
+        Diff::LCS.patch(@s1, @patch_set_s2_s1, :unpatch).should == @s2
+        Diff::LCS.unpatch!(@s2, @patch_set_s1_s2).should == @s1
+        Diff::LCS.unpatch!(@s1, @patch_set_s2_s1).should == @s2
+      end
+    end
+
+    describe "using Diff::LCS.diff with sdiff callbacks" do
+      before(:each) do
+        @patch_set_s1_s2 = Diff::LCS.diff(@s1, @s2, Diff::LCS::SDiffCallbacks)
+        @patch_set_s2_s1 = Diff::LCS.diff(@s2, @s1, Diff::LCS::SDiffCallbacks)
+      end
+
+      it "should autodiscover s1 to s2 patches" do
+        expect do
+          Diff::LCS.patch(@s1, @patch_set_s1_s2).should == @s2
+        end.to_not raise_error(RuntimeError, /provided patchset/)
+      end
+
+      it "should autodiscover s2 to s1 patches" do
+        expect do
+          Diff::LCS.patch(@s1, @patch_set_s2_s1).should == @s2
+        end.to_not raise_error(RuntimeError, /provided patchset/)
+      end
+
+      it "should autodiscover s2 to s1 the left-to-right patches" do
+        Diff::LCS.patch(@s2, @patch_set_s2_s1).should == @s1
+        Diff::LCS.patch(@s2, @patch_set_s1_s2).should == @s1
+      end
+
+      it "should correctly patch left-to-right (explicit patch)" do
+        Diff::LCS.patch(@s1, @patch_set_s1_s2, :patch).should == @s2
+        Diff::LCS.patch(@s2, @patch_set_s2_s1, :patch).should == @s1
+        Diff::LCS.patch!(@s1, @patch_set_s1_s2).should == @s2
+        Diff::LCS.patch!(@s2, @patch_set_s2_s1).should == @s1
+      end
+
+      it "should correctly patch right-to-left (explicit unpatch)" do
+        Diff::LCS.patch(@s2, @patch_set_s1_s2, :unpatch).should == @s1
+        Diff::LCS.patch(@s1, @patch_set_s2_s1, :unpatch).should == @s2
+        Diff::LCS.unpatch!(@s2, @patch_set_s1_s2).should == @s1
+        Diff::LCS.unpatch!(@s1, @patch_set_s2_s1).should == @s2
+      end
+    end
+
+    describe "using Diff::LCS.sdiff with default sdiff callbacks" do
+      before(:each) do
+        @patch_set_s1_s2 = Diff::LCS.sdiff(@s1, @s2)
+        @patch_set_s2_s1 = Diff::LCS.sdiff(@s2, @s1)
+      end
+
+      it "should autodiscover s1 to s2 patches" do
+        expect do
+          Diff::LCS.patch(@s1, @patch_set_s1_s2).should == @s2
+        end.to_not raise_error(RuntimeError, /provided patchset/)
+      end
+
+      it "should autodiscover s2 to s1 patches" do
+        expect do
+          Diff::LCS.patch(@s1, @patch_set_s2_s1).should == @s2
+        end.to_not raise_error(RuntimeError, /provided patchset/)
+      end
+
+      it "should autodiscover s2 to s1 the left-to-right patches" do
+        Diff::LCS.patch(@s2, @patch_set_s2_s1).should == @s1
+        Diff::LCS.patch(@s2, @patch_set_s1_s2).should == @s1
+      end
+
+      it "should correctly patch left-to-right (explicit patch)", :only => true do
+        Diff::LCS.patch(@s1, @patch_set_s1_s2, :patch).should == @s2
+        Diff::LCS.patch(@s2, @patch_set_s2_s1, :patch).should == @s1
+        Diff::LCS.patch!(@s1, @patch_set_s1_s2).should == @s2
+        Diff::LCS.patch!(@s2, @patch_set_s2_s1).should == @s1
+      end
+
+      it "should correctly patch right-to-left (explicit unpatch)" do
+        Diff::LCS.patch(@s2, @patch_set_s1_s2, :unpatch).should == @s1
+        Diff::LCS.patch(@s1, @patch_set_s2_s1, :unpatch).should == @s2
+        Diff::LCS.unpatch!(@s2, @patch_set_s1_s2).should == @s1
+        Diff::LCS.unpatch!(@s1, @patch_set_s2_s1).should == @s2
+      end
+    end
+
+    describe "using Diff::LCS.sdiff with context diff callbacks" do
+      before(:each) do
+        @patch_set_s1_s2 = Diff::LCS.sdiff(@s1, @s2, Diff::LCS::ContextDiffCallbacks)
+        @patch_set_s2_s1 = Diff::LCS.sdiff(@s2, @s1, Diff::LCS::ContextDiffCallbacks)
+      end
+
+      it "should autodiscover s1 to s2 patches" do
+        expect do
+          Diff::LCS.patch(@s1, @patch_set_s1_s2).should == @s2
+        end.to_not raise_error(RuntimeError, /provided patchset/)
+      end
+
+      it "should autodiscover s2 to s1 patches" do
+        expect do
+          Diff::LCS.patch(@s1, @patch_set_s2_s1).should == @s2
+        end.to_not raise_error(RuntimeError, /provided patchset/)
+      end
+
+      it "should autodiscover s2 to s1 the left-to-right patches" do
+        Diff::LCS.patch(@s2, @patch_set_s2_s1).should == @s1
+        Diff::LCS.patch(@s2, @patch_set_s1_s2).should == @s1
+      end
+
+      it "should correctly patch left-to-right (explicit patch)" do
+        Diff::LCS.patch(@s1, @patch_set_s1_s2, :patch).should == @s2
+        Diff::LCS.patch(@s2, @patch_set_s2_s1, :patch).should == @s1
+        Diff::LCS.patch!(@s1, @patch_set_s1_s2).should == @s2
+        Diff::LCS.patch!(@s2, @patch_set_s2_s1).should == @s1
+      end
+
+      it "should correctly patch right-to-left (explicit unpatch)" do
+        Diff::LCS.patch(@s2, @patch_set_s1_s2, :unpatch).should == @s1
+        Diff::LCS.patch(@s1, @patch_set_s2_s1, :unpatch).should == @s2
+        Diff::LCS.unpatch!(@s2, @patch_set_s1_s2).should == @s1
+        Diff::LCS.unpatch!(@s1, @patch_set_s2_s1).should == @s2
+      end
+    end
+
+    describe "using Diff::LCS.sdiff with default diff callbacks" do
+      before(:each) do
+        @patch_set_s1_s2 = Diff::LCS.sdiff(@s1, @s2, Diff::LCS::DiffCallbacks)
+        @patch_set_s2_s1 = Diff::LCS.sdiff(@s2, @s1, Diff::LCS::DiffCallbacks)
+      end
+
+      it "should autodiscover s1 to s2 patches" do
+        expect do
+          Diff::LCS.patch(@s1, @patch_set_s1_s2).should == @s2
+        end.to_not raise_error(RuntimeError, /provided patchset/)
+      end
+
+      it "should autodiscover s2 to s1 patches" do
+        expect do
+          Diff::LCS.patch(@s1, @patch_set_s2_s1).should == @s2
+        end.to_not raise_error(RuntimeError, /provided patchset/)
+      end
+
+      it "should autodiscover s2 to s1 the left-to-right patches" do
+        Diff::LCS.patch(@s2, @patch_set_s2_s1).should == @s1
+        Diff::LCS.patch(@s2, @patch_set_s1_s2).should == @s1
+      end
+
+      it "should correctly patch left-to-right (explicit patch)" do
+        Diff::LCS.patch(@s1, @patch_set_s1_s2, :patch).should == @s2
+        Diff::LCS.patch(@s2, @patch_set_s2_s1, :patch).should == @s1
+        Diff::LCS.patch!(@s1, @patch_set_s1_s2).should == @s2
+        Diff::LCS.patch!(@s2, @patch_set_s2_s1).should == @s1
+      end
+
+      it "should correctly patch right-to-left (explicit unpatch)" do
+        Diff::LCS.patch(@s2, @patch_set_s1_s2, :unpatch).should == @s1
+        Diff::LCS.patch(@s1, @patch_set_s2_s1, :unpatch).should == @s2
+        Diff::LCS.unpatch!(@s2, @patch_set_s1_s2).should == @s1
+        Diff::LCS.unpatch!(@s1, @patch_set_s2_s1).should == @s2
+      end
+    end
+  end
+end