coingecko_client 0.1.0

data/vendor/bundle/ruby/2.7.0/gems/diff-lcs-1.4.3/spec/fixtures/ldiff/output.diff-e

@@ -0,0 +1,3 @@
+1c
+bXaX
+.

data/vendor/bundle/ruby/2.7.0/gems/diff-lcs-1.4.3/spec/fixtures/ldiff/output.diff-f

@@ -0,0 +1,3 @@
+c1
+bXaX
+.

data/vendor/bundle/ruby/2.7.0/gems/diff-lcs-1.4.3/spec/fixtures/ldiff/output.diff-u

@@ -0,0 +1,5 @@
+--- spec/fixtures/aX	2019-02-01 22:29:34.000000000 -0500
++++ spec/fixtures/bXaX	2019-02-01 22:29:43.000000000 -0500
+@@ -1 +1 @@
+-aX
++bXaX

data/vendor/bundle/ruby/2.7.0/gems/diff-lcs-1.4.3/spec/hunk_spec.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+if String.method_defined?(:encoding)
+  require 'diff/lcs/hunk'
+
+  describe Diff::LCS::Hunk do
+    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 'produces a unified diff from the two pieces' do
+      expected = <<-EXPECTED.gsub(/^\s+/, '').encode('UTF-16LE').chomp
+        @@ -1 +1 @@
+        -Tu avec carté {count} itém has
+        +Tu avec carte {count} item has
+      EXPECTED
+
+      expect(hunk.diff(:unified)).to eq(expected)
+    end
+
+    it 'produces a context diff from the two pieces' do
+      expected = <<-EXPECTED.gsub(/^\s+/, '').encode('UTF-16LE').chomp
+        ***************
+        *** 1 ****
+        ! Tu avec carté {count} itém has
+        --- 1 ----
+        ! Tu avec carte {count} item has
+      EXPECTED
+
+      expect(hunk.diff(:context)).to eq(expected)
+    end
+
+    it 'produces an old diff from the two pieces' do
+      expected = <<-EXPECTED.gsub(/^ +/, '').encode('UTF-16LE').chomp
+        1c1
+        < Tu avec carté {count} itém has
+        ---
+        > Tu avec carte {count} item has
+
+      EXPECTED
+
+      expect(hunk.diff(:old)).to eq(expected)
+    end
+
+    it 'produces a reverse ed diff from the two pieces' do
+      expected = <<-EXPECTED.gsub(/^ +/, '').encode('UTF-16LE').chomp
+        c1
+        Tu avec carte {count} item has
+        .
+
+      EXPECTED
+
+      expect(hunk.diff(:reverse_ed)).to eq(expected)
+    end
+
+    context 'with empty first data set' do
+      let(:old_data) { [] }
+
+      it 'produces a unified diff' do
+        expected = <<-EXPECTED.gsub(/^\s+/, '').encode('UTF-16LE').chomp
+          @@ -1 +1,2 @@
+          +Tu avec carte {count} item has
+        EXPECTED
+
+        expect(hunk.diff(:unified)).to eq(expected)
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/2.7.0/gems/diff-lcs-1.4.3/spec/issues_spec.rb

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+require 'diff/lcs/hunk'
+
+describe 'Diff::LCS Issues' do
+  include Diff::LCS::SpecHelper::Matchers
+
+  describe 'issue #1' do
+    shared_examples 'handles simple diffs' do |s1, s2, forward_diff|
+      before do
+        @diff_s1_s2 = Diff::LCS.diff(s1, s2)
+      end
+
+      it 'creates the correct diff' do
+        expect(change_diff(forward_diff)).to eq(@diff_s1_s2)
+      end
+
+      it 'creates the correct patch s1->s2' do
+        expect(Diff::LCS.patch(s1, @diff_s1_s2)).to eq(s2)
+      end
+
+      it 'creates the correct patch s2->s1' do
+        expect(Diff::LCS.patch(s2, @diff_s1_s2)).to eq(s1)
+      end
+    end
+
+    describe 'string' do
+      it_has_behavior 'handles simple diffs', 'aX', 'bXaX', [
+        [
+          ['+', 0, 'b'],
+          ['+', 1, 'X']
+        ]
+      ]
+      it_has_behavior 'handles simple diffs', 'bXaX', 'aX', [
+        [
+          ['-', 0, 'b'],
+          ['-', 1, 'X']
+        ]
+      ]
+    end
+
+    describe 'array' do
+      it_has_behavior 'handles simple diffs', %w(a X), %w(b X a X), [
+        [
+          ['+', 0, 'b'],
+          ['+', 1, 'X']
+        ]
+      ]
+      it_has_behavior 'handles simple diffs', %w(b X a X), %w(a X), [
+        [
+          ['-', 0, 'b'],
+          ['-', 1, 'X']
+        ]
+      ]
+    end
+  end
+
+  describe "issue #57" do
+    it 'should fail with a correct error' do
+      expect {
+        actual = {:category=>"app.rack.request"}
+        expected = {:category=>"rack.middleware", :title=>"Anonymous Middleware"}
+        expect(actual).to eq(expected)
+      }.to raise_error(RSpec::Expectations::ExpectationNotMetError)
+    end
+  end
+
+  describe "issue #60" do
+    it 'should produce unified output with correct context' do
+      old_data = <<-DATA_OLD.strip.split("\n").map(&:chomp)
+{
+  "name": "x",
+  "description": "hi"
+}
+      DATA_OLD
+
+      new_data = <<-DATA_NEW.strip.split("\n").map(&:chomp)
+{
+  "name": "x",
+  "description": "lo"
+}
+      DATA_NEW
+
+      diff = ::Diff::LCS.diff(old_data, new_data)
+      hunk = ::Diff::LCS::Hunk.new(old_data, new_data, diff.first, 3, 0)
+
+      expect(hunk.diff(:unified)).to eq(<<-EXPECTED.chomp)
+@@ -1,5 +1,5 @@
+ {
+   "name": "x",
+-  "description": "hi"
++  "description": "lo"
+ }
+      EXPECTED
+    end
+  end
+end

data/vendor/bundle/ruby/2.7.0/gems/diff-lcs-1.4.3/spec/lcs_spec.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe Diff::LCS::Internals, '.lcs' do
+  include Diff::LCS::SpecHelper::Matchers
+
+  it 'returns 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.
+    expect(res.compact.size).to eq(correct_lcs.size)
+    expect(res).to 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
+
+    expect(x_seq1).to eq(correct_lcs)
+    expect(x_seq2).to eq(correct_lcs)
+  end
+
+  it 'returns all indexes with (hello, hello)' do
+    expect(Diff::LCS::Internals.lcs(hello, hello)).to \
+      eq((0...hello.size).to_a)
+  end
+
+  it 'returns all indexes with (hello_ary, hello_ary)' do
+    expect(Diff::LCS::Internals.lcs(hello_ary, hello_ary)).to \
+      eq((0...hello_ary.size).to_a)
+  end
+end
+
+describe Diff::LCS, '.LCS' do
+  include Diff::LCS::SpecHelper::Matchers
+
+  it 'returns the correct compacted values from Diff::LCS.LCS' do
+    res = Diff::LCS.LCS(seq1, seq2)
+    expect(res).to eq(correct_lcs)
+    expect(res.compact).to eq(res)
+  end
+
+  it 'is transitive' do
+    res = Diff::LCS.LCS(seq2, seq1)
+    expect(res).to eq(correct_lcs)
+    expect(res.compact).to eq(res)
+  end
+
+  it 'returns %W(h e l l o) with (hello, hello)' do
+    expect(Diff::LCS.LCS(hello, hello)).to eq(hello.split(//))
+  end
+
+  it 'returns hello_ary with (hello_ary, hello_ary)' do
+    expect(Diff::LCS.LCS(hello_ary, hello_ary)).to eq(hello_ary)
+  end
+end

data/vendor/bundle/ruby/2.7.0/gems/diff-lcs-1.4.3/spec/ldiff_spec.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe 'bin/ldiff' do
+  include CaptureSubprocessIO
+
+  let(:output_diff) { read_fixture }
+  let(:output_diff_c) { read_fixture('-c') }
+  let(:output_diff_e) { read_fixture('-e') }
+  let(:output_diff_f) { read_fixture('-f') }
+  let(:output_diff_u) { read_fixture('-u') }
+  let(:output_diff_chef) { read_fixture('-u', :base => 'output.diff.chef') }
+
+  specify do
+    expect(run_ldiff('-u', :left => 'old-chef', :right => 'new-chef')).to eq(output_diff_chef)
+  end
+
+  specify do
+    expect(run_ldiff).to eq(output_diff)
+  end
+
+  specify do
+    expect(run_ldiff('-c')).to eq(output_diff_c)
+  end
+
+  specify do
+    expect(run_ldiff('-e')).to eq(output_diff_e)
+  end
+
+  specify do
+    expect(run_ldiff('-f')).to eq(output_diff_f)
+  end
+
+  specify do
+    expect(run_ldiff('-u')).to eq(output_diff_u)
+  end
+
+  def read_fixture(flag = nil, options = {})
+    base = options.fetch(:base, 'output.diff')
+    name = "spec/fixtures/ldiff/#{base}#{flag}"
+    data = IO.__send__(IO.respond_to?(:binread) ? :binread : :read, name)
+    clean_data(data, flag)
+  end
+
+  def clean_data(data, flag)
+    data =
+      case flag
+      when '-c', '-u'
+        clean_output_timestamp(data)
+      else
+        data
+      end
+    data.gsub(/\r\n?/, "\n")
+  end
+
+  def clean_output_timestamp(data)
+    data.gsub(
+      %r{
+        ^
+        [-+*]{3}
+        \s*
+        spec/fixtures/(\S+)
+        \s*
+        \d{4}-\d\d-\d\d
+        \s*
+        \d\d:\d\d:\d\d(?:\.\d+)
+        \s*
+        (?:[-+]\d{4}|Z)
+      }x,
+      '*** spec/fixtures/\1	0000-00-00 00:00:00.000000000 -0000'
+    )
+  end
+
+  def run_ldiff(flag = nil, options = {})
+    left = options.fetch(:left, 'aX')
+    right = options.fetch(:right, 'bXaX')
+    stdout, stderr = capture_subprocess_io do
+      system("ruby -Ilib bin/ldiff #{flag} spec/fixtures/#{left} spec/fixtures/#{right}")
+    end
+
+    expect(stderr).to be_empty if RUBY_VERSION >= '1.9'
+    expect(stdout).not_to be_empty
+    clean_data(stdout, flag)
+  end
+end

data/vendor/bundle/ruby/2.7.0/gems/diff-lcs-1.4.3/spec/patch_spec.rb

@@ -0,0 +1,416 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe 'Diff::LCS.patch' do
+  include Diff::LCS::SpecHelper::Matchers
+
+  shared_examples 'patch sequences correctly' do
+    it 'correctly patches left-to-right (patch autodiscovery)' do
+      expect(Diff::LCS.patch(s1, patch_set)).to eq(s2)
+    end
+
+    it 'correctly patches left-to-right (explicit patch)' do
+      expect(Diff::LCS.patch(s1, patch_set, :patch)).to eq(s2)
+      expect(Diff::LCS.patch!(s1, patch_set)).to eq(s2)
+    end
+
+    it 'correctly patches right-to-left (unpatch autodiscovery)' do
+      expect(Diff::LCS.patch(s2, patch_set)).to eq(s1)
+    end
+
+    it 'correctly patches right-to-left (explicit unpatch)' do
+      expect(Diff::LCS.patch(s2, patch_set, :unpatch)).to eq(s1)
+      expect(Diff::LCS.unpatch!(s2, patch_set)).to eq(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 = Diff::LCS.diff(hello, hello)
+        expect(Diff::LCS.patch(hello, diff)).to eq(hello)
+      end
+
+      it 'works on an array %W(h e l l o)' do
+        diff = Diff::LCS.diff(hello_ary, hello_ary)
+        expect(Diff::LCS.patch(hello_ary, diff)).to eq(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
+        expect(Diff::LCS.patch(hello, Diff::LCS.sdiff(hello, hello))).to eq(hello)
+      end
+
+      it 'works on an array %W(h e l l o)' do
+        expect(Diff::LCS.patch(hello_ary, Diff::LCS.sdiff(hello_ary, hello_ary))).to eq(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) # rubocop:disable Layout/SpaceInsideArrayPercentLiteral
+      @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 'autodiscovers s1 to s2 patches' do
+        expect do
+          expect(Diff::LCS.patch(@s1, @patch_set_s1_s2)).to eq(@s2)
+        end.to_not raise_error
+      end
+
+      it 'autodiscovers s2 to s1 patches' do
+        expect do
+          expect(Diff::LCS.patch(@s1, @patch_set_s2_s1)).to eq(@s2)
+        end.to_not raise_error
+      end
+
+      it 'autodiscovers s2 to s1 the left-to-right patches' do
+        expect(Diff::LCS.patch(@s2, @patch_set_s2_s1)).to eq(@s1)
+        expect(Diff::LCS.patch(@s2, @patch_set_s1_s2)).to eq(@s1)
+      end
+
+      it 'correctly patches left-to-right (explicit patch)' do
+        expect(Diff::LCS.patch(@s1, @patch_set_s1_s2, :patch)).to eq(@s2)
+        expect(Diff::LCS.patch(@s2, @patch_set_s2_s1, :patch)).to eq(@s1)
+        expect(Diff::LCS.patch!(@s1, @patch_set_s1_s2)).to eq(@s2)
+        expect(Diff::LCS.patch!(@s2, @patch_set_s2_s1)).to eq(@s1)
+      end
+
+      it 'correctly patches right-to-left (explicit unpatch)' do
+        expect(Diff::LCS.patch(@s2, @patch_set_s1_s2, :unpatch)).to eq(@s1)
+        expect(Diff::LCS.patch(@s1, @patch_set_s2_s1, :unpatch)).to eq(@s2)
+        expect(Diff::LCS.unpatch!(@s2, @patch_set_s1_s2)).to eq(@s1)
+        expect(Diff::LCS.unpatch!(@s1, @patch_set_s2_s1)).to eq(@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 'autodiscovers s1 to s2 patches' do
+        expect do
+          expect(Diff::LCS.patch(@s1, @patch_set_s1_s2)).to eq(@s2)
+        end.to_not raise_error
+      end
+
+      it 'autodiscovers s2 to s1 patches' do
+        expect do
+          expect(Diff::LCS.patch(@s1, @patch_set_s2_s1)).to eq(@s2)
+        end.to_not raise_error
+      end
+
+      it 'autodiscovers s2 to s1 the left-to-right patches' do
+        expect(Diff::LCS.patch(@s2, @patch_set_s2_s1)).to eq(@s1)
+        expect(Diff::LCS.patch(@s2, @patch_set_s1_s2)).to eq(@s1)
+      end
+
+      it 'correctly patches left-to-right (explicit patch)' do
+        expect(Diff::LCS.patch(@s1, @patch_set_s1_s2, :patch)).to eq(@s2)
+        expect(Diff::LCS.patch(@s2, @patch_set_s2_s1, :patch)).to eq(@s1)
+        expect(Diff::LCS.patch!(@s1, @patch_set_s1_s2)).to eq(@s2)
+        expect(Diff::LCS.patch!(@s2, @patch_set_s2_s1)).to eq(@s1)
+      end
+
+      it 'correctly patches right-to-left (explicit unpatch)' do
+        expect(Diff::LCS.patch(@s2, @patch_set_s1_s2, :unpatch)).to eq(@s1)
+        expect(Diff::LCS.patch(@s1, @patch_set_s2_s1, :unpatch)).to eq(@s2)
+        expect(Diff::LCS.unpatch!(@s2, @patch_set_s1_s2)).to eq(@s1)
+        expect(Diff::LCS.unpatch!(@s1, @patch_set_s2_s1)).to eq(@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 'autodiscovers s1 to s2 patches' do
+        expect do
+          expect(Diff::LCS.patch(@s1, @patch_set_s1_s2)).to eq(@s2)
+        end.to_not raise_error
+      end
+
+      it 'autodiscovers s2 to s1 patches' do
+        expect do
+          expect(Diff::LCS.patch(@s1, @patch_set_s2_s1)).to eq(@s2)
+        end.to_not raise_error
+      end
+
+      it 'autodiscovers s2 to s1 the left-to-right patches' do
+        expect(Diff::LCS.patch(@s2, @patch_set_s2_s1)).to eq(@s1)
+        expect(Diff::LCS.patch(@s2, @patch_set_s1_s2)).to eq(@s1)
+      end
+
+      it 'correctly patches left-to-right (explicit patch)' do
+        expect(Diff::LCS.patch(@s1, @patch_set_s1_s2, :patch)).to eq(@s2)
+        expect(Diff::LCS.patch(@s2, @patch_set_s2_s1, :patch)).to eq(@s1)
+        expect(Diff::LCS.patch!(@s1, @patch_set_s1_s2)).to eq(@s2)
+        expect(Diff::LCS.patch!(@s2, @patch_set_s2_s1)).to eq(@s1)
+      end
+
+      it 'correctly patches right-to-left (explicit unpatch)' do
+        expect(Diff::LCS.patch(@s2, @patch_set_s1_s2, :unpatch)).to eq(@s1)
+        expect(Diff::LCS.patch(@s1, @patch_set_s2_s1, :unpatch)).to eq(@s2)
+        expect(Diff::LCS.unpatch!(@s2, @patch_set_s1_s2)).to eq(@s1)
+        expect(Diff::LCS.unpatch!(@s1, @patch_set_s2_s1)).to eq(@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 'autodiscovers s1 to s2 patches' do
+        expect do
+          expect(Diff::LCS.patch(@s1, @patch_set_s1_s2)).to eq(@s2)
+        end.to_not raise_error
+      end
+
+      it 'autodiscovers s2 to s1 patches' do
+        expect do
+          expect(Diff::LCS.patch(@s1, @patch_set_s2_s1)).to eq(@s2)
+        end.to_not raise_error
+      end
+
+      it 'autodiscovers s2 to s1 the left-to-right patches' do
+        expect(Diff::LCS.patch(@s2, @patch_set_s2_s1)).to eq(@s1)
+        expect(Diff::LCS.patch(@s2, @patch_set_s1_s2)).to eq(@s1)
+      end
+
+      it 'correctly patches left-to-right (explicit patch)' do
+        expect(Diff::LCS.patch(@s1, @patch_set_s1_s2, :patch)).to eq(@s2)
+        expect(Diff::LCS.patch(@s2, @patch_set_s2_s1, :patch)).to eq(@s1)
+        expect(Diff::LCS.patch!(@s1, @patch_set_s1_s2)).to eq(@s2)
+        expect(Diff::LCS.patch!(@s2, @patch_set_s2_s1)).to eq(@s1)
+      end
+
+      it 'correctly patches right-to-left (explicit unpatch)' do
+        expect(Diff::LCS.patch(@s2, @patch_set_s1_s2, :unpatch)).to eq(@s1)
+        expect(Diff::LCS.patch(@s1, @patch_set_s2_s1, :unpatch)).to eq(@s2)
+        expect(Diff::LCS.unpatch!(@s2, @patch_set_s1_s2)).to eq(@s1)
+        expect(Diff::LCS.unpatch!(@s1, @patch_set_s2_s1)).to eq(@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 'autodiscovers s1 to s2 patches' do
+        expect do
+          expect(Diff::LCS.patch(@s1, @patch_set_s1_s2)).to eq(@s2)
+        end.to_not raise_error
+      end
+
+      it 'autodiscovers s2 to s1 patches' do
+        expect do
+          expect(Diff::LCS.patch(@s1, @patch_set_s2_s1)).to eq(@s2)
+        end.to_not raise_error
+      end
+
+      it 'autodiscovers s2 to s1 the left-to-right patches' do
+        expect(Diff::LCS.patch(@s2, @patch_set_s2_s1)).to eq(@s1)
+        expect(Diff::LCS.patch(@s2, @patch_set_s1_s2)).to eq(@s1)
+      end
+
+      it 'correctly patches left-to-right (explicit patch)' do
+        expect(Diff::LCS.patch(@s1, @patch_set_s1_s2, :patch)).to eq(@s2)
+        expect(Diff::LCS.patch(@s2, @patch_set_s2_s1, :patch)).to eq(@s1)
+        expect(Diff::LCS.patch!(@s1, @patch_set_s1_s2)).to eq(@s2)
+        expect(Diff::LCS.patch!(@s2, @patch_set_s2_s1)).to eq(@s1)
+      end
+
+      it 'correctly patches right-to-left (explicit unpatch)' do
+        expect(Diff::LCS.patch(@s2, @patch_set_s1_s2, :unpatch)).to eq(@s1)
+        expect(Diff::LCS.patch(@s1, @patch_set_s2_s1, :unpatch)).to eq(@s2)
+        expect(Diff::LCS.unpatch!(@s2, @patch_set_s1_s2)).to eq(@s1)
+        expect(Diff::LCS.unpatch!(@s1, @patch_set_s2_s1)).to eq(@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 'autodiscovers s1 to s2 patches' do
+        expect do
+          expect(Diff::LCS.patch(@s1, @patch_set_s1_s2)).to eq(@s2)
+        end.to_not raise_error
+      end
+
+      it 'autodiscovers s2 to s1 patches' do
+        expect do
+          expect(Diff::LCS.patch(@s1, @patch_set_s2_s1)).to eq(@s2)
+        end.to_not raise_error
+      end
+
+      it 'autodiscovers s2 to s1 the left-to-right patches' do
+        expect(Diff::LCS.patch(@s2, @patch_set_s2_s1)).to eq(@s1)
+        expect(Diff::LCS.patch(@s2, @patch_set_s1_s2)).to eq(@s1)
+      end
+
+      it 'correctly patches left-to-right (explicit patch)' do
+        expect(Diff::LCS.patch(@s1, @patch_set_s1_s2, :patch)).to eq(@s2)
+        expect(Diff::LCS.patch(@s2, @patch_set_s2_s1, :patch)).to eq(@s1)
+        expect(Diff::LCS.patch!(@s1, @patch_set_s1_s2)).to eq(@s2)
+        expect(Diff::LCS.patch!(@s2, @patch_set_s2_s1)).to eq(@s1)
+      end
+
+      it 'correctly patches right-to-left (explicit unpatch)' do
+        expect(Diff::LCS.patch(@s2, @patch_set_s1_s2, :unpatch)).to eq(@s1)
+        expect(Diff::LCS.patch(@s1, @patch_set_s2_s1, :unpatch)).to eq(@s2)
+        expect(Diff::LCS.unpatch!(@s2, @patch_set_s1_s2)).to eq(@s1)
+        expect(Diff::LCS.unpatch!(@s1, @patch_set_s2_s1)).to eq(@s2)
+      end
+    end
+  end
+end