diff --git a/lib/puppet/util.rb b/lib/puppet/util.rb
index e05339517..719009c42 100644
--- a/lib/puppet/util.rb
+++ b/lib/puppet/util.rb
@@ -1,554 +1,529 @@
 # A module to collect utility functions.
 
 require 'English'
 require 'puppet/error'
 require 'puppet/util/execution_stub'
 require 'uri'
 require 'pathname'
 require 'ostruct'
 require 'puppet/util/platform'
 require 'puppet/util/symbolic_file_mode'
 require 'puppet/file_system/uniquefile'
 require 'securerandom'
 
 module Puppet
 module Util
   require 'puppet/util/monkey_patches'
   require 'benchmark'
 
   # These are all for backward compatibility -- these are methods that used
   # to be in Puppet::Util but have been moved into external modules.
   require 'puppet/util/posix'
   extend Puppet::Util::POSIX
 
   extend Puppet::Util::SymbolicFileMode
 
   def self.activerecord_version
     if (defined?(::ActiveRecord) and defined?(::ActiveRecord::VERSION) and defined?(::ActiveRecord::VERSION::MAJOR) and defined?(::ActiveRecord::VERSION::MINOR))
       ([::ActiveRecord::VERSION::MAJOR, ::ActiveRecord::VERSION::MINOR].join('.').to_f)
     else
       0
     end
   end
 
 
   # Run some code with a specific environment.  Resets the environment back to
   # what it was at the end of the code.
   def self.withenv(hash)
     saved = ENV.to_hash
     hash.each do |name, val|
       ENV[name.to_s] = val
     end
 
     yield
   ensure
     ENV.clear
     saved.each do |name, val|
       ENV[name] = val
     end
   end
 
 
   # Execute a given chunk of code with a new umask.
   def self.withumask(mask)
     cur = File.umask(mask)
 
     begin
       yield
     ensure
       File.umask(cur)
     end
   end
 
 
   # Change the process to a different user
   def self.chuser
     if group = Puppet[:group]
       begin
         Puppet::Util::SUIDManager.change_group(group, true)
       rescue => detail
         Puppet.warning "could not change to group #{group.inspect}: #{detail}"
         $stderr.puts "could not change to group #{group.inspect}"
 
         # Don't exit on failed group changes, since it's
         # not fatal
         #exit(74)
       end
     end
 
     if user = Puppet[:user]
       begin
         Puppet::Util::SUIDManager.change_user(user, true)
       rescue => detail
         $stderr.puts "Could not change to user #{user}: #{detail}"
         exit(74)
       end
     end
   end
 
   # Create instance methods for each of the log levels.  This allows
   # the messages to be a little richer.  Most classes will be calling this
   # method.
   def self.logmethods(klass, useself = true)
     Puppet::Util::Log.eachlevel { |level|
       klass.send(:define_method, level, proc { |args|
         args = args.join(" ") if args.is_a?(Array)
         if useself
 
           Puppet::Util::Log.create(
             :level => level,
             :source => self,
             :message => args
           )
         else
 
           Puppet::Util::Log.create(
             :level => level,
             :message => args
           )
         end
       })
     }
   end
 
   # Proxy a bunch of methods to another object.
   def self.classproxy(klass, objmethod, *methods)
     classobj = class << klass; self; end
     methods.each do |method|
       classobj.send(:define_method, method) do |*args|
         obj = self.send(objmethod)
 
         obj.send(method, *args)
       end
     end
   end
 
   # Proxy a bunch of methods to another object.
   def self.proxy(klass, objmethod, *methods)
     methods.each do |method|
       klass.send(:define_method, method) do |*args|
         obj = self.send(objmethod)
 
         obj.send(method, *args)
       end
     end
   end
 
   def benchmark(*args)
     msg = args.pop
     level = args.pop
     object = nil
 
     if args.empty?
       if respond_to?(level)
         object = self
       else
         object = Puppet
       end
     else
       object = args.pop
     end
 
     raise Puppet::DevError, "Failed to provide level to :benchmark" unless level
 
     unless level == :none or object.respond_to? level
       raise Puppet::DevError, "Benchmarked object does not respond to #{level}"
     end
 
     # Only benchmark if our log level is high enough
     if level != :none and Puppet::Util::Log.sendlevel?(level)
       seconds = Benchmark.realtime {
         yield
       }
       object.send(level, msg + (" in %0.2f seconds" % seconds))
       return seconds
     else
       yield
     end
   end
   module_function :benchmark
 
   # Resolve a path for an executable to the absolute path. This tries to behave
   # in the same manner as the unix `which` command and uses the `PATH`
   # environment variable.
   #
   # @api public
   # @param bin [String] the name of the executable to find.
   # @return [String] the absolute path to the found executable.
   def which(bin)
     if absolute_path?(bin)
       return bin if FileTest.file? bin and FileTest.executable? bin
     else
       ENV['PATH'].split(File::PATH_SEPARATOR).each do |dir|
         begin
           dest = File.expand_path(File.join(dir, bin))
         rescue ArgumentError => e
           # if the user's PATH contains a literal tilde (~) character and HOME is not set, we may get
           # an ArgumentError here.  Let's check to see if that is the case; if not, re-raise whatever error
           # was thrown.
           if e.to_s =~ /HOME/ and (ENV['HOME'].nil? || ENV['HOME'] == "")
             # if we get here they have a tilde in their PATH.  We'll issue a single warning about this and then
             # ignore this path element and carry on with our lives.
             Puppet::Util::Warnings.warnonce("PATH contains a ~ character, and HOME is not set; ignoring PATH element '#{dir}'.")
           elsif e.to_s =~ /doesn't exist|can't find user/
             # ...otherwise, we just skip the non-existent entry, and do nothing.
             Puppet::Util::Warnings.warnonce("Couldn't expand PATH containing a ~ character; ignoring PATH element '#{dir}'.")
           else
             raise
           end
         else
           if Puppet.features.microsoft_windows? && File.extname(dest).empty?
             exts = ENV['PATHEXT']
             exts = exts ? exts.split(File::PATH_SEPARATOR) : %w[.COM .EXE .BAT .CMD]
             exts.each do |ext|
               destext = File.expand_path(dest + ext)
               return destext if FileTest.file? destext and FileTest.executable? destext
             end
           end
           return dest if FileTest.file? dest and FileTest.executable? dest
         end
       end
     end
     nil
   end
   module_function :which
 
   # Determine in a platform-specific way whether a path is absolute. This
   # defaults to the local platform if none is specified.
   #
   # Escape once for the string literal, and once for the regex.
   slash = '[\\\\/]'
   label = '[^\\\\/]+'
   AbsolutePathWindows = %r!^(?:(?:[A-Z]:#{slash})|(?:#{slash}#{slash}#{label}#{slash}#{label})|(?:#{slash}#{slash}\?#{slash}#{label}))!io
   AbsolutePathPosix   = %r!^/!
   def absolute_path?(path, platform=nil)
     # Ruby only sets File::ALT_SEPARATOR on Windows and the Ruby standard
     # library uses that to test what platform it's on.  Normally in Puppet we
     # would use Puppet.features.microsoft_windows?, but this method needs to
     # be called during the initialization of features so it can't depend on
     # that.
     platform ||= Puppet::Util::Platform.windows? ? :windows : :posix
     regex = case platform
             when :windows
               AbsolutePathWindows
             when :posix
               AbsolutePathPosix
             else
               raise Puppet::DevError, "unknown platform #{platform} in absolute_path"
             end
 
     !! (path =~ regex)
   end
   module_function :absolute_path?
 
   # Convert a path to a file URI
   def path_to_uri(path)
     return unless path
 
     params = { :scheme => 'file' }
 
     if Puppet.features.microsoft_windows?
       path = path.gsub(/\\/, '/')
 
       if unc = /^\/\/([^\/]+)(\/.+)/.match(path)
         params[:host] = unc[1]
         path = unc[2]
       elsif path =~ /^[a-z]:\//i
         path = '/' + path
       end
     end
 
     params[:path] = URI.escape(path)
 
     begin
       URI::Generic.build(params)
     rescue => detail
       raise Puppet::Error, "Failed to convert '#{path}' to URI: #{detail}", detail.backtrace
     end
   end
   module_function :path_to_uri
 
   # Get the path component of a URI
   def uri_to_path(uri)
     return unless uri.is_a?(URI)
 
     path = URI.unescape(uri.path)
 
     if Puppet.features.microsoft_windows? and uri.scheme == 'file'
       if uri.host
         path = "//#{uri.host}" + path # UNC
       else
         path.sub!(/^\//, '')
       end
     end
 
     path
   end
   module_function :uri_to_path
 
   def safe_posix_fork(stdin=$stdin, stdout=$stdout, stderr=$stderr, &block)
     child_pid = Kernel.fork do
       $stdin.reopen(stdin)
       $stdout.reopen(stdout)
       $stderr.reopen(stderr)
 
       3.upto(256){|fd| IO::new(fd).close rescue nil}
 
       block.call if block
     end
     child_pid
   end
   module_function :safe_posix_fork
 
   def memory
     unless defined?(@pmap)
       @pmap = which('pmap')
     end
     if @pmap
       %x{#{@pmap} #{Process.pid}| grep total}.chomp.sub(/^\s*total\s+/, '').sub(/K$/, '').to_i
     else
       0
     end
   end
 
   def symbolizehash(hash)
     newhash = {}
     hash.each do |name, val|
       name = name.intern if name.respond_to? :intern
       newhash[name] = val
     end
     newhash
   end
   module_function :symbolizehash
 
   # Just benchmark, with no logging.
   def thinmark
     seconds = Benchmark.realtime {
       yield
     }
 
     seconds
   end
 
   module_function :memory, :thinmark
 
   # Because IO#binread is only available in 1.9
   def binread(file)
     Puppet.deprecation_warning("Puppet::Util.binread is deprecated. Read the file without this method as it will be removed in a future version.")
     File.open(file, 'rb') { |f| f.read }
   end
   module_function :binread
 
   # utility method to get the current call stack and format it to a human-readable string (which some IDEs/editors
   # will recognize as links to the line numbers in the trace)
   def self.pretty_backtrace(backtrace = caller(1))
     backtrace.collect do |line|
       _, path, rest = /^(.*):(\d+.*)$/.match(line).to_a
       # If the path doesn't exist - like in one test, and like could happen in
       # the world - we should just tolerate it and carry on. --daniel 2012-09-05
       # Also, if we don't match, just include the whole line.
       if path
         path = Pathname(path).realpath rescue path
         "#{path}:#{rest}"
       else
         line
       end
     end.join("\n")
   end
 
   # Replace a file, securely.  This takes a block, and passes it the file
   # handle of a file open for writing.  Write the replacement content inside
   # the block and it will safely replace the target file.
   #
   # This method will make no changes to the target file until the content is
   # successfully written and the block returns without raising an error.
   #
   # As far as possible the state of the existing file, such as mode, is
   # preserved.  This works hard to avoid loss of any metadata, but will result
   # in an inode change for the file.
   #
   # Arguments: `filename`, `default_mode`
   #
   # The filename is the file we are going to replace.
   #
   # The default_mode is the mode to use when the target file doesn't already
   # exist; if the file is present we copy the existing mode/owner/group values
   # across. The default_mode can be expressed as an octal integer, a numeric string (ie '0664')
   # or a symbolic file mode.
 
   DEFAULT_POSIX_MODE = 0644
   DEFAULT_WINDOWS_MODE = nil
 
   def replace_file(file, default_mode, &block)
     raise Puppet::DevError, "replace_file requires a block" unless block_given?
 
     if default_mode
       unless valid_symbolic_mode?(default_mode)
         raise Puppet::DevError, "replace_file default_mode: #{default_mode} is invalid"
       end
 
       mode = symbolic_mode_to_int(normalize_symbolic_mode(default_mode))
     else
       if Puppet.features.microsoft_windows?
         mode = DEFAULT_WINDOWS_MODE
       else
         mode = DEFAULT_POSIX_MODE
       end
     end
 
     begin
       file     = Puppet::FileSystem.pathname(file)
       tempfile = Puppet::FileSystem::Uniquefile.new(Puppet::FileSystem.basename_string(file), Puppet::FileSystem.dir_string(file))
 
       # Set properties of the temporary file before we write the content, because
       # Tempfile doesn't promise to be safe from reading by other people, just
       # that it avoids races around creating the file.
       #
       # Our Windows emulation is pretty limited, and so we have to carefully
       # and specifically handle the platform, which has all sorts of magic.
       # So, unlike Unix, we don't pre-prep security; we use the default "quite
       # secure" tempfile permissions instead.  Magic happens later.
       if !Puppet.features.microsoft_windows?
         # Grab the current file mode, and fall back to the defaults.
         effective_mode =
         if Puppet::FileSystem.exist?(file)
           stat = Puppet::FileSystem.lstat(file)
           tempfile.chown(stat.uid, stat.gid)
           stat.mode
         else
           mode
         end
 
         if effective_mode
           # We only care about the bottom four slots, which make the real mode,
           # and not the rest of the platform stat call fluff and stuff.
           tempfile.chmod(effective_mode & 07777)
         end
       end
 
       # OK, now allow the caller to write the content of the file.
       yield tempfile
 
       # Now, make sure the data (which includes the mode) is safe on disk.
       tempfile.flush
       begin
         tempfile.fsync
       rescue NotImplementedError
         # fsync may not be implemented by Ruby on all platforms, but
         # there is absolutely no recovery path if we detect that.  So, we just
         # ignore the return code.
         #
         # However, don't be fooled: that is accepting that we are running in
         # an unsafe fashion.  If you are porting to a new platform don't stub
         # that out.
       end
 
       tempfile.close
 
       if Puppet.features.microsoft_windows?
         # Windows ReplaceFile needs a file to exist, so touch handles this
         if !Puppet::FileSystem.exist?(file)
           Puppet::FileSystem.touch(file)
           if mode
             Puppet::Util::Windows::Security.set_mode(mode, Puppet::FileSystem.path_string(file))
           end
         end
         # Yes, the arguments are reversed compared to the rename in the rest
         # of the world.
         Puppet::Util::Windows::File.replace_file(FileSystem.path_string(file), tempfile.path)
 
       else
         File.rename(tempfile.path, Puppet::FileSystem.path_string(file))
       end
     ensure
       # in case an error occurred before we renamed the temp file, make sure it
       # gets deleted
       if tempfile
         tempfile.close!
       end
     end
 
 
     # Ideally, we would now fsync the directory as well, but Ruby doesn't
     # have support for that, and it doesn't matter /that/ much...
 
     # Return something true, and possibly useful.
     file
   end
   module_function :replace_file
 
   # Executes a block of code, wrapped with some special exception handling.  Causes the ruby interpreter to
   #  exit if the block throws an exception.
   #
   # @api public
   # @param [String] message a message to log if the block fails
   # @param [Integer] code the exit code that the ruby interpreter should return if the block fails
   # @yield
   def exit_on_fail(message, code = 1)
     yield
   # First, we need to check and see if we are catching a SystemExit error.  These will be raised
   #  when we daemonize/fork, and they do not necessarily indicate a failure case.
   rescue SystemExit => err
     raise err
 
   # Now we need to catch *any* other kind of exception, because we may be calling third-party
   #  code (e.g. webrick), and we have no idea what they might throw.
   rescue Exception => err
     ## NOTE: when debugging spec failures, these two lines can be very useful
     #puts err.inspect
     #puts Puppet::Util.pretty_backtrace(err.backtrace)
     Puppet.log_exception(err, "Could not #{message}: #{err}")
     Puppet::Util::Log.force_flushqueue()
     exit(code)
   end
   module_function :exit_on_fail
 
   def deterministic_rand(seed,max)
     if defined?(Random) == 'constant' && Random.class == Class
       Random.new(seed).rand(max).to_s
     else
       srand(seed)
       result = rand(max).to_s
       srand()
       result
     end
   end
   module_function :deterministic_rand
-
-
-  #######################################################################################################
-  # Deprecated methods relating to process execution; these have been moved to Puppet::Util::Execution
-  #######################################################################################################
-
-  def execpipe(command, failonfail = true, &block)
-    Puppet.deprecation_warning("Puppet::Util.execpipe is deprecated; please use Puppet::Util::Execution.execpipe")
-    Puppet::Util::Execution.execpipe(command, failonfail, &block)
-  end
-  module_function :execpipe
-
-  def execfail(command, exception)
-    Puppet.deprecation_warning("Puppet::Util.execfail is deprecated; please use Puppet::Util::Execution.execfail")
-    Puppet::Util::Execution.execfail(command, exception)
-  end
-  module_function :execfail
-
-  def execute(*args)
-    Puppet.deprecation_warning("Puppet::Util.execute is deprecated; please use Puppet::Util::Execution.execute")
-
-    Puppet::Util::Execution.execute(*args)
-  end
-  module_function :execute
-
 end
 end
 
 
 require 'puppet/util/errors'
 require 'puppet/util/methodhelper'
 require 'puppet/util/metaid'
 require 'puppet/util/classgen'
 require 'puppet/util/docs'
 require 'puppet/util/execution'
 require 'puppet/util/logging'
 require 'puppet/util/package'
 require 'puppet/util/warnings'
diff --git a/spec/unit/util/execution_spec.rb b/spec/unit/util/execution_spec.rb
index 6a4bee490..d64ed705d 100755
--- a/spec/unit/util/execution_spec.rb
+++ b/spec/unit/util/execution_spec.rb
@@ -1,630 +1,630 @@
 #! /usr/bin/env ruby
 require 'spec_helper'
 require 'puppet/file_system/uniquefile'
 
 describe Puppet::Util::Execution do
   include Puppet::Util::Execution
   # utility methods to help us test some private methods without being quite so verbose
   def call_exec_posix(command, arguments, stdin, stdout, stderr)
     Puppet::Util::Execution.send(:execute_posix, command, arguments, stdin, stdout, stderr)
   end
   def call_exec_windows(command, arguments, stdin, stdout, stderr)
     Puppet::Util::Execution.send(:execute_windows, command, arguments, stdin, stdout, stderr)
   end
 
   describe "execution methods" do
     let(:pid) { 5501 }
     let(:process_handle) { 0xDEADBEEF }
     let(:thread_handle) { 0xCAFEBEEF }
     let(:proc_info_stub) { stub 'processinfo', :process_handle => process_handle, :thread_handle => thread_handle, :process_id => pid}
     let(:null_file) { Puppet.features.microsoft_windows? ? 'NUL' : '/dev/null' }
 
     def stub_process_wait(exitstatus)
       if Puppet.features.microsoft_windows?
         Puppet::Util::Windows::Process.stubs(:wait_process).with(process_handle).returns(exitstatus)
         FFI::WIN32.stubs(:CloseHandle).with(process_handle)
         FFI::WIN32.stubs(:CloseHandle).with(thread_handle)
       else
         Process.stubs(:waitpid2).with(pid).returns([pid, stub('child_status', :exitstatus => exitstatus)])
       end
     end
 
     describe "#execute_posix (stubs)", :unless => Puppet.features.microsoft_windows? do
       before :each do
         # Most of the things this method does are bad to do during specs. :/
         Kernel.stubs(:fork).returns(pid).yields
         Process.stubs(:setsid)
         Kernel.stubs(:exec)
         Puppet::Util::SUIDManager.stubs(:change_user)
         Puppet::Util::SUIDManager.stubs(:change_group)
 
         # ensure that we don't really close anything!
         (0..256).each {|n| IO.stubs(:new) }
 
         $stdin.stubs(:reopen)
         $stdout.stubs(:reopen)
         $stderr.stubs(:reopen)
 
         @stdin  = File.open(null_file, 'r')
         @stdout = Puppet::FileSystem::Uniquefile.new('stdout')
         @stderr = File.open(null_file, 'w')
 
         # there is a danger here that ENV will be modified by exec_posix.  Normally it would only affect the ENV
         #  of a forked process, but here, we're stubbing Kernel.fork, so the method has the ability to override the
         #  "real" ENV.  To guard against this, we'll capture a snapshot of ENV before each test.
         @saved_env = ENV.to_hash
 
         # Now, we're going to effectively "mock" the magic ruby 'ENV' variable by creating a local definition of it
         #  inside of the module we're testing.
         Puppet::Util::Execution::ENV = {}
       end
 
       after :each do
         # And here we remove our "mock" version of 'ENV', which will allow us to validate that the real ENV has been
         #  left unharmed.
         Puppet::Util::Execution.send(:remove_const, :ENV)
 
         # capture the current environment and make sure it's the same as it was before the test
         cur_env = ENV.to_hash
 
         # we will get some fairly useless output if we just use the raw == operator on the hashes here, so we'll
         #  be a bit more explicit and laborious in the name of making the error more useful...
         @saved_env.each_pair { |key,val| cur_env[key].should == val }
         (cur_env.keys - @saved_env.keys).should == []
 
       end
 
 
       it "should fork a child process to execute the command" do
         Kernel.expects(:fork).returns(pid).yields
         Kernel.expects(:exec).with('test command')
 
         call_exec_posix('test command', {}, @stdin, @stdout, @stderr)
       end
 
       it "should start a new session group" do
         Process.expects(:setsid)
 
         call_exec_posix('test command', {}, @stdin, @stdout, @stderr)
       end
 
       it "should permanently change to the correct user and group if specified" do
         Puppet::Util::SUIDManager.expects(:change_group).with(55, true)
         Puppet::Util::SUIDManager.expects(:change_user).with(50, true)
 
         call_exec_posix('test command', {:uid => 50, :gid => 55}, @stdin, @stdout, @stderr)
       end
 
       it "should exit failure if there is a problem execing the command" do
         Kernel.expects(:exec).with('test command').raises("failed to execute!")
         Puppet::Util::Execution.stubs(:puts)
         Puppet::Util::Execution.expects(:exit!).with(1)
 
         call_exec_posix('test command', {}, @stdin, @stdout, @stderr)
       end
 
       it "should properly execute commands specified as arrays" do
         Kernel.expects(:exec).with('test command', 'with', 'arguments')
 
         call_exec_posix(['test command', 'with', 'arguments'], {:uid => 50, :gid => 55}, @stdin, @stdout, @stderr)
       end
 
       it "should properly execute string commands with embedded newlines" do
         Kernel.expects(:exec).with("/bin/echo 'foo' ; \n /bin/echo 'bar' ;")
 
         call_exec_posix("/bin/echo 'foo' ; \n /bin/echo 'bar' ;", {:uid => 50, :gid => 55}, @stdin, @stdout, @stderr)
       end
 
       it "should return the pid of the child process" do
         call_exec_posix('test command', {}, @stdin, @stdout, @stderr).should == pid
       end
     end
 
     describe "#execute_windows (stubs)", :if => Puppet.features.microsoft_windows? do
       before :each do
         Process.stubs(:create).returns(proc_info_stub)
         stub_process_wait(0)
 
         @stdin  = File.open(null_file, 'r')
         @stdout = Puppet::FileSystem::Uniquefile.new('stdout')
         @stderr = File.open(null_file, 'w')
       end
 
       it "should create a new process for the command" do
         Process.expects(:create).with(
           :command_line => "test command",
           :startup_info => {:stdin => @stdin, :stdout => @stdout, :stderr => @stderr},
           :close_handles => false
         ).returns(proc_info_stub)
 
         call_exec_windows('test command', {}, @stdin, @stdout, @stderr)
       end
 
       it "should return the process info of the child process" do
         call_exec_windows('test command', {}, @stdin, @stdout, @stderr).should == proc_info_stub
       end
 
       it "should quote arguments containing spaces if command is specified as an array" do
         Process.expects(:create).with do |args|
           args[:command_line] == '"test command" with some "arguments \"with spaces"'
         end.returns(proc_info_stub)
 
         call_exec_windows(['test command', 'with', 'some', 'arguments "with spaces'], {}, @stdin, @stdout, @stderr)
       end
     end
 
     describe "#execute (stubs)" do
       before :each do
         stub_process_wait(0)
       end
 
       describe "when an execution stub is specified" do
         before :each do
           Puppet::Util::ExecutionStub.set do |command,args,stdin,stdout,stderr|
             "execution stub output"
           end
         end
 
         it "should call the block on the stub" do
           Puppet::Util::Execution.execute("/usr/bin/run_my_execute_stub").should == "execution stub output"
         end
 
         it "should not actually execute anything" do
           Puppet::Util::Execution.expects(:execute_posix).never
           Puppet::Util::Execution.expects(:execute_windows).never
 
           Puppet::Util::Execution.execute("/usr/bin/run_my_execute_stub")
         end
       end
 
       describe "when setting up input and output files" do
         include PuppetSpec::Files
         let(:executor) { Puppet.features.microsoft_windows? ? 'execute_windows' : 'execute_posix' }
         let(:rval) { Puppet.features.microsoft_windows? ? proc_info_stub : pid }
 
         before :each do
           Puppet::Util::Execution.stubs(:wait_for_output)
         end
 
         it "should set stdin to the stdinfile if specified" do
           input = tmpfile('stdin')
           FileUtils.touch(input)
 
           Puppet::Util::Execution.expects(executor).with do |_,_,stdin,_,_|
             stdin.path == input
           end.returns(rval)
 
           Puppet::Util::Execution.execute('test command', :stdinfile => input)
         end
 
         it "should set stdin to the null file if not specified" do
           Puppet::Util::Execution.expects(executor).with do |_,_,stdin,_,_|
             stdin.path == null_file
           end.returns(rval)
 
           Puppet::Util::Execution.execute('test command')
         end
 
         describe "when squelch is set" do
           it "should set stdout and stderr to the null file" do
             Puppet::Util::Execution.expects(executor).with do |_,_,_,stdout,stderr|
               stdout.path == null_file and stderr.path == null_file
             end.returns(rval)
 
             Puppet::Util::Execution.execute('test command', :squelch => true)
           end
         end
 
         describe "when squelch is not set" do
           it "should set stdout to a temporary output file" do
             outfile = Puppet::FileSystem::Uniquefile.new('stdout')
             Puppet::FileSystem::Uniquefile.stubs(:new).returns(outfile)
 
             Puppet::Util::Execution.expects(executor).with do |_,_,_,stdout,_|
               stdout.path == outfile.path
             end.returns(rval)
 
             Puppet::Util::Execution.execute('test command', :squelch => false)
           end
 
           it "should set stderr to the same file as stdout if combine is true" do
             outfile = Puppet::FileSystem::Uniquefile.new('stdout')
             Puppet::FileSystem::Uniquefile.stubs(:new).returns(outfile)
 
             Puppet::Util::Execution.expects(executor).with do |_,_,_,stdout,stderr|
               stdout.path == outfile.path and stderr.path == outfile.path
             end.returns(rval)
 
             Puppet::Util::Execution.execute('test command', :squelch => false, :combine => true)
           end
 
           it "should set stderr to the null device if combine is false" do
             outfile = Puppet::FileSystem::Uniquefile.new('stdout')
             Puppet::FileSystem::Uniquefile.stubs(:new).returns(outfile)
 
             Puppet::Util::Execution.expects(executor).with do |_,_,_,stdout,stderr|
               stdout.path == outfile.path and stderr.path == null_file
             end.returns(rval)
 
             Puppet::Util::Execution.execute('test command', :squelch => false, :combine => false)
           end
 
           it "should combine stdout and stderr if combine is true" do
             outfile = Puppet::FileSystem::Uniquefile.new('stdout')
             Puppet::FileSystem::Uniquefile.stubs(:new).returns(outfile)
 
             Puppet::Util::Execution.expects(executor).with do |_,_,_,stdout,stderr|
               stdout.path == outfile.path and stderr.path == outfile.path
             end.returns(rval)
 
             Puppet::Util::Execution.execute('test command', :combine => true)
           end
 
           it "should default combine to true when no options are specified" do
             outfile = Puppet::FileSystem::Uniquefile.new('stdout')
             Puppet::FileSystem::Uniquefile.stubs(:new).returns(outfile)
 
             Puppet::Util::Execution.expects(executor).with do |_,_,_,stdout,stderr|
               stdout.path == outfile.path and stderr.path == outfile.path
             end.returns(rval)
 
             Puppet::Util::Execution.execute('test command')
           end
 
           it "should default combine to false when options are specified, but combine is not" do
             outfile = Puppet::FileSystem::Uniquefile.new('stdout')
             Puppet::FileSystem::Uniquefile.stubs(:new).returns(outfile)
 
             Puppet::Util::Execution.expects(executor).with do |_,_,_,stdout,stderr|
               stdout.path == outfile.path and stderr.path == null_file
             end.returns(rval)
 
             Puppet::Util::Execution.execute('test command', :failonfail => false)
           end
 
           it "should default combine to false when an empty hash of options is specified" do
             outfile = Puppet::FileSystem::Uniquefile.new('stdout')
             Puppet::FileSystem::Uniquefile.stubs(:new).returns(outfile)
 
             Puppet::Util::Execution.expects(executor).with do |_,_,_,stdout,stderr|
               stdout.path == outfile.path and stderr.path == null_file
             end.returns(rval)
 
             Puppet::Util::Execution.execute('test command', {})
           end
         end
       end
 
       describe "on Windows", :if => Puppet.features.microsoft_windows? do
         it "should always close the process and thread handles" do
           Puppet::Util::Execution.stubs(:execute_windows).returns(proc_info_stub)
 
           Puppet::Util::Windows::Process.expects(:wait_process).with(process_handle).raises('whatever')
           FFI::WIN32.expects(:CloseHandle).with(thread_handle)
           FFI::WIN32.expects(:CloseHandle).with(process_handle)
 
           expect { Puppet::Util::Execution.execute('test command') }.to raise_error(RuntimeError)
         end
 
         it "should return the correct exit status even when exit status is greater than 256" do
           real_exit_status = 3010
 
           Puppet::Util::Execution.stubs(:execute_windows).returns(proc_info_stub)
           stub_process_wait(real_exit_status)
           $CHILD_STATUS.stubs(:exitstatus).returns(real_exit_status % 256) # The exitstatus is changed to be mod 256 so that ruby can fit it into 8 bits.
 
           Puppet::Util::Execution.execute('test command', :failonfail => false).exitstatus.should == real_exit_status
         end
       end
     end
 
     describe "#execute (posix locale)", :unless => Puppet.features.microsoft_windows?  do
 
       before :each do
         # there is a danger here that ENV will be modified by exec_posix.  Normally it would only affect the ENV
         #  of a forked process, but, in some of the previous tests in this file we're stubbing Kernel.fork., which could
         #  allow the method to override the "real" ENV.  This shouldn't be a problem for these tests because they are
         #  not stubbing Kernel.fork, but, better safe than sorry... so, to guard against this, we'll capture a snapshot
         #  of ENV before each test.
         @saved_env = ENV.to_hash
       end
 
       after :each do
         # capture the current environment and make sure it's the same as it was before the test
         cur_env = ENV.to_hash
         # we will get some fairly useless output if we just use the raw == operator on the hashes here, so we'll
         #  be a bit more explicit and laborious in the name of making the error more useful...
         @saved_env.each_pair { |key,val| cur_env[key].should == val }
         (cur_env.keys - @saved_env.keys).should == []
       end
 
 
       # build up a printf-style string that contains a command to get the value of an environment variable
       # from the operating system.  We can substitute into this with the names of the desired environment variables later.
       get_env_var_cmd = 'echo $%s'
 
       # a sentinel value that we can use to emulate what locale environment variables might be set to on an international
       # system.
       lang_sentinel_value = "en_US.UTF-8"
       # a temporary hash that contains sentinel values for each of the locale environment variables that we override in
       # "execute"
       locale_sentinel_env = {}
       Puppet::Util::POSIX::LOCALE_ENV_VARS.each { |var| locale_sentinel_env[var] = lang_sentinel_value }
 
       it "should override the locale environment variables when :override_locale is not set (defaults to true)" do
         # temporarily override the locale environment vars with a sentinel value, so that we can confirm that
         # execute is actually setting them.
         Puppet::Util.withenv(locale_sentinel_env) do
           Puppet::Util::POSIX::LOCALE_ENV_VARS.each do |var|
             # we expect that all of the POSIX vars will have been cleared except for LANG and LC_ALL
             expected_value = (['LANG', 'LC_ALL'].include?(var)) ? "C" : ""
-            Puppet::Util::execute(get_env_var_cmd % var).strip.should == expected_value
+            Puppet::Util::Execution.execute(get_env_var_cmd % var).strip.should == expected_value
           end
         end
       end
 
       it "should override the LANG environment variable when :override_locale is set to true" do
         # temporarily override the locale environment vars with a sentinel value, so that we can confirm that
         # execute is actually setting them.
         Puppet::Util.withenv(locale_sentinel_env) do
           Puppet::Util::POSIX::LOCALE_ENV_VARS.each do |var|
             # we expect that all of the POSIX vars will have been cleared except for LANG and LC_ALL
             expected_value = (['LANG', 'LC_ALL'].include?(var)) ? "C" : ""
-            Puppet::Util::execute(get_env_var_cmd % var, {:override_locale => true}).strip.should == expected_value
+            Puppet::Util::Execution.execute(get_env_var_cmd % var, {:override_locale => true}).strip.should == expected_value
           end
         end
       end
 
       it "should *not* override the LANG environment variable when :override_locale is set to false" do
         # temporarily override the locale environment vars with a sentinel value, so that we can confirm that
         # execute is not setting them.
         Puppet::Util.withenv(locale_sentinel_env) do
           Puppet::Util::POSIX::LOCALE_ENV_VARS.each do |var|
-            Puppet::Util::execute(get_env_var_cmd % var, {:override_locale => false}).strip.should == lang_sentinel_value
+            Puppet::Util::Execution.execute(get_env_var_cmd % var, {:override_locale => false}).strip.should == lang_sentinel_value
           end
         end
       end
 
       it "should have restored the LANG and locale environment variables after execution" do
         # we'll do this once without any sentinel values, to give us a little more test coverage
         orig_env_vals = {}
         Puppet::Util::POSIX::LOCALE_ENV_VARS.each do |var|
           orig_env_vals[var] = ENV[var]
         end
         # now we can really execute any command--doesn't matter what it is...
-        Puppet::Util::execute(get_env_var_cmd % 'anything', {:override_locale => true})
+        Puppet::Util::Execution.execute(get_env_var_cmd % 'anything', {:override_locale => true})
         # now we check and make sure the original environment was restored
         Puppet::Util::POSIX::LOCALE_ENV_VARS.each do |var|
           ENV[var].should == orig_env_vals[var]
         end
 
         # now, once more... but with our sentinel values
         Puppet::Util.withenv(locale_sentinel_env) do
           # now we can really execute any command--doesn't matter what it is...
-          Puppet::Util::execute(get_env_var_cmd % 'anything', {:override_locale => true})
+          Puppet::Util::Execution.execute(get_env_var_cmd % 'anything', {:override_locale => true})
           # now we check and make sure the original environment was restored
           Puppet::Util::POSIX::LOCALE_ENV_VARS.each do |var|
             ENV[var].should == locale_sentinel_env[var]
           end
         end
 
       end
     end
 
     describe "#execute (posix user env vars)", :unless => Puppet.features.microsoft_windows?  do
       # build up a printf-style string that contains a command to get the value of an environment variable
       # from the operating system.  We can substitute into this with the names of the desired environment variables later.
       get_env_var_cmd = 'echo $%s'
 
       # a sentinel value that we can use to emulate what locale environment variables might be set to on an international
       # system.
       user_sentinel_value = "Abracadabra"
       # a temporary hash that contains sentinel values for each of the locale environment variables that we override in
       # "execute"
       user_sentinel_env = {}
       Puppet::Util::POSIX::USER_ENV_VARS.each { |var| user_sentinel_env[var] = user_sentinel_value }
 
       it "should unset user-related environment vars during execution" do
         # first we set up a temporary execution environment with sentinel values for the user-related environment vars
         # that we care about.
         Puppet::Util.withenv(user_sentinel_env) do
           # with this environment, we loop over the vars in question
           Puppet::Util::POSIX::USER_ENV_VARS.each do |var|
             # ensure that our temporary environment is set up as we expect
             ENV[var].should == user_sentinel_env[var]
 
             # run an "exec" via the provider and ensure that it unsets the vars
-            Puppet::Util::execute(get_env_var_cmd % var).strip.should == ""
+            Puppet::Util::Execution.execute(get_env_var_cmd % var).strip.should == ""
 
             # ensure that after the exec, our temporary env is still intact
             ENV[var].should == user_sentinel_env[var]
           end
 
         end
       end
 
       it "should have restored the user-related environment variables after execution" do
         # we'll do this once without any sentinel values, to give us a little more test coverage
         orig_env_vals = {}
         Puppet::Util::POSIX::USER_ENV_VARS.each do |var|
           orig_env_vals[var] = ENV[var]
         end
         # now we can really execute any command--doesn't matter what it is...
-        Puppet::Util::execute(get_env_var_cmd % 'anything')
+        Puppet::Util::Execution.execute(get_env_var_cmd % 'anything')
         # now we check and make sure the original environment was restored
         Puppet::Util::POSIX::USER_ENV_VARS.each do |var|
           ENV[var].should == orig_env_vals[var]
         end
 
         # now, once more... but with our sentinel values
         Puppet::Util.withenv(user_sentinel_env) do
           # now we can really execute any command--doesn't matter what it is...
-          Puppet::Util::execute(get_env_var_cmd % 'anything')
+          Puppet::Util::Execution.execute(get_env_var_cmd % 'anything')
           # now we check and make sure the original environment was restored
           Puppet::Util::POSIX::USER_ENV_VARS.each do |var|
             ENV[var].should == user_sentinel_env[var]
           end
         end
 
       end
     end
 
     describe "after execution" do
       before :each do
         stub_process_wait(0)
 
         if Puppet.features.microsoft_windows?
           Puppet::Util::Execution.stubs(:execute_windows).returns(proc_info_stub)
         else
           Puppet::Util::Execution.stubs(:execute_posix).returns(pid)
         end
       end
 
       it "should wait for the child process to exit" do
         Puppet::Util::Execution.stubs(:wait_for_output)
 
         Puppet::Util::Execution.execute('test command')
       end
 
       it "should close the stdin/stdout/stderr files used by the child" do
         stdin = mock 'file', :close
         stdout = mock 'file', :close
         stderr = mock 'file', :close
 
         File.expects(:open).
             times(3).
             returns(stdin).
             then.returns(stdout).
             then.returns(stderr)
 
         Puppet::Util::Execution.execute('test command', {:squelch => true, :combine => false})
       end
 
       it "should read and return the output if squelch is false" do
         stdout = Puppet::FileSystem::Uniquefile.new('test')
         Puppet::FileSystem::Uniquefile.stubs(:new).returns(stdout)
         stdout.write("My expected command output")
 
         Puppet::Util::Execution.execute('test command').should == "My expected command output"
       end
 
       it "should not read the output if squelch is true" do
         stdout = Puppet::FileSystem::Uniquefile.new('test')
         Puppet::FileSystem::Uniquefile.stubs(:new).returns(stdout)
         stdout.write("My expected command output")
 
         Puppet::Util::Execution.execute('test command', :squelch => true).should == ''
       end
 
       it "should delete the file used for output if squelch is false" do
         stdout = Puppet::FileSystem::Uniquefile.new('test')
         path = stdout.path
         Puppet::FileSystem::Uniquefile.stubs(:new).returns(stdout)
 
         Puppet::Util::Execution.execute('test command')
 
         Puppet::FileSystem.exist?(path).should be_false
       end
 
       it "should not raise an error if the file is open" do
         stdout = Puppet::FileSystem::Uniquefile.new('test')
         Puppet::FileSystem::Uniquefile.stubs(:new).returns(stdout)
         file = File.new(stdout.path, 'r')
 
-        Puppet::Util.execute('test command')
+        Puppet::Util::Execution.execute('test command')
       end
 
       it "should raise an error if failonfail is true and the child failed" do
         stub_process_wait(1)
 
         expect {
           subject.execute('fail command', :failonfail => true)
         }.to raise_error(Puppet::ExecutionFailure, /Execution of 'fail command' returned 1/)
       end
 
       it "should not raise an error if failonfail is false and the child failed" do
         stub_process_wait(1)
 
         subject.execute('fail command', :failonfail => false)
       end
 
       it "should not raise an error if failonfail is true and the child succeeded" do
         stub_process_wait(0)
 
         subject.execute('fail command', :failonfail => true)
       end
 
       it "should not raise an error if failonfail is false and the child succeeded" do
         stub_process_wait(0)
 
         subject.execute('fail command', :failonfail => false)
       end
 
       it "should default failonfail to true when no options are specified" do
         stub_process_wait(1)
 
         expect {
           subject.execute('fail command')
         }.to raise_error(Puppet::ExecutionFailure, /Execution of 'fail command' returned 1/)
       end
 
       it "should default failonfail to false when options are specified, but failonfail is not" do
         stub_process_wait(1)
 
         subject.execute('fail command', { :combine => true })
       end
 
       it "should default failonfail to false when an empty hash of options is specified" do
         stub_process_wait(1)
 
         subject.execute('fail command', {})
       end
 
       it "should raise an error if a nil option is specified" do
         expect {
           Puppet::Util::Execution.execute('fail command', nil)
         }.to raise_error(TypeError, /(can\'t convert|no implicit conversion of) nil into Hash/)
       end
     end
   end
 
   describe "#execpipe" do
     it "should execute a string as a string" do
       Puppet::Util::Execution.expects(:open).with('| echo hello 2>&1').returns('hello')
       Puppet::Util::Execution.expects(:exitstatus).returns(0)
       Puppet::Util::Execution.execpipe('echo hello').should == 'hello'
     end
 
     it "should print meaningful debug message for string argument" do
       Puppet::Util::Execution.expects(:debug).with("Executing 'echo hello'")
       Puppet::Util::Execution.expects(:open).with('| echo hello 2>&1').returns('hello')
       Puppet::Util::Execution.expects(:exitstatus).returns(0)
       Puppet::Util::Execution.execpipe('echo hello')
     end
 
     it "should print meaningful debug message for array argument" do
       Puppet::Util::Execution.expects(:debug).with("Executing 'echo hello'")
       Puppet::Util::Execution.expects(:open).with('| echo hello 2>&1').returns('hello')
       Puppet::Util::Execution.expects(:exitstatus).returns(0)
       Puppet::Util::Execution.execpipe(['echo','hello'])
     end
 
     it "should execute an array by pasting together with spaces" do
       Puppet::Util::Execution.expects(:open).with('| echo hello 2>&1').returns('hello')
       Puppet::Util::Execution.expects(:exitstatus).returns(0)
       Puppet::Util::Execution.execpipe(['echo', 'hello']).should == 'hello'
     end
 
     it "should fail if asked to fail, and the child does" do
       Puppet::Util::Execution.stubs(:open).with('| echo hello 2>&1').returns('error message')
       Puppet::Util::Execution.expects(:exitstatus).returns(1)
       expect { Puppet::Util::Execution.execpipe('echo hello') }.
         to raise_error Puppet::ExecutionFailure, /error message/
     end
 
     it "should not fail if asked not to fail, and the child does" do
       Puppet::Util::Execution.stubs(:open).returns('error message')
       Puppet::Util::Execution.execpipe('echo hello', false).should == 'error message'
     end
   end
 end
diff --git a/spec/unit/util_spec.rb b/spec/unit/util_spec.rb
index 1c6f30367..f0843d3f4 100755
--- a/spec/unit/util_spec.rb
+++ b/spec/unit/util_spec.rb
@@ -1,577 +1,560 @@
 #!/usr/bin/env ruby
 
 require 'spec_helper'
 
 describe Puppet::Util do
   include PuppetSpec::Files
 
   if Puppet.features.microsoft_windows?
     def set_mode(mode, file)
       Puppet::Util::Windows::Security.set_mode(mode, file)
     end
 
     def get_mode(file)
       Puppet::Util::Windows::Security.get_mode(file) & 07777
     end
   else
     def set_mode(mode, file)
       File.chmod(mode, file)
     end
 
     def get_mode(file)
       Puppet::FileSystem.lstat(file).mode & 07777
     end
   end
 
   describe "#withenv" do
     before :each do
       @original_path = ENV["PATH"]
       @new_env = {:PATH => "/some/bogus/path"}
     end
 
     it "should change environment variables within the block then reset environment variables to their original values" do
       Puppet::Util.withenv @new_env do
         ENV["PATH"].should == "/some/bogus/path"
       end
       ENV["PATH"].should == @original_path
     end
 
     it "should reset environment variables to their original values even if the block fails" do
       begin
         Puppet::Util.withenv @new_env do
           ENV["PATH"].should == "/some/bogus/path"
           raise "This is a failure"
         end
       rescue
       end
       ENV["PATH"].should == @original_path
     end
 
     it "should reset environment variables even when they are set twice" do
       # Setting Path & Environment parameters in Exec type can cause weirdness
       @new_env["PATH"] = "/someother/bogus/path"
       Puppet::Util.withenv @new_env do
         # When assigning duplicate keys, can't guarantee order of evaluation
         ENV["PATH"].should =~ /\/some.*\/bogus\/path/
       end
       ENV["PATH"].should == @original_path
     end
 
     it "should remove any new environment variables after the block ends" do
       @new_env[:FOO] = "bar"
       ENV["FOO"] = nil
       Puppet::Util.withenv @new_env do
         ENV["FOO"].should == "bar"
       end
       ENV["FOO"].should == nil
     end
 
   end
 
   describe "#absolute_path?" do
     describe "on posix systems", :as_platform => :posix do
       it "should default to the platform of the local system" do
         Puppet::Util.should be_absolute_path('/foo')
         Puppet::Util.should_not be_absolute_path('C:/foo')
       end
     end
 
     describe "on windows", :as_platform => :windows do
       it "should default to the platform of the local system" do
         Puppet::Util.should be_absolute_path('C:/foo')
         Puppet::Util.should_not be_absolute_path('/foo')
       end
     end
 
     describe "when using platform :posix" do
       %w[/ /foo /foo/../bar //foo //Server/Foo/Bar //?/C:/foo/bar /\Server/Foo /foo//bar/baz].each do |path|
         it "should return true for #{path}" do
           Puppet::Util.should be_absolute_path(path, :posix)
         end
       end
 
       %w[. ./foo \foo C:/foo \\Server\Foo\Bar \\?\C:\foo\bar \/?/foo\bar \/Server/foo foo//bar/baz].each do |path|
         it "should return false for #{path}" do
           Puppet::Util.should_not be_absolute_path(path, :posix)
         end
       end
     end
 
     describe "when using platform :windows" do
       %w[C:/foo C:\foo \\\\Server\Foo\Bar \\\\?\C:\foo\bar //Server/Foo/Bar //?/C:/foo/bar /\?\C:/foo\bar \/Server\Foo/Bar c:/foo//bar//baz].each do |path|
         it "should return true for #{path}" do
           Puppet::Util.should be_absolute_path(path, :windows)
         end
       end
 
       %w[/ . ./foo \foo /foo /foo/../bar //foo C:foo/bar foo//bar/baz].each do |path|
         it "should return false for #{path}" do
           Puppet::Util.should_not be_absolute_path(path, :windows)
         end
       end
     end
   end
 
   describe "#path_to_uri" do
     %w[. .. foo foo/bar foo/../bar].each do |path|
       it "should reject relative path: #{path}" do
         lambda { Puppet::Util.path_to_uri(path) }.should raise_error(Puppet::Error)
       end
     end
 
     it "should perform URI escaping" do
       Puppet::Util.path_to_uri("/foo bar").path.should == "/foo%20bar"
     end
 
     describe "when using platform :posix" do
       before :each do
         Puppet.features.stubs(:posix).returns true
         Puppet.features.stubs(:microsoft_windows?).returns false
       end
 
       %w[/ /foo /foo/../bar].each do |path|
         it "should convert #{path} to URI" do
           Puppet::Util.path_to_uri(path).path.should == path
         end
       end
     end
 
     describe "when using platform :windows" do
       before :each do
         Puppet.features.stubs(:posix).returns false
         Puppet.features.stubs(:microsoft_windows?).returns true
       end
 
       it "should normalize backslashes" do
         Puppet::Util.path_to_uri('c:\\foo\\bar\\baz').path.should == '/' + 'c:/foo/bar/baz'
       end
 
       %w[C:/ C:/foo/bar].each do |path|
         it "should convert #{path} to absolute URI" do
           Puppet::Util.path_to_uri(path).path.should == '/' + path
         end
       end
 
       %w[share C$].each do |path|
         it "should convert UNC #{path} to absolute URI" do
           uri = Puppet::Util.path_to_uri("\\\\server\\#{path}")
           uri.host.should == 'server'
           uri.path.should == '/' + path
         end
       end
     end
   end
 
   describe ".uri_to_path" do
     require 'uri'
 
     it "should strip host component" do
       Puppet::Util.uri_to_path(URI.parse('http://foo/bar')).should == '/bar'
     end
 
     it "should accept puppet URLs" do
       Puppet::Util.uri_to_path(URI.parse('puppet:///modules/foo')).should == '/modules/foo'
     end
 
     it "should return unencoded path" do
       Puppet::Util.uri_to_path(URI.parse('http://foo/bar%20baz')).should == '/bar baz'
     end
 
     it "should be nil-safe" do
       Puppet::Util.uri_to_path(nil).should be_nil
     end
 
     describe "when using platform :posix",:if => Puppet.features.posix? do
       it "should accept root" do
         Puppet::Util.uri_to_path(URI.parse('file:/')).should == '/'
       end
 
       it "should accept single slash" do
         Puppet::Util.uri_to_path(URI.parse('file:/foo/bar')).should == '/foo/bar'
       end
 
       it "should accept triple slashes" do
         Puppet::Util.uri_to_path(URI.parse('file:///foo/bar')).should == '/foo/bar'
       end
     end
 
     describe "when using platform :windows", :if => Puppet.features.microsoft_windows? do
       it "should accept root" do
         Puppet::Util.uri_to_path(URI.parse('file:/C:/')).should == 'C:/'
       end
 
       it "should accept single slash" do
         Puppet::Util.uri_to_path(URI.parse('file:/C:/foo/bar')).should == 'C:/foo/bar'
       end
 
       it "should accept triple slashes" do
         Puppet::Util.uri_to_path(URI.parse('file:///C:/foo/bar')).should == 'C:/foo/bar'
       end
 
       it "should accept file scheme with double slashes as a UNC path" do
         Puppet::Util.uri_to_path(URI.parse('file://host/share/file')).should == '//host/share/file'
       end
     end
   end
 
   describe "safe_posix_fork" do
     let(:pid) { 5501 }
 
     before :each do
       # Most of the things this method does are bad to do during specs. :/
       Kernel.stubs(:fork).returns(pid).yields
 
       $stdin.stubs(:reopen)
       $stdout.stubs(:reopen)
       $stderr.stubs(:reopen)
 
       # ensure that we don't really close anything!
       (0..256).each {|n| IO.stubs(:new) }
     end
 
     it "should close all open file descriptors except stdin/stdout/stderr" do
       # This is ugly, but I can't really think of a better way to do it without
       # letting it actually close fds, which seems risky
       (0..2).each {|n| IO.expects(:new).with(n).never}
       (3..256).each {|n| IO.expects(:new).with(n).returns mock('io', :close) }
 
       Puppet::Util.safe_posix_fork
     end
 
     it "should fork a child process to execute the block" do
       Kernel.expects(:fork).returns(pid).yields
 
       Puppet::Util.safe_posix_fork do
         message = "Fork this!"
       end
     end
 
     it "should return the pid of the child process" do
       Puppet::Util.safe_posix_fork.should == pid
     end
   end
 
   describe "#which" do
     let(:base) { File.expand_path('/bin') }
     let(:path) { File.join(base, 'foo') }
 
     before :each do
       FileTest.stubs(:file?).returns false
       FileTest.stubs(:file?).with(path).returns true
 
       FileTest.stubs(:executable?).returns false
       FileTest.stubs(:executable?).with(path).returns true
     end
 
     it "should accept absolute paths" do
       Puppet::Util.which(path).should == path
     end
 
     it "should return nil if no executable found" do
       Puppet::Util.which('doesnotexist').should be_nil
     end
 
     it "should warn if the user's HOME is not set but their PATH contains a ~" do
       env_path = %w[~/bin /usr/bin /bin].join(File::PATH_SEPARATOR)
 
       env = {:HOME => nil, :PATH => env_path}
       env.merge!({:HOMEDRIVE => nil, :USERPROFILE => nil}) if Puppet.features.microsoft_windows?
 
       Puppet::Util.withenv(env) do
         Puppet::Util::Warnings.expects(:warnonce).once
         Puppet::Util.which('foo')
       end
     end
 
     it "should reject directories" do
       Puppet::Util.which(base).should be_nil
     end
 
     it "should ignore ~user directories if the user doesn't exist" do
       # Windows treats *any* user as a "user that doesn't exist", which means
       # that this will work correctly across all our platforms, and should
       # behave consistently.  If they ever implement it correctly (eg: to do
       # the lookup for real) it should just work transparently.
       baduser = 'if_this_user_exists_I_will_eat_my_hat'
       Puppet::Util.withenv("PATH" => "~#{baduser}#{File::PATH_SEPARATOR}#{base}") do
         Puppet::Util.which('foo').should == path
       end
     end
 
     describe "on POSIX systems" do
       before :each do
         Puppet.features.stubs(:posix?).returns true
         Puppet.features.stubs(:microsoft_windows?).returns false
       end
 
       it "should walk the search PATH returning the first executable" do
         ENV.stubs(:[]).with('PATH').returns(File.expand_path('/bin'))
 
         Puppet::Util.which('foo').should == path
       end
     end
 
     describe "on Windows systems" do
       let(:path) { File.expand_path(File.join(base, 'foo.CMD')) }
 
       before :each do
         Puppet.features.stubs(:posix?).returns false
         Puppet.features.stubs(:microsoft_windows?).returns true
       end
 
       describe "when a file extension is specified" do
         it "should walk each directory in PATH ignoring PATHEXT" do
           ENV.stubs(:[]).with('PATH').returns(%w[/bar /bin].map{|dir| File.expand_path(dir)}.join(File::PATH_SEPARATOR))
 
           FileTest.expects(:file?).with(File.join(File.expand_path('/bar'), 'foo.CMD')).returns false
 
           ENV.expects(:[]).with('PATHEXT').never
           Puppet::Util.which('foo.CMD').should == path
         end
       end
 
       describe "when a file extension is not specified" do
         it "should walk each extension in PATHEXT until an executable is found" do
           bar = File.expand_path('/bar')
           ENV.stubs(:[]).with('PATH').returns("#{bar}#{File::PATH_SEPARATOR}#{base}")
           ENV.stubs(:[]).with('PATHEXT').returns(".EXE#{File::PATH_SEPARATOR}.CMD")
 
           exts = sequence('extensions')
           FileTest.expects(:file?).in_sequence(exts).with(File.join(bar, 'foo.EXE')).returns false
           FileTest.expects(:file?).in_sequence(exts).with(File.join(bar, 'foo.CMD')).returns false
           FileTest.expects(:file?).in_sequence(exts).with(File.join(base, 'foo.EXE')).returns false
           FileTest.expects(:file?).in_sequence(exts).with(path).returns true
 
           Puppet::Util.which('foo').should == path
         end
 
         it "should walk the default extension path if the environment variable is not defined" do
           ENV.stubs(:[]).with('PATH').returns(base)
           ENV.stubs(:[]).with('PATHEXT').returns(nil)
 
           exts = sequence('extensions')
           %w[.COM .EXE .BAT].each do |ext|
             FileTest.expects(:file?).in_sequence(exts).with(File.join(base, "foo#{ext}")).returns false
           end
           FileTest.expects(:file?).in_sequence(exts).with(path).returns true
 
           Puppet::Util.which('foo').should == path
         end
 
         it "should fall back if no extension matches" do
           ENV.stubs(:[]).with('PATH').returns(base)
           ENV.stubs(:[]).with('PATHEXT').returns(".EXE")
 
           FileTest.stubs(:file?).with(File.join(base, 'foo.EXE')).returns false
           FileTest.stubs(:file?).with(File.join(base, 'foo')).returns true
           FileTest.stubs(:executable?).with(File.join(base, 'foo')).returns true
 
           Puppet::Util.which('foo').should == File.join(base, 'foo')
         end
       end
     end
   end
 
   describe "#binread" do
     let(:contents) { "foo\r\nbar" }
 
     it "should preserve line endings" do
       path = tmpfile('util_binread')
       File.open(path, 'wb') { |f| f.print contents }
 
       Puppet::Util.binread(path).should == contents
     end
 
     it "should raise an error if the file doesn't exist" do
       expect { Puppet::Util.binread('/path/does/not/exist') }.to raise_error(Errno::ENOENT)
     end
   end
 
   describe "hash symbolizing functions" do
     let (:myhash) { { "foo" => "bar", :baz => "bam" } }
     let (:resulthash) { { :foo => "bar", :baz => "bam" } }
 
     describe "#symbolizehash" do
       it "should return a symbolized hash" do
         newhash = Puppet::Util.symbolizehash(myhash)
         newhash.should == resulthash
       end
     end
   end
 
   context "#replace_file" do
     subject { Puppet::Util }
     it { should respond_to :replace_file }
 
     let :target do
       target = Tempfile.new("puppet-util-replace-file")
       target.puts("hello, world")
       target.flush              # make sure content is on disk.
       target.fsync rescue nil
       target.close
       target
     end
 
     it "should fail if no block is given" do
       expect { subject.replace_file(target.path, 0600) }.to raise_error /block/
     end
 
     it "should replace a file when invoked" do
       # Check that our file has the expected content.
       File.read(target.path).should == "hello, world\n"
 
       # Replace the file.
       subject.replace_file(target.path, 0600) do |fh|
         fh.puts "I am the passenger..."
       end
 
       # ...and check the replacement was complete.
       File.read(target.path).should == "I am the passenger...\n"
     end
 
     # When running with the same user and group sid, which is the default,
     # Windows collapses the owner and group modes into a single ACE, resulting
     # in set(0600) => get(0660) and so forth. --daniel 2012-03-30
     modes = [0555, 0660, 0770]
     modes += [0600, 0700] unless Puppet.features.microsoft_windows?
     modes.each do |mode|
       it "should copy 0#{mode.to_s(8)} permissions from the target file by default" do
         set_mode(mode, target.path)
 
         get_mode(target.path).should == mode
 
         subject.replace_file(target.path, 0000) {|fh| fh.puts "bazam" }
 
         get_mode(target.path).should == mode
         File.read(target.path).should == "bazam\n"
       end
     end
 
     it "should copy the permissions of the source file before yielding on Unix", :if => !Puppet.features.microsoft_windows? do
       set_mode(0555, target.path)
       inode = Puppet::FileSystem.stat(target.path).ino
 
       yielded = false
       subject.replace_file(target.path, 0600) do |fh|
         get_mode(fh.path).should == 0555
         yielded = true
       end
       yielded.should be_true
 
       Puppet::FileSystem.stat(target.path).ino.should_not == inode
       get_mode(target.path).should == 0555
     end
 
     it "should use the default permissions if the source file doesn't exist" do
       new_target = target.path + '.foo'
       Puppet::FileSystem.exist?(new_target).should be_false
 
       begin
         subject.replace_file(new_target, 0555) {|fh| fh.puts "foo" }
         get_mode(new_target).should == 0555
       ensure
         Puppet::FileSystem.unlink(new_target) if Puppet::FileSystem.exist?(new_target)
       end
     end
 
     it "should not replace the file if an exception is thrown in the block" do
       yielded = false
       threw   = false
 
       begin
         subject.replace_file(target.path, 0600) do |fh|
           yielded = true
           fh.puts "different content written, then..."
           raise "...throw some random failure"
         end
       rescue Exception => e
         if e.to_s =~ /some random failure/
           threw = true
         else
           raise
         end
       end
 
       yielded.should be_true
       threw.should be_true
 
       # ...and check the replacement was complete.
       File.read(target.path).should == "hello, world\n"
     end
 
     {:string => '664', :number => 0664, :symbolic => "ug=rw-,o=r--" }.each do |label,mode|
       it "should support #{label} format permissions" do
         new_target = target.path + "#{mode}.foo"
         Puppet::FileSystem.exist?(new_target).should be_false
 
         begin
           subject.replace_file(new_target, mode) {|fh| fh.puts "this is an interesting content" }
 
           get_mode(new_target).should == 0664
         ensure
           Puppet::FileSystem.unlink(new_target) if Puppet::FileSystem.exist?(new_target)
         end
       end
     end
 
   end
 
   describe "#pretty_backtrace" do
     it "should include lines that don't match the standard backtrace pattern" do
       line = "non-standard line\n"
       trace = caller[0..2] + [line] + caller[3..-1]
       Puppet::Util.pretty_backtrace(trace).should =~ /#{line}/
     end
 
     it "should include function names" do
       Puppet::Util.pretty_backtrace.should =~ /:in `\w+'/
     end
 
     it "should work with Windows paths" do
       Puppet::Util.pretty_backtrace(["C:/work/puppet/c.rb:12:in `foo'\n"]).
         should == "C:/work/puppet/c.rb:12:in `foo'"
     end
   end
 
-  describe "#execute" do
-    let(:command) { 'mycommand' }
-
-    it "should pass arguments through" do
-      arguments = 'myarg'
-      Puppet::Util::Execution.expects(:execute).with(command, arguments)
-
-      subject.execute(command, arguments)
-    end
-
-    it "should not supply default arguments" do
-      Puppet::Util::Execution.expects(:execute).with(command)
-
-      subject.execute(command)
-    end
-  end
-
   describe "#deterministic_rand" do
 
     it "should not fiddle with future rand calls" do
       Puppet::Util.deterministic_rand(123,20)
       rand_one = rand()
       Puppet::Util.deterministic_rand(123,20)
       rand().should_not eql(rand_one)
     end
 
     if defined?(Random) == 'constant' && Random.class == Class
       it "should not fiddle with the global seed" do
         srand(1234)
         Puppet::Util.deterministic_rand(123,20)
         srand().should eql(1234)
       end
     # ruby below 1.9.2 variant
     else
       it "should set a new global seed" do
         srand(1234)
         Puppet::Util.deterministic_rand(123,20)
         srand().should_not eql(1234)
       end
     end
   end
 end