berkeley_library-tind 0.4.1 → 0.4.2

data/spec/berkeley_library/util/arrays_spec.rb

@@ -1,340 +0,0 @@
-require 'spec_helper'
-
-require 'berkeley_library/util/arrays'
-
-module BerkeleyLibrary::Util
-  describe Arrays do
-    describe :ordered_superset do
-      let(:sup) { %w[a b c d e] }
-
-      it 'returns true for an identical subset' do
-        expect(Arrays.ordered_superset?(superset: sup, subset: sup.dup)).to eq(true)
-      end
-
-      it 'returns true for an empty subset' do
-        expect(Arrays.ordered_superset?(superset: sup, subset: [])).to eq(true)
-      end
-
-      it 'returns true for an exact sublist' do
-        subs = [
-          %w[a b c],
-          %w[b c d],
-          %w[c d e]
-        ]
-        subs.each do |sub|
-          expect(Arrays.ordered_superset?(superset: sup, subset: sub)).to eq(true)
-        end
-      end
-
-      it 'returns true when the superset interpolates extra elements' do
-        subs = [
-          %w[a c e],
-          %w[b d],
-          %w[a b d e]
-        ]
-        subs.each do |sub|
-          expect(Arrays.ordered_superset?(superset: sup, subset: sub)).to eq(true)
-        end
-      end
-
-      it 'returns false for a too-large subset' do
-        sub = %w[a b c d e f g]
-        expect(Arrays.ordered_superset?(superset: sup, subset: sub)).to eq(false)
-      end
-
-      it 'returns false when extra elements are present' do
-        subs = [
-          %w[a b c x],
-          %w[x b c d],
-          %w[c d x e]
-        ]
-        subs.each do |sub|
-          expect(Arrays.ordered_superset?(superset: sup, subset: sub)).to eq(false)
-        end
-      end
-    end
-
-    describe :count_while do
-      it 'returns the count of matching elements' do
-        a = [1, 3, 5, 2, 4, 6, 7, 11, 13]
-        expect(Arrays.count_while(values: a, &:odd?)).to eq(3)
-      end
-
-      it 'returns 0 if the first element does not match' do
-        a = [2, 4, 6, 7, 11, 13]
-        expect(Arrays.count_while(values: a, &:odd?)).to eq(0)
-      end
-
-      it 'returns an enumerator if not passed a block' do
-        a = [1, 3, 5, 2, 4, 6, 7, 11, 13]
-        e = Arrays.count_while(values: a)
-        expect(e.each(&:odd?)).to eq(3)
-      end
-
-      it 'works on non-arrays' do
-        a = [1, 3, 5, 2, 4, 6, 7, 11, 13]
-        e = Enumerator.new { |y| a.each { |x| y << x } }
-        expect(Arrays.count_while(values: e, &:odd?)).to eq(3)
-      end
-    end
-
-    describe :find_indices do
-      let(:target) { %w[a b c d e] }
-
-      it 'returns identity indices for an identical subset' do
-        expect(Arrays.find_indices(for_array: target.dup, in_array: target)).to eq([0, 1, 2, 3, 4])
-      end
-
-      it 'returns an empty array for an empty subset' do
-        expect(Arrays.find_indices(for_array: [], in_array: target)).to eq([])
-      end
-
-      it 'returns the expected subindices for an exact sublist' do
-        sources = {
-          %w[a b c] => [0, 1, 2],
-          %w[b c d] => [1, 2, 3],
-          %w[c d e] => [2, 3, 4]
-        }
-        sources.each do |source, expected|
-          expect(Arrays.find_indices(for_array: source, in_array: target)).to eq(expected)
-        end
-      end
-
-      it 'returns nil for a too-large subset' do
-        source = %w[a b c d e f g]
-        expect(Arrays.find_indices(for_array: source, in_array: target)).to be_nil
-      end
-
-      it 'returns nil when extra elements are present' do
-        sources = [
-          %w[a b c x],
-          %w[x b c d],
-          %w[c d x e]
-        ]
-        sources.each do |source|
-          expect(Arrays.find_indices(for_array: source, in_array: target)).to be_nil
-        end
-      end
-
-      it 'takes a comparison block' do
-        sub = %i[a c e]
-        expect(Arrays.find_indices(for_array: sub, in_array: target) { |source, target| target == source.to_s }).to eq([0, 2, 4])
-      end
-    end
-
-    describe :find_index do
-      let(:arr) { [0, 2, 4, 6, 4] }
-
-      it 'finds an index based on a value' do
-        expect(Arrays.find_index(4, in_array: arr)).to eq(2)
-        expect(Arrays.find_index(4, in_array: arr, start_index: 3)).to eq(4)
-      end
-
-      it 'finds an index based on a block' do
-        expect(Arrays.find_index(in_array: arr) { |x| x > 3 }).to eq(2)
-        expect(Arrays.find_index(in_array: arr, start_index: 3) { |x| x < 5 }).to eq(4)
-      end
-
-      it 'returns nil if no equal value found' do
-        expect(Arrays.find_index(7, in_array: arr)).to be_nil
-        expect(Arrays.find_index(2, in_array: arr, start_index: 2)).to be_nil
-      end
-
-      it 'returns nil if no matching value found' do
-        expect(Arrays.find_index(in_array: arr, &:odd?)).to be_nil
-        expect(Arrays.find_index(in_array: arr, start_index: 2) { |x| x < 4 }).to be_nil
-      end
-
-      # rubocop:disable Lint/Void
-      it 'returns an enumerator if given no arguments' do
-        e = Arrays.find_index(in_array: arr)
-        expect(e.each { |x| x > 3 }).to eq(2)
-
-        e = Arrays.find_index(in_array: arr, start_index: 3)
-        expect(e.each { |x| x < 5 }).to eq(4)
-      end
-      # rubocop:enable Lint/Void
-    end
-
-    describe :merge do
-      it 'merges two arrays' do
-        a1 = [1, 2, 3]
-        a2 = [2, 3, 4]
-        expect(Arrays.merge(a1, a2)).to eq([1, 2, 3, 4])
-        expect(Arrays.merge(a2, a1)).to eq([1, 2, 3, 4])
-      end
-
-      it 'merges disjoint arrays' do
-        a1 = [1, 3, 5]
-        a2 = [2, 4, 6]
-        expect(Arrays.merge(a1, a2)).to eq([1, 3, 5, 2, 4, 6])
-      end
-
-      it 'preserves duplicates' do
-        a1 = [1, 2, 2, 3, 4, 5]
-        a2 = [2, 4, 4, 5, 5, 6]
-
-        merged = Arrays.merge(a1, a2)
-        [a1, a2].each do |a|
-          expect(Arrays.ordered_superset?(superset: merged, subset: a)).to eq(true), "merge(#{[a1.join, a2.join].inspect}): #{a.join} not found in #{merged.join}"
-        end
-
-        expected = [1, 2, 2, 3, 4, 4, 5, 5, 6]
-        expect(merged.size).to eq(expected.size)
-        expect(merged).to eq(expected)
-      end
-
-      it 'merges gappy arrays' do
-        a1 = [1, 4, 5, 7, 9]
-        a2 = [2, 3, 4, 7, 8, 9]
-
-        merged = Arrays.merge(a1, a2)
-        [a1, a2].each do |a|
-          expect(Arrays.ordered_superset?(superset: merged, subset: a)).to eq(true), "merge(#{[a1.join, a2.join].inspect}): #{a.join} not found in #{merged.join}"
-        end
-
-        expected = [1, 2, 3, 4, 5, 7, 8, 9]
-        expect(merged.size).to eq(expected.size)
-        expect(merged).to eq(expected)
-      end
-
-      it 'preserves order when merging arrays with duplicates' do
-        a1 = [1, 3, 2, 2, 4]
-        a2 = [1, 2, 3, 2, 4]
-
-        merged = Arrays.merge(a1, a2)
-        [a1, a2].each do |a|
-          expect(Arrays.ordered_superset?(superset: merged, subset: a)).to eq(true), "merge(#{[a1.join, a2.join].inspect}): #{a.join} not found in #{merged.join}"
-        end
-
-        expected = [1, 2, 3, 2, 2, 4]
-        expect(merged.size).to eq(expected.size)
-        expect(merged).to eq(expected)
-      end
-
-      it 'preserves nil' do
-        a1 = [1, 3, nil, nil, 4]
-        a2 = [1, nil, 3, nil, 4]
-
-        merged = Arrays.merge(a1, a2)
-        [a1, a2].each do |a|
-          expect(Arrays.ordered_superset?(superset: merged, subset: a)).to eq(true), "merge(#{[a1.join, a2.join].inspect}): #{a.join} not found in #{merged.join}"
-        end
-
-        expected = [1, nil, 3, nil, nil, 4]
-        expect(merged.size).to eq(expected.size)
-        expect(merged).to eq(expected)
-      end
-
-      it 'works with non-comparable types' do
-        a1 = [1, 3, 'two', 'two', 4]
-        a2 = [1, 'two', 3, 'two', 4]
-
-        merged = Arrays.merge(a1, a2)
-        [a1, a2].each do |a|
-          expect(Arrays.ordered_superset?(superset: merged, subset: a)).to eq(true), "merge(#{[a1.join, a2.join].inspect}): #{a.join} not found in #{merged.join}"
-        end
-
-        expected = [1, 'two', 3, 'two', 'two', 4]
-        expect(merged.size).to eq(expected.size)
-        expect(merged).to eq(expected)
-      end
-
-      it 'returns the larger array if the smaller is already a subarray' do
-        a1 = [2, 3, 4]
-        a2 = [1, 2, 3, 4, 5]
-
-        merged = Arrays.merge(a1, a2)
-        [a1, a2].each do |a|
-          expect(Arrays.ordered_superset?(superset: merged, subset: a)).to eq(true), "merge(#{[a1.join, a2.join].inspect}): #{a.join} not found in #{merged.join}"
-        end
-
-        expected = a2
-        expect(merged.size).to eq(expected.size)
-        expect(merged).to eq(expected)
-
-        expect(Arrays.merge(a2, a1)).to eq(expected)
-      end
-
-      it 'sorts where sorting preserves order' do
-        a1 = [1, 2, 3, 4, 5]
-        a2 = [2, 3, 6, 9]
-
-        merged = Arrays.merge(a1, a2)
-        [a1, a2].each do |a|
-          expect(Arrays.ordered_superset?(superset: merged, subset: a)).to eq(true), "merge(#{[a1.join, a2.join].inspect}): #{a.join} not found in #{merged.join}"
-        end
-
-        expected = [1, 2, 3, 4, 5, 6, 9]
-        expect(merged.size).to eq(expected.size)
-        expect(merged).to eq(expected)
-
-        expect(Arrays.merge(a2, a1)).to eq(expected)
-      end
-
-      it "doesn't muck up partial matches" do
-        a1 = [1, 2, 3, 4, 5]
-        a2 = [6, 9, 2, 3]
-
-        merged = Arrays.merge(a1, a2)
-        [a1, a2].each do |a|
-          expect(Arrays.ordered_superset?(superset: merged, subset: a)).to eq(true), "merge(#{[a1.join, a2.join].inspect}): #{a.join} not found in #{merged.join}"
-        end
-
-        expected = [1, 6, 9, 2, 3, 4, 5]
-        expect(merged.size).to eq(expected.size)
-        expect(merged).to eq(expected)
-
-        expect(Arrays.merge(a2, a1)).to eq(expected)
-      end
-
-      it "doesn't much up disjoints" do
-        a1 = [1, 2, 3, 4, 5]
-        a2 = [6, 9]
-
-        merged = Arrays.merge(a1, a2)
-        [a1, a2].each do |a|
-          expect(Arrays.ordered_superset?(superset: merged, subset: a)).to eq(true), "merge(#{[a1.join, a2.join].inspect}): #{a.join} not found in #{merged.join}"
-        end
-
-        expected = [1, 2, 3, 4, 5, 6, 9]
-        expect(merged.size).to eq(expected.size)
-        expect(merged).to eq(expected)
-
-        expect(Arrays.merge(a2, a1)).to eq(expected)
-      end
-
-      it 'works on a selection of random values' do
-        next_int = ->(n) { (n * rand).to_i }
-        rand_array = -> { (0...next_int.call(10)).map { next_int.call(10) } }
-        aggregate_failures 'random values' do
-          100.times do
-            a1 = rand_array.call
-            a2 = rand_array.call
-
-            merged = Arrays.merge(a1, a2)
-            [a1, a2].each do |a|
-              expect(Arrays.ordered_superset?(superset: merged, subset: a)).to eq(true), "merge(#{[a1.join, a2.join].inspect}): #{a.join} not found in #{merged.join}"
-            end
-          end
-        end
-      end
-
-    end
-
-    describe :invert do
-      it 'inverts an array of ints' do
-        expect(Arrays.invert([0, 2, 3])).to eq([0, nil, 1, 2])
-      end
-
-      it 'fails if values are not ints' do
-        # noinspection RubyYardParamTypeMatch
-        expect { Arrays.invert(%i[a b c]) }.to raise_error(TypeError)
-      end
-
-      it 'fails if given duplicate values' do
-        expect { Arrays.invert([1, 2, 3, 2]) }.to raise_error(ArgumentError)
-      end
-    end
-  end
-end

data/spec/berkeley_library/util/paths_spec.rb

@@ -1,90 +0,0 @@
-require 'spec_helper'
-require 'berkeley_library/util/paths'
-
-module BerkeleyLibrary::Util
-  describe Paths do
-    describe :clean do
-      {
-        # nil
-        nil => nil,
-
-        # Already clean
-        '' => '.',
-        'abc' => 'abc',
-        'abc/def' => 'abc/def',
-        'a/b/c' => 'a/b/c',
-        '.' => '.',
-        '..' => '..',
-        '../..' => '../..',
-        '../../abc' => '../../abc',
-        '/abc' => '/abc',
-        '/' => '/',
-
-        # Remove trailing slash
-        'abc/' => 'abc',
-        'abc/def/' => 'abc/def',
-        'a/b/c/' => 'a/b/c',
-        './' => '.',
-        '../' => '..',
-        '../../' => '../..',
-        '/abc/' => '/abc',
-
-        # Remove doubled slash
-        'abc//def//ghi' => 'abc/def/ghi',
-        '//abc' => '/abc',
-        '///abc' => '/abc',
-        '//abc//' => '/abc',
-        'abc//' => 'abc',
-
-        # Remove . elements
-        'abc/./def' => 'abc/def',
-        '/./abc/def' => '/abc/def',
-        'abc/.' => 'abc',
-
-        # Remove .. elements
-        'abc/def/ghi/../jkl' => 'abc/def/jkl',
-        'abc/def/../ghi/../jkl' => 'abc/jkl',
-        'abc/def/..' => 'abc',
-        'abc/def/../..' => '.',
-        '/abc/def/../..' => '/',
-        'abc/def/../../..' => '..',
-        '/abc/def/../../..' => '/',
-        'abc/def/../../../ghi/jkl/../../../mno' => '../../mno',
-
-        # Combinations
-        'abc/./../def' => 'def',
-        'abc//./../def' => 'def',
-        'abc/../../././../def' => '../../def'
-      }.each do |orig, expected|
-        it "clean(#{orig.inspect}) -> #{expected.inspect}" do
-          expect(Paths.clean(orig)).to eq(expected)
-        end
-      end
-    end
-
-    describe :join do
-      {
-        # zero parameters
-        [] => '',
-
-        # one parameter
-        [''] => '',
-        ['a'] => 'a',
-
-        # two parameters
-        ['a', 'b'] => 'a/b',
-        ['a', ''] => 'a',
-        ['', 'b'] => 'b',
-        ['/', 'a'] => '/a',
-        ['/', ''] => '/',
-        ['a/', 'b'] => 'a/b',
-        ['a/', ''] => 'a',
-        ['', ''] => ''
-      }.each do |orig, expected|
-        it "join(#{orig.map(&:inspect).join(', ')}) -> #{expected.inspect}" do
-          expect(Paths.join(*orig)).to eq(expected)
-        end
-      end
-    end
-  end
-end

data/spec/berkeley_library/util/stringios_spec.rb

@@ -1,34 +0,0 @@
-require 'spec_helper'
-
-require 'berkeley_library/util/stringios'
-
-module BerkeleyLibrary
-  module Util
-    describe StringIOs do
-      describe :getbyte do
-        let(:s) { '祇園精舎の鐘の声、諸行無常の響きあり。' }
-        let(:bytes) { s.bytes }
-        let(:sio) { StringIO.new(s) }
-
-        it 'gets the byte at the specified byte index' do
-          bytes.each_with_index do |b, i|
-            expect(StringIOs.getbyte(sio, i)).to eq(b)
-          end
-        end
-
-        it 'resets the current offset' do
-          StringIOs.getbyte(sio, bytes.size / 2)
-          expect(sio.pos).to eq(0)
-        end
-
-        it 'returns nil for a too-large positive offset' do
-          expect(StringIOs.getbyte(s, bytes.size)).to be_nil
-        end
-
-        it 'returns nil for a too-large negative offset' do
-          expect(StringIOs.getbyte(s, -(1 + bytes.size))).to be_nil
-        end
-      end
-    end
-  end
-end

data/spec/berkeley_library/util/strings_spec.rb

@@ -1,27 +0,0 @@
-require 'spec_helper'
-
-module BerkeleyLibrary
-  module Util
-    describe Strings do
-      describe :diff_index do
-        it 'returns nil for identical strings' do
-          s = 'elvis'
-          expect(Strings.diff_index(s, s)).to be_nil
-        end
-
-        it 'returns the index for different strings' do
-          s1 = 'elvis aaron presley'
-          s2 = 'elvis nikita presley'
-          expect(Strings.diff_index(s1, s2)).to eq(6)
-        end
-
-        it 'returns the length of the shorter string for prefixes' do
-          s1 = 'elvis'
-          s2 = 'elvis aaron presley'
-          expect(Strings.diff_index(s1, s2)).to eq(5)
-          expect(Strings.diff_index(s2, s1)).to eq(5)
-        end
-      end
-    end
-  end
-end

data/spec/berkeley_library/util/times_spec.rb

@@ -1,39 +0,0 @@
-require 'spec_helper'
-require 'berkeley_library/util/times'
-
-module BerkeleyLibrary
-  module Util
-    describe Times do
-      describe :ensure_utc do
-        it 'returns a UTC time unchanged' do
-          time = Time.parse('2021-02-05 16:19:11.37707 -0800')
-          utc_time = time.getutc
-          expect(Times.ensure_utc(utc_time)).to be(utc_time)
-        end
-
-        it 'converts a non-UTC time' do
-          time = Time.parse('2021-02-06 08:19:11.37707 +0800')
-          expect(Times.ensure_utc(time)).to eq(time.getutc)
-          expect(time.gmt_offset).to eq(28_800), 'Times.ensure_utc() should not modify its argument'
-        end
-
-        it 'accepts a Date' do
-          date = Date.new(2021, 2, 6)
-          utc_time = Time.new(2021, 2, 6).getutc
-          expect(Times.ensure_utc(date)).to eq(utc_time)
-        end
-
-        it 'accepts a Datetime' do
-          datetime = DateTime.parse('2021-02-05 16:19:11.37707 -0800')
-          utc_time = Time.parse('2021-02-06 00:19:11.37707 UTC')
-          expect(Times.ensure_utc(datetime)).to eq(utc_time)
-        end
-
-        it 'rejects non-date/time objects' do
-          # noinspection RubyYardParamTypeMatch
-          expect { Times.ensure_utc(Object.new) }.to raise_error(ArgumentError)
-        end
-      end
-    end
-  end
-end

data/spec/berkeley_library/util/uris_spec.rb

@@ -1,118 +0,0 @@
-require 'spec_helper'
-
-module BerkeleyLibrary::Util
-  describe URIs do
-    describe :append do
-      it 'appends paths' do
-        original_uri = URI('https://example.org/foo/bar')
-        new_uri = URIs.append(original_uri, 'qux', 'corge', 'garply')
-        expect(new_uri).to eq(URI('https://example.org/foo/bar/qux/corge/garply'))
-      end
-
-      it 'does not modify the original URI' do
-        original_uri = URI('https://example.org/foo/bar')
-        original_url = original_uri.to_s
-        new_uri = URIs.append(original_uri, 'qux', 'corge', 'garply')
-        expect(new_uri).not_to be(original_uri)
-        expect(original_uri.to_s).to eq(original_url)
-      end
-
-      it 'removes extraneous slashes' do
-        original_uri = URI('https://example.org/foo/bar')
-        new_uri = URIs.append(original_uri, '/qux', '/corge/', '//garply')
-        expect(new_uri).to eq(URI('https://example.org/foo/bar/qux/corge/garply'))
-      end
-
-      it 'preserves queries' do
-        original_uri = URI('https://example.org/foo/bar?baz=qux')
-        new_uri = URIs.append(original_uri, '/qux', '/corge/', '//garply')
-        expect(new_uri).to eq(URI('https://example.org/foo/bar/qux/corge/garply?baz=qux'))
-      end
-
-      it 'preserves fragments' do
-        original_uri = URI('https://example.org/foo/bar#baz')
-        new_uri = URIs.append(original_uri, '/qux', '/corge/', '//garply')
-        expect(new_uri).to eq(URI('https://example.org/foo/bar/qux/corge/garply#baz'))
-      end
-
-      it 'accepts a query string if no previous query present' do
-        original_uri = URI('https://example.org/foo/bar#baz')
-        new_uri = URIs.append(original_uri, '/qux', '/corge/', '//garply?grault=xyzzy')
-        expect(new_uri).to eq(URI('https://example.org/foo/bar/qux/corge/garply?grault=xyzzy#baz'))
-      end
-
-      it 'allows the ? to be passed separately' do
-        original_uri = URI('https://example.org/foo/bar#baz')
-        new_uri = URIs.append(original_uri, '/qux', '/corge/', '//garply', '?', 'grault=xyzzy')
-        expect(new_uri).to eq(URI('https://example.org/foo/bar/qux/corge/garply?grault=xyzzy#baz'))
-      end
-
-      it 'appends query parameters with &' do
-        original_uri = URI('https://example.org/foo/bar#baz')
-        new_uri = URIs.append(original_uri, '/qux', '/corge/', '//garply?grault=xyzzy', '&plugh=flob')
-        expect(new_uri).to eq(URI('https://example.org/foo/bar/qux/corge/garply?grault=xyzzy&plugh=flob#baz'))
-      end
-
-      it 'appends query parameters to original URI query' do
-        original_uri = URI('https://example.org/foo/bar/qux/corge/garply?grault=xyzzy')
-        new_uri = URIs.append(original_uri, '&plugh=flob')
-        expect(new_uri).to eq(URI('https://example.org/foo/bar/qux/corge/garply?grault=xyzzy&plugh=flob'))
-      end
-
-      it 'treats & as a path element if no query is present' do
-        original_uri = URI('https://example.org/foo/bar#baz')
-        new_uri = URIs.append(original_uri, '/qux', '/corge/', 'garply', '&plugh=flob')
-        expect(new_uri).to eq(URI('https://example.org/foo/bar/qux/corge/garply/&plugh=flob#baz'))
-      end
-
-      it 'accepts a fragment if no previous fragment present' do
-        original_uri = URI('https://example.org/foo/bar?baz=qux')
-        new_uri = URIs.append(original_uri, '/qux', '/corge/', '//garply#grault')
-        expect(new_uri).to eq(URI('https://example.org/foo/bar/qux/corge/garply?baz=qux#grault'))
-      end
-
-      it 'rejects a query string if the original URI already has one' do
-        original_uri = URI('https://example.org/foo/bar?baz=qux')
-        expect { URIs.append(original_uri, '/qux?corge') }.to raise_error(URI::InvalidComponentError)
-      end
-
-      it 'rejects a fragment if the original URI already has one' do
-        original_uri = URI('https://example.org/foo/bar#baz')
-        expect { URIs.append(original_uri, '/qux#corge') }.to raise_error(URI::InvalidComponentError)
-      end
-
-      it 'rejects appending multiple queries' do
-        original_uri = URI('https://example.org/foo/bar')
-        expect { URIs.append(original_uri, 'baz?qux=corge', 'grault?plugh=xyzzy') }.to raise_error(URI::InvalidComponentError)
-      end
-
-      it 'rejects appending multiple fragments' do
-        original_uri = URI('https://example.org/foo/bar')
-        expect { URIs.append(original_uri, 'baz#qux', 'grault#plugh') }.to raise_error(URI::InvalidComponentError)
-      end
-
-      it 'rejects queries after fragments' do
-        original_uri = URI('https://example.org/foo/bar')
-        expect { URIs.append(original_uri, 'baz#qux', '?grault=plugh') }.to raise_error(URI::InvalidComponentError)
-      end
-
-      it 'correctly handles fragments in mid-path-segment' do
-        original_uri = URI('https://example.org/foo/bar')
-        new_uri = URIs.append(original_uri, 'qux#corge')
-        expect(new_uri).to eq(URI('https://example.org/foo/bar/qux#corge'))
-      end
-
-      it 'correctly handles fragments in query start' do
-        original_uri = URI('https://example.org/foo/bar')
-        new_uri = URIs.append(original_uri, '?qux=corge&grault=plugh#xyzzy')
-        expect(new_uri).to eq(URI('https://example.org/foo/bar?qux=corge&grault=plugh#xyzzy'))
-      end
-
-      it 'correctly handles fragments in mid-query' do
-        original_uri = URI('https://example.org/foo/bar')
-        new_uri = URIs.append(original_uri, '?qux=corge', '&grault=plugh#xyzzy')
-        expect(new_uri).to eq(URI('https://example.org/foo/bar?qux=corge&grault=plugh#xyzzy'))
-      end
-    end
-  end
-end