puppet 5.5.16 → 5.5.21

data/spec/unit/util/pidlock_spec.rb

@@ -22,23 +22,6 @@ describe Puppet::Util::Pidlock do
 
     it "should become locked" do
       @lock.lock
-      if Puppet::Util::Platform.windows?
-        allow(Puppet::Util::Windows::Process).to receive(:get_process_image_name_by_pid).with(@lock.lock_pid).and_return('C:\Program Files\Puppet Labs\Puppet\puppet\bin\ruby.exe')
-      else
-        allow(Puppet::Util::Execution).to receive(:execute).with(['ps', '-p', @lock.lock_pid, '-o', 'comm=']).and_return('puppet')
-        allow(Puppet::Util::Execution).to receive(:execute).with(['ps', '-p', @lock.lock_pid, '-o', 'args=']).and_return('puppet')
-      end
-      expect(@lock).to be_locked
-    end
-
-    it "should become locked if puppet is a gem" do
-      @lock.lock
-      unless Puppet::Util::Platform.windows?
-        expect(Puppet::Util::Execution).to receive(:execute).with(['ps', '-p', @lock.lock_pid, '-o', 'comm=']).and_return('ruby')
-        expect(Puppet::Util::Execution).to receive(:execute).with(['ps', '-p', @lock.lock_pid, '-o', 'args=']).and_return('ruby /root/puppet/.bundle/ruby/2.3.0/bin/puppet agent --no-daemonize -v')
-      else
-        allow(Puppet::Util::Windows::Process).to receive(:get_process_image_name_by_pid).with(@lock.lock_pid).and_return('C:\tools\ruby25\bin\ruby.exe')
-      end
       expect(@lock).to be_locked
     end
 
@@ -117,23 +100,6 @@ describe Puppet::Util::Pidlock do
   describe "#locked?" do
     it "should return true if locked" do
       @lock.lock
-      if Puppet::Util::Platform.windows?
-        allow(Puppet::Util::Windows::Process).to receive(:get_process_image_name_by_pid).with(@lock.lock_pid).and_return('C:\Program Files\Puppet Labs\Puppet\puppet\bin\ruby.exe')
-      else
-        allow(Puppet::Util::Execution).to receive(:execute).with(['ps', '-p', @lock.lock_pid, '-o', 'comm=']).and_return('puppet')
-        allow(Puppet::Util::Execution).to receive(:execute).with(['ps', '-p', @lock.lock_pid, '-o', 'args=']).and_return('puppet')
-      end
-      expect(@lock).to be_locked
-    end
-
-    it "should return true if locked when puppet as gem" do
-      @lock.lock
-      unless Puppet::Util::Platform.windows?
-        expect(Puppet::Util::Execution).to receive(:execute).with(['ps', '-p', @lock.lock_pid, '-o', 'comm=']).and_return('ruby')
-        expect(Puppet::Util::Execution).to receive(:execute).with(['ps', '-p', @lock.lock_pid, '-o', 'args=']).and_return('ruby /root/puppet/.bundle/ruby/2.3.0/bin/puppet agent --no-daemonize -v')
-      else
-        allow(Puppet::Util::Windows::Process).to receive(:get_process_image_name_by_pid).with(@lock.lock_pid).and_return('C:\tools\ruby25\bin\ruby.exe')
-      end
       expect(@lock).to be_locked
     end
 
@@ -179,12 +145,6 @@ describe Puppet::Util::Pidlock do
       end
 
       it "should replace with new locks" do
-        if Puppet::Util::Platform.windows?
-          allow(Puppet::Util::Windows::Process).to receive(:get_process_image_name_by_pid).with(6789).and_return('C:\Program Files\Puppet Labs\Puppet\puppet\bin\ruby.exe')
-        else
-          allow(Puppet::Util::Execution).to receive(:execute).with(['ps', '-p', 6789, '-o', 'comm=']).and_return('puppet')
-          allow(Puppet::Util::Execution).to receive(:execute).with(['ps', '-p', 6789, '-o', 'args=']).and_return('puppet')
-        end
         @lock.lock
         expect(Puppet::FileSystem.exist?(@lockfile)).to be_truthy
         expect(@lock.lock_pid).to eq(6789)
@@ -205,6 +165,49 @@ describe Puppet::Util::Pidlock do
     end
   end
 
+  describe "with no access to open the process on Windows", :if => Puppet.features.microsoft_windows? do
+    before(:each) do
+      allow(Process).to receive(:pid).and_return(6789)
+      @lock.lock
+      allow(Process).to receive(:pid).and_return(1234)
+      exception = Puppet::Util::Windows::Error.new('Access Denied', 5) # ERROR_ACCESS_DENIED
+      allow(Puppet::Util::Windows::Process).to receive(:get_process_image_name_by_pid).with(6789).and_raise(exception)
+      allow(Process).to receive(:kill).with(0, 6789)
+      allow(Process).to receive(:kill).with(0, 1234)
+    end
+
+    it "should be locked" do
+      expect(@lock).to be_locked
+    end
+
+    describe "#lock" do
+      it "should not be possible" do
+        expect(@lock.lock).to be_falsey
+      end
+
+      it "should not overwrite the lock" do
+        @lock.lock
+        expect(@lock).not_to be_mine
+      end
+    end
+
+    describe "#unlock" do
+      it "should not be possible" do
+        expect(@lock.unlock).to be_falsey
+      end
+
+      it "should not remove the lock file" do
+        @lock.unlock
+        expect(Puppet::FileSystem.exist?(@lockfile)).to be_truthy
+      end
+
+      it "should still not be our lock" do
+        @lock.unlock
+        expect(@lock).not_to be_mine
+      end
+    end
+  end
+
   describe "with another process lock" do
     before(:each) do
       # fake our pid to be 1234
@@ -233,6 +236,30 @@ describe Puppet::Util::Pidlock do
       expect(@lock).not_to be_mine
     end
 
+    it "should be locked if the other process is a puppet gem" do
+      File.write(@lockfile, "1234")
+
+      if Puppet::Util::Platform.windows?
+        allow(Puppet::Util::Windows::Process).to receive(:get_process_image_name_by_pid).with(1234).and_return('C:\Program Files\Puppet Labs\Puppet\puppet\bin\ruby.exe')
+      else
+        allow(Puppet::Util::Execution).to receive(:execute).with(['ps', '-p', 1234, '-o', 'comm=']).and_return('ruby')
+        allow(Puppet::Util::Execution).to receive(:execute).with(['ps', '-p', 1234, '-o', 'args=']).and_return('ruby /root/puppet/.bundle/ruby/2.3.0/bin/puppet agent --no-daemonize -v')
+      end
+      expect(@lock).to be_locked
+    end
+
+    it "should not be mine if the other process is a puppet gem" do
+      File.write(@lockfile, "1234")
+
+      if Puppet::Util::Platform.windows?
+        allow(Puppet::Util::Windows::Process).to receive(:get_process_image_name_by_pid).with(1234).and_return('C:\Program Files\Puppet Labs\Puppet\puppet\bin\ruby.exe')
+      else
+        allow(Puppet::Util::Execution).to receive(:execute).with(['ps', '-p', 1234, '-o', 'comm=']).and_return('ruby')
+        allow(Puppet::Util::Execution).to receive(:execute).with(['ps', '-p', 1234, '-o', 'args=']).and_return('ruby /root/puppet/.bundle/ruby/2.3.0/bin/puppet agent --no-daemonize -v')
+      end
+      expect(@lock).to_not be_mine
+    end
+
     describe "#lock" do
       it "should not be possible" do
         expect(@lock.lock).to be_falsey

data/spec/unit/util/plist_spec.rb

@@ -1,3 +1,5 @@
+# coding: utf-8
+
 require 'spec_helper'
 require 'puppet/util/plist'
 require 'puppet_spec/files'
@@ -52,6 +54,19 @@ describe Puppet::Util::Plist, :if => Puppet.features.cfpropertylist? do
     </dict>
     </plist>'
   end
+  let(:ascii_xml_plist) do
+    '<?xml version="1.0" encoding="UTF-8"?>
+     <!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+     <plist version="1.0">
+     <dict>
+       <key>RecordName</key>
+         <array>
+           <string>Timișoara</string>
+           <string>Tōkyō</string>
+         </array>
+     </dict>
+     </plist>'.force_encoding(Encoding::US_ASCII)
+  end
   let(:non_plist_data) do
     "Take my love, take my land
      Take me where I cannot stand
@@ -62,6 +77,7 @@ describe Puppet::Util::Plist, :if => Puppet.features.cfpropertylist? do
     "\xCF\xFA\xED\xFE\a\u0000\u0000\u0001\u0003\u0000\u0000\x80\u0002\u0000\u0000\u0000\u0012\u0000\u0000\u0000\b"
   end
   let(:valid_xml_plist_hash) { {"LastUsedPrinters"=>[{"Network"=>"10.85.132.1", "PrinterID"=>"baskerville_corp_puppetlabs_net"}, {"Network"=>"10.14.96.1", "PrinterID"=>"Statler"}]} }
+  let(:ascii_xml_plist_hash) { {"RecordName"=>["Timișoara", "Tōkyō"]} }
   let(:plist_path) { file_containing('sample.plist', valid_xml_plist) }
   let(:binary_plist_magic_number) { 'bplist00' }
   let(:bad_xml_doctype) { '<!DOCTYPE plist PUBLIC -//Apple Computer' }
@@ -132,6 +148,10 @@ describe Puppet::Util::Plist, :if => Puppet.features.cfpropertylist? do
       expect(subject.parse_plist(valid_xml_plist)).to eq(valid_xml_plist_hash)
     end
 
+    it "returns a valid hash when an ASCII XML plist is provided" do
+      expect(subject.parse_plist(ascii_xml_plist)).to eq(ascii_xml_plist_hash)
+    end
+
     it "raises a debug message and replaces a bad XML plist doctype should one be encountered" do
       expect(subject).to receive(:new_cfpropertylist).with({:data => good_xml_doctype}).and_return('plist_object')
       allow(subject).to receive(:convert_cfpropertylist_to_native_types).with('plist_object')

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

@@ -41,6 +41,19 @@ describe Puppet::Util::Windows::ADSI, :if => Puppet.features.microsoft_windows?
     end
   end
 
+  describe ".domain_role" do
+    DOMAIN_ROLES = Puppet::Util::Platform.windows? ? Puppet::Util::Windows::ADSI::DOMAIN_ROLES : {}
+
+    DOMAIN_ROLES.each do |id, role|
+      it "should be able to return #{role} as the domain role of the computer" do
+        Puppet::Util::Windows::ADSI.instance_variable_set(:@domain_role, nil)
+        domain_role = [double('WMI', :DomainRole => id)]
+        allow(Puppet::Util::Windows::ADSI).to receive(:execquery).with('select DomainRole from Win32_ComputerSystem').and_return(domain_role)
+        expect(Puppet::Util::Windows::ADSI.domain_role).to eq(role)
+      end
+    end
+  end
+
   describe ".sid_uri" do
     it "should raise an error when the input is not a SID Principal" do
       [Object.new, {}, 1, :symbol, '', nil].each do |input|
@@ -56,6 +69,32 @@ describe Puppet::Util::Windows::ADSI, :if => Puppet.features.microsoft_windows?
     end
   end
 
+  shared_examples 'a local only resource query' do |klass, account_type|
+    before(:each) do
+      allow(Puppet::Util::Windows::ADSI).to receive(:domain_role).and_return(:MEMBER_SERVER)
+    end
+
+    it "should be able to check for a local resource" do
+      local_domain = 'testcomputername'
+      principal = double('Principal', :account => resource_name, :domain => local_domain, :account_type => account_type)
+      allow(Puppet::Util::Windows::SID).to receive(:name_to_principal).with(resource_name).and_return(principal)
+      expect(klass.exists?(resource_name)).to eq(true)
+    end
+
+    it "should be case insensitive when comparing the domain with the computer name" do
+      local_domain = 'TESTCOMPUTERNAME'
+      principal = double('Principal', :account => resource_name, :domain => local_domain, :account_type => account_type)
+      allow(Puppet::Util::Windows::SID).to receive(:name_to_principal).with(resource_name).and_return(principal)
+      expect(klass.exists?(resource_name)).to eq(true)
+    end
+
+    it "should return false if no local resource exists" do
+      principal = double('Principal', :account => resource_name, :domain => 'AD_DOMAIN', :account_type => account_type)
+      allow(Puppet::Util::Windows::SID).to receive(:name_to_principal).with(resource_name).and_return(principal)
+      expect(klass.exists?(resource_name)).to eq(false)
+    end
+  end
+
   describe Puppet::Util::Windows::ADSI::User do
     let(:username)  { 'testuser' }
     let(:domain)    { 'DOMAIN' }
@@ -103,6 +142,12 @@ describe Puppet::Util::Windows::ADSI, :if => Puppet.features.microsoft_windows?
       expect(user.native_object).to eq(adsi_user)
     end
 
+    context "when domain-joined" do
+      it_should_behave_like 'a local only resource query', Puppet::Util::Windows::ADSI::User, :SidTypeUser do
+        let(:resource_name) { username }
+      end
+    end
+
     it "should be able to check the existence of a user" do
       expect(Puppet::Util::Windows::SID).to receive(:name_to_principal).with(username).and_return(nil)
       expect(Puppet::Util::Windows::ADSI).to receive(:connect).with("WinNT://./#{username},user").and_return(connection)
@@ -421,8 +466,8 @@ describe Puppet::Util::Windows::ADSI, :if => Puppet.features.microsoft_windows?
           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")
@@ -448,8 +493,8 @@ describe Puppet::Util::Windows::ADSI, :if => Puppet.features.microsoft_windows?
           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")
 
@@ -543,6 +588,12 @@ describe Puppet::Util::Windows::ADSI, :if => Puppet.features.microsoft_windows?
       expect(Puppet::Util::Windows::ADSI::Group.uri(groupname, ntauthority_localized)).to eq("WinNT://./#{groupname},group")
     end
 
+    context "when domain-joined" do
+      it_should_behave_like 'a local only resource query', Puppet::Util::Windows::ADSI::Group, :SidTypeGroup do
+        let(:resource_name) { groupname }
+      end
+    end
+
     it "should be able to create a group" do
       adsi_group = double("adsi")
 

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

@@ -4,62 +4,86 @@ require 'spec_helper'
 
 describe "FFI::MemoryPointer", :if => Puppet.features.microsoft_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.features.microsoft_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