puppet 6.16.0-universal-darwin → 7.0.0-universal-darwin

data/spec/unit/util/command_line_spec.rb

@@ -62,7 +62,7 @@ describe Puppet::Util::CommandLine do
       it "should print the version and exit if #{arg} is given" do
         expect do
           described_class.new("puppet", [arg]).execute
-        end.to have_printed(/^#{Regexp.escape(Puppet.version)}$/)
+        end.to output(/^#{Regexp.escape(Puppet.version)}$/).to_stdout
       end
     end
 
@@ -73,7 +73,8 @@ describe Puppet::Util::CommandLine do
 
         expect {
           commandline.execute
-        }.to have_printed(/Usage: puppet <subcommand> \[options\] <action> \[options\]/).and_exit_with(0)
+        }.to exit_with(0)
+         .and output(/Usage: puppet <subcommand> \[options\] <action> \[options\]/).to_stdout
       end
     end
 
@@ -95,7 +96,8 @@ describe Puppet::Util::CommandLine do
 
       expect {
         commandline.execute
-      }.to have_printed(/Usage: puppet <subcommand> \[options\] <action> \[options\]/).and_exit_with(0)
+      }.to exit_with(0)
+       .and output(/Usage: puppet <subcommand> \[options\] <action> \[options\]/).to_stdout
     end
   end
 
@@ -124,7 +126,8 @@ describe Puppet::Util::CommandLine do
 
           expect {
             commandline.execute
-          }.to have_printed(/Unknown Puppet subcommand 'whatever'/).and_exit_with(1)
+          }.to exit_with(1)
+           .and output(/Unknown Puppet subcommand 'whatever'/).to_stdout
         end
 
         it "should abort and show the help message" do
@@ -134,7 +137,8 @@ describe Puppet::Util::CommandLine do
 
           expect {
             commandline.execute
-          }.to have_printed(/See 'puppet help' for help on available puppet subcommands/).and_exit_with(1)
+          }.to exit_with(1)
+           .and output(/See 'puppet help' for help on available puppet subcommands/).to_stdout
         end
 
         %w{--version -V}.each do |arg|
@@ -145,7 +149,8 @@ describe Puppet::Util::CommandLine do
 
             expect {
               commandline.execute
-            }.to have_printed(%r[^#{Regexp.escape(Puppet.version)}$]).and_exit_with(1)
+            }.to exit_with(1)
+             .and output(%r[^#{Regexp.escape(Puppet.version)}$]).to_stdout
           end
         end
       end

data/spec/unit/util/execution_spec.rb

@@ -935,33 +935,4 @@ describe Puppet::Util::Execution, if: !Puppet::Util::Platform.jruby? do
       expect(Puppet::Util::Execution.execpipe('echo hello', false)).to eq('error message')
     end
   end
-
-  describe "execfail" do
-    it "returns the executed command output" do
-      allow(Puppet::Util::Execution).to receive(:execute)
-        .and_return(Puppet::Util::Execution::ProcessOutput.new("process output", 0))
-      expect(Puppet::Util::Execution.execfail('echo hello', Puppet::Error)).to eq('process output')
-    end
-
-    it "raises a caller-specified exception on failure with the backtrace" do
-      allow(Puppet::Util::Execution).to receive(:execute).and_raise(Puppet::ExecutionFailure, "failed to execute")
-      expect {
-        Puppet::Util::Execution.execfail("this will fail", Puppet::Error)
-      }.to raise_error(Puppet::Error, /failed to execute/)
-    end
-
-    it "raises exceptions that don't extend ExecutionFailure" do
-      allow(Puppet::Util::Execution).to receive(:execute).and_raise(ArgumentError, "failed to execute")
-      expect {
-        Puppet::Util::Execution.execfail("this will fail", Puppet::Error)
-      }.to raise_error(ArgumentError, /failed to execute/)
-    end
-
-    it "raises a TypeError if the exception class is nil" do
-      allow(Puppet::Util::Execution).to receive(:execute).and_raise(Puppet::ExecutionFailure, "failed to execute")
-      expect {
-        Puppet::Util::Execution.execfail('echo hello', nil)
-      }.to raise_error(TypeError, /exception class\/object expected/)
-    end
-  end
 end

data/spec/unit/util/monkey_patches_spec.rb

@@ -135,9 +135,3 @@ describe SecureRandom do
     expect(SecureRandom.uuid).to match(/[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}/i)
   end
 end
-
-describe 'Enumerable' do
-  it 'expects uniq to work on an Enumerable' do
-    expect(['c', 'c', 'C'].reverse_each.uniq).to eql(['C', 'c'])
-  end
-end

data/spec/unit/util/rubygems_spec.rb

@@ -33,8 +33,8 @@ describe Puppet::Util::RubyGems::Source do
   describe '::Gems18Source' do
     before(:each) { allow(described_class).to receive(:source).and_return(Puppet::Util::RubyGems::Gems18Source) }
 
-    it "#directories returns the lib subdirs of Gem::Specification.latest_specs" do
-      expect(Gem::Specification).to receive(:latest_specs).with(true).and_return([fake_gem])
+    it "#directories returns the lib subdirs of Gem::Specification.stubs" do
+      expect(Gem::Specification).to receive(:stubs).and_return([fake_gem])
 
       expect(described_class.new.directories).to eq([gem_lib])
     end

data/spec/unit/util/run_mode_spec.rb

@@ -1,12 +1,6 @@
 require 'spec_helper'
 
 describe Puppet::Util::RunMode do
-  # Discriminator for tests that attempts to unset HOME since that, for reasons currently unknown,
-  # doesn't work in Ruby >= 2.4.0
-  def self.gte_ruby_2_4
-    @gte_ruby_2_4 ||= SemanticPuppet::Version.parse(RUBY_VERSION) >= SemanticPuppet::Version.parse('2.4.0')
-  end
-
   before do
     @run_mode = Puppet::Util::RunMode.new('fake')
   end
@@ -25,23 +19,15 @@ 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
-
-      it "fails when asking for the conf_dir as non-root and there is no $HOME", :unless => gte_ruby_2_4 || Puppet::Util::Platform.windows? do
-        as_non_root do
-          without_home do
-            expect { @run_mode.conf_dir }.to raise_error ArgumentError, /couldn't find HOME/
-          end
-        end
-      end
     end
 
     describe "#code_dir" do
@@ -53,23 +39,15 @@ 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
-
-      it "fails when asking for the code_dir as non-root and there is no $HOME", :unless => gte_ruby_2_4 || Puppet::Util::Platform.windows? do
-        as_non_root do
-          without_home do
-            expect { @run_mode.code_dir }.to raise_error ArgumentError, /couldn't find HOME/
-          end
-        end
-      end
     end
 
     describe "#var_dir" do
@@ -80,13 +58,15 @@ describe Puppet::Util::RunMode do
       it "has vardir ~/.puppetlabs/opt/puppet/cache when run as non-root" do
         as_non_root { expect(@run_mode.var_dir).to eq(File.expand_path('~/.puppetlabs/opt/puppet/cache')) }
       end
+    end
+
+    describe "#public_dir" do
+      it "has publicdir /opt/puppetlabs/puppet/public when run as root" do
+        as_root { expect(@run_mode.public_dir).to eq(File.expand_path('/opt/puppetlabs/puppet/public')) }
+      end
 
-      it "fails when asking for the var_dir as non-root and there is no $HOME", :unless => gte_ruby_2_4 || Puppet::Util::Platform.windows? do
-        as_non_root do
-          without_home do
-            expect { @run_mode.var_dir }.to raise_error ArgumentError, /couldn't find HOME/
-          end
-        end
+      it "has publicdir ~/.puppetlabs/opt/puppet/public when run as non-root" do
+        as_non_root { expect(@run_mode.public_dir).to eq(File.expand_path('~/.puppetlabs/opt/puppet/public')) }
       end
     end
 
@@ -101,14 +81,6 @@ describe Puppet::Util::RunMode do
         it "has default logdir ~/.puppetlabs/var/log" do
           as_non_root { expect(@run_mode.log_dir).to eq(File.expand_path('~/.puppetlabs/var/log')) }
         end
-
-        it "fails when asking for the log_dir and there is no $HOME", :unless => gte_ruby_2_4 || Puppet::Util::Platform.windows? do
-          as_non_root do
-            without_home do
-              expect { @run_mode.log_dir }.to raise_error ArgumentError, /couldn't find HOME/
-            end
-          end
-        end
       end
     end
 
@@ -123,103 +95,59 @@ describe Puppet::Util::RunMode do
         it "has default rundir ~/.puppetlabs/var/run" do
           as_non_root { expect(@run_mode.run_dir).to eq(File.expand_path('~/.puppetlabs/var/run')) }
         end
-
-        it "fails when asking for the run_dir and there is no $HOME", :unless => gte_ruby_2_4 || Puppet::Util::Platform.windows? do
-          as_non_root do
-            without_home do
-              expect { @run_mode.run_dir }.to raise_error ArgumentError, /couldn't find HOME/
-            end
-          end
-        end
       end
     end
   end
 
   describe Puppet::Util::WindowsRunMode, :if => Puppet::Util::Platform.windows? do
     before do
-      if not Dir.const_defined? :COMMON_APPDATA
-        Dir.const_set :COMMON_APPDATA, "/CommonFakeBase"
-        @remove_const = true
-      end
       @run_mode = Puppet::Util::WindowsRunMode.new('fake')
     end
 
-    after do
-      if @remove_const
-        Dir.send :remove_const, :COMMON_APPDATA
-      end
-    end
-
     describe "#conf_dir" do
       it "has confdir ending in Puppetlabs/puppet/etc when run as root" do
-        as_root { expect(@run_mode.conf_dir).to eq(File.expand_path(File.join(Dir::COMMON_APPDATA, "PuppetLabs", "puppet", "etc"))) }
+        as_root { expect(@run_mode.conf_dir).to eq(File.expand_path(File.join(ENV['ALLUSERSPROFILE'], "PuppetLabs", "puppet", "etc"))) }
       end
 
       it "has confdir in ~/.puppetlabs/etc/puppet when run as non-root" do
         as_non_root { expect(@run_mode.conf_dir).to eq(File.expand_path("~/.puppetlabs/etc/puppet")) }
       end
-
-      it "fails when asking for the conf_dir as non-root and there is no %HOME%, %HOMEDRIVE%, and %USERPROFILE%", :unless => gte_ruby_2_4 do
-        as_non_root do
-          without_env('HOME') do
-            without_env('HOMEDRIVE') do
-              without_env('USERPROFILE') do
-                expect { @run_mode.conf_dir }.to raise_error ArgumentError, /couldn't find HOME/
-              end
-            end
-          end
-        end
-      end
     end
 
     describe "#code_dir" do
       it "has codedir ending in PuppetLabs/code when run as root" do
-        as_root { expect(@run_mode.code_dir).to eq(File.expand_path(File.join(Dir::COMMON_APPDATA, "PuppetLabs", "code"))) }
+        as_root { expect(@run_mode.code_dir).to eq(File.expand_path(File.join(ENV['ALLUSERSPROFILE'], "PuppetLabs", "code"))) }
       end
 
       it "has codedir in ~/.puppetlabs/etc/code when run as non-root" do
         as_non_root { expect(@run_mode.code_dir).to eq(File.expand_path("~/.puppetlabs/etc/code")) }
       end
-
-      it "fails when asking for the code_dir as non-root and there is no %HOME%, %HOMEDRIVE%, and %USERPROFILE%", :unless => gte_ruby_2_4 do
-        as_non_root do
-          without_env('HOME') do
-            without_env('HOMEDRIVE') do
-              without_env('USERPROFILE') do
-                expect { @run_mode.code_dir }.to raise_error ArgumentError, /couldn't find HOME/
-              end
-            end
-          end
-        end
-      end
     end
 
     describe "#var_dir" do
       it "has vardir ending in PuppetLabs/puppet/cache when run as root" do
-        as_root { expect(@run_mode.var_dir).to eq(File.expand_path(File.join(Dir::COMMON_APPDATA, "PuppetLabs", "puppet", "cache"))) }
+        as_root { expect(@run_mode.var_dir).to eq(File.expand_path(File.join(ENV['ALLUSERSPROFILE'], "PuppetLabs", "puppet", "cache"))) }
       end
 
       it "has vardir in ~/.puppetlabs/opt/puppet/cache when run as non-root" do
         as_non_root { expect(@run_mode.var_dir).to eq(File.expand_path("~/.puppetlabs/opt/puppet/cache")) }
       end
+    end
+
+    describe "#public_dir" do
+      it "has publicdir ending in PuppetLabs/puppet/public when run as root" do
+        as_root { expect(@run_mode.public_dir).to eq(File.expand_path(File.join(ENV['ALLUSERSPROFILE'], "PuppetLabs", "puppet", "public"))) }
+      end
 
-      it "fails when asking for the conf_dir as non-root and there is no %HOME%, %HOMEDRIVE%, and %USERPROFILE%", :unless => gte_ruby_2_4 do
-        as_non_root do
-          without_env('HOME') do
-            without_env('HOMEDRIVE') do
-              without_env('USERPROFILE') do
-                expect { @run_mode.var_dir }.to raise_error ArgumentError, /couldn't find HOME/
-              end
-            end
-          end
-        end
+      it "has publicdir in ~/.puppetlabs/opt/puppet/public when run as non-root" do
+        as_non_root { expect(@run_mode.public_dir).to eq(File.expand_path("~/.puppetlabs/opt/puppet/public")) }
       end
     end
 
     describe "#log_dir" do
       describe "when run as root" do
         it "has logdir ending in PuppetLabs/puppet/var/log" do
-          as_root { expect(@run_mode.log_dir).to eq(File.expand_path(File.join(Dir::COMMON_APPDATA, "PuppetLabs", "puppet", "var", "log"))) }
+          as_root { expect(@run_mode.log_dir).to eq(File.expand_path(File.join(ENV['ALLUSERSPROFILE'], "PuppetLabs", "puppet", "var", "log"))) }
         end
       end
 
@@ -227,25 +155,13 @@ describe Puppet::Util::RunMode do
         it "has default logdir ~/.puppetlabs/var/log" do
           as_non_root { expect(@run_mode.log_dir).to eq(File.expand_path('~/.puppetlabs/var/log')) }
         end
-
-        it "fails when asking for the log_dir and there is no $HOME", :unless => gte_ruby_2_4 do
-          as_non_root do
-            without_env('HOME') do
-              without_env('HOMEDRIVE') do
-                without_env('USERPROFILE') do
-                  expect { @run_mode.log_dir }.to raise_error ArgumentError, /couldn't find HOME/
-                end
-              end
-            end
-          end
-        end
       end
     end
 
     describe "#run_dir" do
       describe "when run as root" do
         it "has rundir ending in PuppetLabs/puppet/var/run" do
-          as_root { expect(@run_mode.run_dir).to eq(File.expand_path(File.join(Dir::COMMON_APPDATA, "PuppetLabs", "puppet", "var", "run"))) }
+          as_root { expect(@run_mode.run_dir).to eq(File.expand_path(File.join(ENV['ALLUSERSPROFILE'], "PuppetLabs", "puppet", "var", "run"))) }
         end
       end
 
@@ -253,18 +169,6 @@ describe Puppet::Util::RunMode do
         it "has default rundir ~/.puppetlabs/var/run" do
           as_non_root { expect(@run_mode.run_dir).to eq(File.expand_path('~/.puppetlabs/var/run')) }
         end
-
-        it "fails when asking for the run_dir and there is no $HOME", :unless => gte_ruby_2_4 do
-          as_non_root do
-            without_env('HOME') do
-              without_env('HOMEDRIVE') do
-                without_env('USERPROFILE') do
-                  expect { @run_mode.run_dir }.to raise_error ArgumentError, /couldn't find HOME/
-                end
-              end
-            end
-          end
-        end
       end
     end
 
@@ -310,8 +214,4 @@ describe Puppet::Util::RunMode do
   ensure
     Puppet::Util.set_env(name, saved)
   end
-
-  def without_home(&block)
-    without_env('HOME', &block)
-  end
 end

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