puppet 6.14.0 → 6.19.0

data/spec/unit/util/rpm_compare_spec.rb

@@ -0,0 +1,196 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+require 'puppet/util/rpm_compare'
+
+describe Puppet::Util::RpmCompare do
+  class RpmTest
+    extend Puppet::Util::RpmCompare
+  end
+
+  describe '.rpmvercmp' do
+    # test cases munged directly from rpm's own
+    # tests/rpmvercmp.at
+    it { expect(RpmTest.rpmvercmp('1.0', '1.0')).to eq(0) }
+    it { expect(RpmTest.rpmvercmp('1.0', '2.0')).to eq(-1) }
+    it { expect(RpmTest.rpmvercmp('2.0', '1.0')).to eq(1) }
+    it { expect(RpmTest.rpmvercmp('2.0.1', '2.0.1')).to eq(0) }
+    it { expect(RpmTest.rpmvercmp('2.0', '2.0.1')).to eq(-1) }
+    it { expect(RpmTest.rpmvercmp('2.0.1', '2.0')).to eq(1) }
+    it { expect(RpmTest.rpmvercmp('2.0.1a', '2.0.1a')).to eq(0) }
+    it { expect(RpmTest.rpmvercmp('2.0.1a', '2.0.1')).to eq(1) }
+    it { expect(RpmTest.rpmvercmp('2.0.1', '2.0.1a')).to eq(-1) }
+    it { expect(RpmTest.rpmvercmp('5.5p1', '5.5p1')).to eq(0) }
+    it { expect(RpmTest.rpmvercmp('5.5p1', '5.5p2')).to eq(-1) }
+    it { expect(RpmTest.rpmvercmp('5.5p2', '5.5p1')).to eq(1) }
+    it { expect(RpmTest.rpmvercmp('5.5p10', '5.5p10')).to eq(0) }
+    it { expect(RpmTest.rpmvercmp('5.5p1', '5.5p10')).to eq(-1) }
+    it { expect(RpmTest.rpmvercmp('5.5p10', '5.5p1')).to eq(1) }
+    it { expect(RpmTest.rpmvercmp('10xyz', '10.1xyz')).to eq(-1) }
+    it { expect(RpmTest.rpmvercmp('10.1xyz', '10xyz')).to eq(1) }
+    it { expect(RpmTest.rpmvercmp('xyz10', 'xyz10')).to eq(0) }
+    it { expect(RpmTest.rpmvercmp('xyz10', 'xyz10.1')).to eq(-1) }
+    it { expect(RpmTest.rpmvercmp('xyz10.1', 'xyz10')).to eq(1) }
+    it { expect(RpmTest.rpmvercmp('xyz.4', 'xyz.4')).to eq(0) }
+    it { expect(RpmTest.rpmvercmp('xyz.4', '8')).to eq(-1) }
+    it { expect(RpmTest.rpmvercmp('8', 'xyz.4')).to eq(1) }
+    it { expect(RpmTest.rpmvercmp('xyz.4', '2')).to eq(-1) }
+    it { expect(RpmTest.rpmvercmp('2', 'xyz.4')).to eq(1) }
+    it { expect(RpmTest.rpmvercmp('5.5p2', '5.6p1')).to eq(-1) }
+    it { expect(RpmTest.rpmvercmp('5.6p1', '5.5p2')).to eq(1) }
+    it { expect(RpmTest.rpmvercmp('5.6p1', '6.5p1')).to eq(-1) }
+    it { expect(RpmTest.rpmvercmp('6.5p1', '5.6p1')).to eq(1) }
+    it { expect(RpmTest.rpmvercmp('6.0.rc1', '6.0')).to eq(1) }
+    it { expect(RpmTest.rpmvercmp('6.0', '6.0.rc1')).to eq(-1) }
+    it { expect(RpmTest.rpmvercmp('10b2', '10a1')).to eq(1) }
+    it { expect(RpmTest.rpmvercmp('10a2', '10b2')).to eq(-1) }
+    it { expect(RpmTest.rpmvercmp('1.0aa', '1.0aa')).to eq(0) }
+    it { expect(RpmTest.rpmvercmp('1.0a', '1.0aa')).to eq(-1) }
+    it { expect(RpmTest.rpmvercmp('1.0aa', '1.0a')).to eq(1) }
+    it { expect(RpmTest.rpmvercmp('10.0001', '10.0001')).to eq(0) }
+    it { expect(RpmTest.rpmvercmp('10.0001', '10.1')).to eq(0) }
+    it { expect(RpmTest.rpmvercmp('10.1', '10.0001')).to eq(0) }
+    it { expect(RpmTest.rpmvercmp('10.0001', '10.0039')).to eq(-1) }
+    it { expect(RpmTest.rpmvercmp('10.0039', '10.0001')).to eq(1) }
+    it { expect(RpmTest.rpmvercmp('4.999.9', '5.0')).to eq(-1) }
+    it { expect(RpmTest.rpmvercmp('5.0', '4.999.9')).to eq(1) }
+    it { expect(RpmTest.rpmvercmp('20101121', '20101121')).to eq(0) }
+    it { expect(RpmTest.rpmvercmp('20101121', '20101122')).to eq(-1) }
+    it { expect(RpmTest.rpmvercmp('20101122', '20101121')).to eq(1) }
+    it { expect(RpmTest.rpmvercmp('2_0', '2_0')).to eq(0) }
+    it { expect(RpmTest.rpmvercmp('2.0', '2_0')).to eq(0) }
+    it { expect(RpmTest.rpmvercmp('2_0', '2.0')).to eq(0) }
+    it { expect(RpmTest.rpmvercmp('a', 'a')).to eq(0) }
+    it { expect(RpmTest.rpmvercmp('a+', 'a+')).to eq(0) }
+    it { expect(RpmTest.rpmvercmp('a+', 'a_')).to eq(0) }
+    it { expect(RpmTest.rpmvercmp('a_', 'a+')).to eq(0) }
+    it { expect(RpmTest.rpmvercmp('+a', '+a')).to eq(0) }
+    it { expect(RpmTest.rpmvercmp('+a', '_a')).to eq(0) }
+    it { expect(RpmTest.rpmvercmp('_a', '+a')).to eq(0) }
+    it { expect(RpmTest.rpmvercmp('+_', '+_')).to eq(0) }
+    it { expect(RpmTest.rpmvercmp('_+', '+_')).to eq(0) }
+    it { expect(RpmTest.rpmvercmp('_+', '_+')).to eq(0) }
+    it { expect(RpmTest.rpmvercmp('+', '_')).to eq(0) }
+    it { expect(RpmTest.rpmvercmp('_', '+')).to eq(0) }
+    it { expect(RpmTest.rpmvercmp('1.0~rc1', '1.0~rc1')).to eq(0) }
+    it { expect(RpmTest.rpmvercmp('1.0~rc1', '1.0')).to eq(-1) }
+    it { expect(RpmTest.rpmvercmp('1.0', '1.0~rc1')).to eq(1) }
+    it { expect(RpmTest.rpmvercmp('1.0~rc1', '1.0~rc2')).to eq(-1) }
+    it { expect(RpmTest.rpmvercmp('1.0~rc2', '1.0~rc1')).to eq(1) }
+    it { expect(RpmTest.rpmvercmp('1.0~rc1~git123', '1.0~rc1~git123')).to eq(0) }
+    it { expect(RpmTest.rpmvercmp('1.0~rc1~git123', '1.0~rc1')).to eq(-1) }
+    it { expect(RpmTest.rpmvercmp('1.0~rc1', '1.0~rc1~git123')).to eq(1) }
+    it { expect(RpmTest.rpmvercmp('1.0~rc1', '1.0arc1')).to eq(-1) }
+    it { expect(RpmTest.rpmvercmp('', '~')).to eq(1) }
+    it { expect(RpmTest.rpmvercmp('~', '~~')).to eq(1) }
+    it { expect(RpmTest.rpmvercmp('~', '~+~')).to eq(1) }
+    it { expect(RpmTest.rpmvercmp('~', '~a')).to eq(-1) }
+
+    # non-upstream test cases
+    it { expect(RpmTest.rpmvercmp('405', '406')).to eq(-1) }
+    it { expect(RpmTest.rpmvercmp('1', '0')).to eq(1) }
+  end
+
+  describe '.rpm_compareEVR' do
+    it 'evaluates identical version-release as equal' do
+      expect(RpmTest.rpm_compareEVR('1.2.3-1.el5', '1.2.3-1.el5')).to eq(0)
+    end
+
+    it 'evaluates identical version as equal' do
+      expect(RpmTest.rpm_compareEVR('1.2.3', '1.2.3')).to eq(0)
+    end
+
+    it 'evaluates identical version but older release as less' do
+      expect(RpmTest.rpm_compareEVR('1.2.3-1.el5', '1.2.3-2.el5')).to eq(-1)
+    end
+
+    it 'evaluates identical version but newer release as greater' do
+      expect(RpmTest.rpm_compareEVR('1.2.3-3.el5', '1.2.3-2.el5')).to eq(1)
+    end
+
+    it 'evaluates a newer epoch as greater' do
+      expect(RpmTest.rpm_compareEVR('1:1.2.3-4.5', '1.2.3-4.5')).to eq(1)
+    end
+
+    # these tests describe PUP-1244 logic yet to be implemented
+    it 'evaluates any version as equal to the same version followed by release' do
+      expect(RpmTest.rpm_compareEVR('1.2.3', '1.2.3-2.el5')).to eq(0)
+    end
+
+    # test cases for PUP-682
+    it 'evaluates same-length numeric revisions numerically' do
+      expect(RpmTest.rpm_compareEVR('2.2-405', '2.2-406')).to eq(-1)
+    end
+  end
+
+  describe '.rpm_parse_evr' do
+    it 'parses full simple evr' do
+      version = RpmTest.rpm_parse_evr('0:1.2.3-4.el5')
+      expect([version[:epoch], version[:version], version[:release]]).to \
+        eq(['0', '1.2.3', '4.el5'])
+    end
+
+    it 'parses version only' do
+      version = RpmTest.rpm_parse_evr('1.2.3')
+      expect([version[:epoch], version[:version], version[:release]]).to \
+        eq([nil, '1.2.3', nil])
+    end
+
+    it 'parses version-release' do
+      version = RpmTest.rpm_parse_evr('1.2.3-4.5.el6')
+      expect([version[:epoch], version[:version], version[:release]]).to \
+        eq([nil, '1.2.3', '4.5.el6'])
+    end
+
+    it 'parses release with git hash' do
+      version = RpmTest.rpm_parse_evr('1.2.3-4.1234aefd')
+      expect([version[:epoch], version[:version], version[:release]]).to \
+        eq([nil, '1.2.3', '4.1234aefd'])
+    end
+
+    it 'parses single integer versions' do
+      version = RpmTest.rpm_parse_evr('12345')
+      expect([version[:epoch], version[:version], version[:release]]).to \
+        eq([nil, '12345', nil])
+    end
+
+    it 'parses text in the epoch to 0' do
+      version = RpmTest.rpm_parse_evr('foo0:1.2.3-4')
+      expect([version[:epoch], version[:version], version[:release]]).to \
+        eq([nil, '1.2.3', '4'])
+    end
+
+    it 'parses revisions with text' do
+      version = RpmTest.rpm_parse_evr('1.2.3-SNAPSHOT20140107')
+      expect([version[:epoch], version[:version], version[:release]]).to \
+        eq([nil, '1.2.3', 'SNAPSHOT20140107'])
+    end
+
+    # test cases for PUP-682
+    it 'parses revisions with text and numbers' do
+      version = RpmTest.rpm_parse_evr('2.2-SNAPSHOT20121119105647')
+      expect([version[:epoch], version[:version], version[:release]]).to \
+        eq([nil, '2.2', 'SNAPSHOT20121119105647'])
+    end
+  end
+
+  describe '.compare_values' do
+    it 'treats two nil values as equal' do
+      expect(RpmTest.compare_values(nil, nil)).to eq(0)
+    end
+
+    it 'treats a nil value as less than a non-nil value' do
+      expect(RpmTest.compare_values(nil, '0')).to eq(-1)
+    end
+
+    it 'treats a non-nil value as greater than a nil value' do
+      expect(RpmTest.compare_values('0', nil)).to eq(1)
+    end
+
+    it 'passes two non-nil values on to rpmvercmp' do
+      allow(RpmTest).to receive(:rpmvercmp).and_return(0)
+      expect(RpmTest).to receive(:rpmvercmp).with('s1', 's2')
+      RpmTest.compare_values('s1', 's2')
+    end
+  end
+end

data/spec/unit/util/run_mode_spec.rb

@@ -25,12 +25,12 @@ describe Puppet::Util::RunMode do
         as_non_root { expect(@run_mode.conf_dir).to eq(File.expand_path('~/.puppetlabs/etc/puppet')) }
       end
 
-      context "master run mode" do
+      context "server run mode" do
         before do
-          @run_mode = Puppet::Util::UnixRunMode.new('master')
+          @run_mode = Puppet::Util::UnixRunMode.new('server')
         end
 
-        it "has confdir ~/.puppetlabs/etc/puppet when run as non-root and master run mode" do
+        it "has confdir ~/.puppetlabs/etc/puppet when run as non-root and server run mode" do
           as_non_root { expect(@run_mode.conf_dir).to eq(File.expand_path('~/.puppetlabs/etc/puppet')) }
         end
       end
@@ -53,12 +53,12 @@ describe Puppet::Util::RunMode do
         as_non_root { expect(@run_mode.code_dir).to eq(File.expand_path('~/.puppetlabs/etc/code')) }
       end
 
-      context "master run mode" do
+      context "server run mode" do
         before do
-          @run_mode = Puppet::Util::UnixRunMode.new('master')
+          @run_mode = Puppet::Util::UnixRunMode.new('server')
         end
 
-        it "has codedir ~/.puppetlabs/etc/code when run as non-root and master run mode" do
+        it "has codedir ~/.puppetlabs/etc/code when run as non-root and server run mode" do
           as_non_root { expect(@run_mode.code_dir).to eq(File.expand_path('~/.puppetlabs/etc/code')) }
         end
       end

data/spec/unit/util/windows/adsi_spec.rb

@@ -466,8 +466,8 @@ describe Puppet::Util::Windows::ADSI, :if => Puppet::Util::Platform.windows? do
           expect(Puppet::Util::Windows::SID).to receive(:octet_string_to_principal).with([0]).and_return(sids[0])
           expect(Puppet::Util::Windows::SID).to receive(:octet_string_to_principal).with([1]).and_return(sids[1])
 
-          expect(Puppet::Util::Windows::SID).to receive(:name_to_principal).with('user2').and_return(sids[1])
-          expect(Puppet::Util::Windows::SID).to receive(:name_to_principal).with('DOMAIN2\user3').and_return(sids[2])
+          expect(Puppet::Util::Windows::SID).to receive(:name_to_principal).with('user2', false).and_return(sids[1])
+          expect(Puppet::Util::Windows::SID).to receive(:name_to_principal).with('DOMAIN2\user3', false).and_return(sids[2])
 
           expect(Puppet::Util::Windows::ADSI).to receive(:sid_uri).with(sids[0]).and_return("WinNT://DOMAIN/user1,user")
           expect(Puppet::Util::Windows::ADSI).to receive(:sid_uri).with(sids[2]).and_return("WinNT://DOMAIN2/user3,user")
@@ -493,8 +493,8 @@ describe Puppet::Util::Windows::ADSI, :if => Puppet::Util::Platform.windows? do
           expect(Puppet::Util::Windows::SID).to receive(:octet_string_to_principal).with([0]).and_return(sids[0])
           expect(Puppet::Util::Windows::SID).to receive(:octet_string_to_principal).with([1]).and_return(sids[1])
 
-          expect(Puppet::Util::Windows::SID).to receive(:name_to_principal).with('user2').and_return(sids[1])
-          expect(Puppet::Util::Windows::SID).to receive(:name_to_principal).with('DOMAIN2\user3').and_return(sids[2])
+          expect(Puppet::Util::Windows::SID).to receive(:name_to_principal).with('user2', any_args).and_return(sids[1])
+          expect(Puppet::Util::Windows::SID).to receive(:name_to_principal).with('DOMAIN2\user3', any_args).and_return(sids[2])
 
           expect(Puppet::Util::Windows::ADSI).to receive(:sid_uri).with(sids[2]).and_return("WinNT://DOMAIN2/user3,user")
 

data/spec/unit/util/windows/api_types_spec.rb

@@ -4,62 +4,86 @@ require 'spec_helper'
 
 describe "FFI::MemoryPointer", :if => Puppet::Util::Platform.windows? do
   # use 2 bad bytes at end so we have even number of bytes / characters
-  let (:bad_string) { "hello invalid world".encode(Encoding::UTF_16LE) + "\xDD\xDD".force_encoding(Encoding::UTF_16LE) }
-  let (:bad_string_bytes) { bad_string.bytes.to_a }
+  let(:bad_string) { "hello invalid world".encode(Encoding::UTF_16LE) + "\xDD\xDD".force_encoding(Encoding::UTF_16LE) }
+  let(:bad_string_bytes) { bad_string.bytes.to_a }
+  let(:a_wide_bytes) { "A".encode(Encoding::UTF_16LE).bytes.to_a }
+  let(:b_wide_bytes) { "B".encode(Encoding::UTF_16LE).bytes.to_a }
 
   context "read_wide_string" do
     let (:string) { "foo_bar" }
 
     it "should properly roundtrip a given string" do
-      read_string = nil
       FFI::MemoryPointer.from_string_to_wide_string(string) do |ptr|
-        read_string = ptr.read_wide_string(string.length)
+        expect(ptr.read_wide_string(string.length)).to eq(string)
       end
-
-      expect(read_string).to eq(string)
     end
 
     it "should return a given string in UTF-8" do
-      read_string = nil
       FFI::MemoryPointer.from_string_to_wide_string(string) do |ptr|
         read_string = ptr.read_wide_string(string.length)
+        expect(read_string.encoding).to eq(Encoding::UTF_8)
       end
-
-      expect(read_string.encoding).to eq(Encoding::UTF_8)
     end
 
     it "should raise an error and emit a debug message when receiving a string containing invalid bytes in the destination encoding" do
-      # enable a debug output sink to local string array
-      Puppet.debug = true
-      arraydest = []
-      Puppet::Util::Log.newdestination(Puppet::Test::LogCollector.new(arraydest))
-
-      read_string = nil
+      Puppet[:log_level] = 'debug'
 
       expect {
         FFI::MemoryPointer.new(:byte, bad_string_bytes.count) do |ptr|
           # uchar here is synonymous with byte
           ptr.put_array_of_uchar(0, bad_string_bytes)
 
-          read_string = ptr.read_wide_string(bad_string.length)
+          ptr.read_wide_string(bad_string.length)
         end
       }.to raise_error(Encoding::InvalidByteSequenceError)
 
-      expect(read_string).to be_nil
-      expect(arraydest.last.message).to eq("Unable to convert value #{bad_string.dump} to encoding UTF-8 due to #<Encoding::InvalidByteSequenceError: \"\\xDD\\xDD\" on UTF-16LE>")
+      expect(@logs.last.message).to eq("Unable to convert value #{bad_string.dump} to encoding UTF-8 due to #<Encoding::InvalidByteSequenceError: \"\\xDD\\xDD\" on UTF-16LE>")
     end
 
     it "should not raise an error when receiving a string containing invalid bytes in the destination encoding, when specifying :invalid => :replace" do
-      read_string = nil
-
       FFI::MemoryPointer.new(:byte, bad_string_bytes.count) do |ptr|
         # uchar here is synonymous with byte
         ptr.put_array_of_uchar(0, bad_string_bytes)
 
-        read_string = ptr.read_wide_string(bad_string.length, Encoding::UTF_8, :invalid => :replace)
+        read_string = ptr.read_wide_string(bad_string.length, Encoding::UTF_8, false, :invalid => :replace)
+        expect(read_string).to eq("hello invalid world\uFFFD")
       end
+    end
 
-      expect(read_string).to eq("hello invalid world\uFFFD")
+    it "raises an IndexError if asked to read more characters than there are bytes allocated" do
+      expect {
+        FFI::MemoryPointer.new(:byte, 1) do |ptr|
+          ptr.read_wide_string(1) # 1 wchar = 2 bytes
+        end
+      }.to raise_error(IndexError, /out of bounds/)
+    end
+
+    it "raises an IndexError if asked to read a negative number of characters" do
+      expect {
+        FFI::MemoryPointer.new(:byte, 1) do |ptr|
+          ptr.read_wide_string(-1)
+        end
+      }.to raise_error(IndexError, /out of bounds/)
+    end
+
+    it "returns an empty string if asked to read 0 characters" do
+      FFI::MemoryPointer.new(:byte, 1) do |ptr|
+        expect(ptr.read_wide_string(0)).to eq("")
+      end
+    end
+
+    it "returns a substring if asked to read fewer characters than are in the byte array" do
+      FFI::MemoryPointer.new(:byte, 4) do |ptr|
+        ptr.write_array_of_uint8("AB".encode('UTF-16LE').bytes.to_a)
+        expect(ptr.read_wide_string(1)).to eq("A")
+      end
+    end
+
+    it "preserves wide null characters in the string" do
+      FFI::MemoryPointer.new(:byte, 6) do |ptr|
+        ptr.write_array_of_uint8(a_wide_bytes + [0, 0] + b_wide_bytes)
+        expect(ptr.read_wide_string(3)).to eq("A\x00B")
+      end
     end
   end
 
@@ -69,52 +93,92 @@ describe "FFI::MemoryPointer", :if => Puppet::Util::Platform.windows? do
     let (:double_null_string) { string + "\x00\x00" }
 
     it "should read a short single null terminated string" do
-      read_string = nil
       FFI::MemoryPointer.from_string_to_wide_string(single_null_string) do |ptr|
-        read_string = ptr.read_arbitrary_wide_string_up_to()
+        expect(ptr.read_arbitrary_wide_string_up_to).to eq(string)
       end
-
-      expect(read_string).to eq(string)
     end
 
     it "should read a short double null terminated string" do
-      read_string = nil
       FFI::MemoryPointer.from_string_to_wide_string(double_null_string) do |ptr|
-        read_string = ptr.read_arbitrary_wide_string_up_to(512, :double_null)
+        expect(ptr.read_arbitrary_wide_string_up_to(512, :double_null)).to eq(string)
       end
+    end
+
+    it "detects trailing single null wchar" do
+      FFI::MemoryPointer.from_string_to_wide_string(single_null_string) do |ptr|
+        expect(ptr).to receive(:read_wide_string).with(string.length, anything, anything, anything).and_call_original
 
-      expect(read_string).to eq(string)
+        expect(ptr.read_arbitrary_wide_string_up_to).to eq(string)
+      end
     end
 
-    it "should return a string of max_length characters when specified" do
-      read_string = nil
+    it "detects trailing double null wchar" do
+      FFI::MemoryPointer.from_string_to_wide_string(double_null_string) do |ptr|
+        expect(ptr).to receive(:read_wide_string).with(string.length, anything, anything, anything).and_call_original
+
+        expect(ptr.read_arbitrary_wide_string_up_to(512, :double_null)).to eq(string)
+      end
+    end
+
+    it "should raises an IndexError if max_length is negative" do
+      FFI::MemoryPointer.from_string_to_wide_string(single_null_string) do |ptr|
+        expect {
+          ptr.read_arbitrary_wide_string_up_to(-1)
+        }.to raise_error(IndexError, /out of bounds/)
+      end
+    end
+
+    it "should return an empty string when the max_length is 0" do
       FFI::MemoryPointer.from_string_to_wide_string(single_null_string) do |ptr|
-        read_string = ptr.read_arbitrary_wide_string_up_to(3)
+        expect(ptr.read_arbitrary_wide_string_up_to(0)).to eq("")
       end
+    end
 
-      expect(read_string).to eq(string[0..2])
+    it "should return a string of max_length characters when specified" do
+      FFI::MemoryPointer.from_string_to_wide_string(single_null_string) do |ptr|
+        expect(ptr.read_arbitrary_wide_string_up_to(3)).to eq(string[0..2])
+      end
     end
 
     it "should return wide strings in UTF-8" do
-      read_string = nil
       FFI::MemoryPointer.from_string_to_wide_string(string) do |ptr|
-        read_string = ptr.read_arbitrary_wide_string_up_to()
+        read_string = ptr.read_arbitrary_wide_string_up_to
+        expect(read_string.encoding).to eq(Encoding::UTF_8)
       end
-
-      expect(read_string.encoding).to eq(Encoding::UTF_8)
     end
 
     it "should not raise an error when receiving a string containing invalid bytes in the destination encoding, when specifying :invalid => :replace" do
-      read_string = nil
-
       FFI::MemoryPointer.new(:byte, bad_string_bytes.count) do |ptr|
         # uchar here is synonymous with byte
         ptr.put_array_of_uchar(0, bad_string_bytes)
 
         read_string = ptr.read_arbitrary_wide_string_up_to(ptr.size / 2, :single_null, :invalid => :replace)
+        expect(read_string).to eq("hello invalid world\uFFFD")
+      end
+    end
+
+    it "should raise an IndexError if there isn't a null terminator" do
+      # This only works when using a memory pointer with a known number of cells
+      # and size per cell, but not arbitrary Pointers
+      FFI::MemoryPointer.new(:wchar, 1) do |ptr|
+        ptr.write_array_of_uint8(a_wide_bytes)
+
+        expect {
+          ptr.read_arbitrary_wide_string_up_to(42)
+        }.to raise_error(IndexError, /out of bounds/)
       end
+    end
+
+    it "should raise an IndexError if there isn't a double null terminator" do
+      # This only works when using a memory pointer with a known number of cells
+      # and size per cell, but not arbitrary Pointers
+      FFI::MemoryPointer.new(:wchar, 1) do |ptr|
+        ptr.write_array_of_uint8(a_wide_bytes)
 
-      expect(read_string).to eq("hello invalid world\uFFFD")
+        expect {
+          ptr.read_arbitrary_wide_string_up_to(42, :double_null)
+        }.to raise_error(IndexError, /out of bounds/)
+      end
     end
   end
 end