diff --git a/lib/puppet/util.rb b/lib/puppet/util.rb
index 736c1a96b..c898296e8 100644
--- a/lib/puppet/util.rb
+++ b/lib/puppet/util.rb
@@ -1,508 +1,521 @@
 # A module to collect utility functions.
 
 require 'English'
 require 'puppet/util/monkey_patches'
 require 'puppet/external/lock'
 require 'puppet/error'
 require 'puppet/util/execution_stub'
 require 'uri'
 require 'sync'
 require 'monitor'
 require 'tempfile'
 require 'pathname'
 
 module Puppet
 
 module Util
   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
 
   @@sync_objects = {}.extend MonitorMixin
 
 
   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
 
 
   def self.synchronize_on(x,type)
     sync_object,users = 0,1
     begin
       @@sync_objects.synchronize {
         (@@sync_objects[x] ||= [Sync.new,0])[users] += 1
       }
       @@sync_objects[x][sync_object].synchronize(type) { yield }
     ensure
       @@sync_objects.synchronize {
         @@sync_objects.delete(x) unless (@@sync_objects[x][users] -= 1) > 0
       }
     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)
       result = nil
       seconds = Benchmark.realtime {
         yield
       }
       object.send(level, msg + (" in %0.2f seconds" % seconds))
       return seconds
     else
       yield
     end
   end
 
   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.
           raise e unless ((dir =~ /~/) && ((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}'.")
           next
         end
         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
     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.
   def absolute_path?(path, platform=nil)
     # Escape once for the string literal, and once for the regex.
     slash = '[\\\\/]'
     name = '[^\\\\/]+'
     regexes = {
       :windows => %r!^(([A-Z]:#{slash})|(#{slash}#{slash}#{name}#{slash}#{name})|(#{slash}#{slash}\?#{slash}#{name}))!i,
       :posix   => %r!^/!,
     }
     require 'puppet'
     platform ||= Puppet.features.microsoft_windows? ? :windows : :posix
 
     !! (path =~ regexes[platform])
   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}"
     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
 
   # Create an exclusive lock.
   def threadlock(resource, type = Sync::EX)
     Puppet::Util.synchronize_on(resource,type) { yield }
   end
 
 
   module_function :benchmark
 
   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 symbolize(value)
     if value.respond_to? :intern
       value.intern
     else
       value
     end
   end
 
   def symbolizehash(hash)
     newhash = {}
     hash.each do |name, val|
       if name.is_a? String
         newhash[name.intern] = val
       else
         newhash[name] = val
       end
     end
   end
 
   def symbolizehash!(hash)
     hash.each do |name, val|
       if name.is_a? String
         hash[name.intern] = val
         hash.delete(name)
       end
     end
 
     hash
   end
   module_function :symbolize, :symbolizehash, :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)
     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|
       file_path, line_num = line.split(":")
       file_path = expand_symlinks(File.expand_path(file_path))
 
       file_path + ":" + line_num
     end .join("\n")
 
   end
 
   # utility method that takes a path as input, checks each component of the path to see if it is a symlink, and expands
   # it if it is.  returns the expanded path.
   def self.expand_symlinks(file_path)
     file_path.split("/").inject do |full_path, next_dir|
       next_path = full_path + "/" + next_dir
       if File.symlink?(next_path) then
         link = File.readlink(next_path)
         next_path =
             case link
               when /^\// then link
               else
                 File.expand_path(full_path + "/" + link)
             end
       end
       next_path
     end
   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.
   def replace_file(file, default_mode, &block)
     raise Puppet::DevError, "replace_file requires a block" unless block_given?
-    raise Puppet::DevError, "replace_file is non-functional on Windows" if Puppet.features.microsoft_windows?
 
     file     = Pathname(file)
     tempfile = Tempfile.new(file.basename.to_s, file.dirname.to_s)
 
     file_exists = file.exist?
 
     # If the file exists, use its current mode/owner/group. If it doesn't, use
     # the supplied mode, and default to current user/group.
     if file_exists
-      stat = file.lstat
+      if Puppet.features.microsoft_windows?
+        mode = Puppet::Util::Windows::Security.get_mode(file.to_s)
+        uid = Puppet::Util::Windows::Security.get_owner(file.to_s)
+        gid = Puppet::Util::Windows::Security.get_owner(file.to_s)
+      else
+        stat = file.lstat
+
+        mode = stat.mode
+        uid = stat.uid
+        gid = stat.gid
+      end
 
       # We only care about the four lowest-order octets. Higher octets are
       # filesystem-specific.
-      mode = stat.mode & 07777
-      uid = stat.uid
-      gid = stat.gid
+      mode &= 07777
     else
       mode = default_mode
       uid = Process.euid
       gid = Process.egid
     end
 
     # 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.
-    tempfile.chmod(mode)
-    tempfile.chown(uid, gid)
+    if Puppet.features.microsoft_windows?
+      Puppet::Util::Windows::Security.set_mode(mode, tempfile.path)
+      Puppet::Util::Windows::Security.set_owner(uid, tempfile.path)
+      Puppet::Util::Windows::Security.set_group(gid, tempfile.path)
+    else
+      tempfile.chmod(mode)
+      tempfile.chown(uid, gid)
+    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
 
     File.rename(tempfile.path, file)
 
     # 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.
   #
   # @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
   rescue ArgumentError, RuntimeError, NotImplementedError => detail
     Puppet.log_exception(detail, "Could not #{message}: #{detail}")
     exit(code)
   end
   module_function :exit_on_fail
 
 
   #######################################################################################################
   # 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(command, arguments = {})
     Puppet.deprecation_warning("Puppet::Util.execute is deprecated; please use Puppet::Util::Execution.execute")
     Puppet::Util::Execution.execute(command, arguments)
   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_spec.rb b/spec/unit/util_spec.rb
index 4216f15ea..704e2851c 100755
--- a/spec/unit/util_spec.rb
+++ b/spec/unit/util_spec.rb
@@ -1,445 +1,435 @@
 #!/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)
       File.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"
       Puppet::Util.withenv @new_env do
         ENV["FOO"].should == "bar"
       end
       ENV["FOO"].should == nil
     end
 
   end
 
   describe "#absolute_path?" do
     it "should default to the platform of the local system" do
       Puppet.features.stubs(:posix?).returns(true)
       Puppet.features.stubs(:microsoft_windows?).returns(false)
 
       Puppet::Util.should be_absolute_path('/foo')
       Puppet::Util.should_not be_absolute_path('C:/foo')
 
       Puppet.features.stubs(:posix?).returns(false)
       Puppet.features.stubs(:microsoft_windows?).returns(true)
 
       Puppet::Util.should be_absolute_path('C:/foo')
       Puppet::Util.should_not be_absolute_path('/foo')
     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 "#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)
 
       Puppet::Util.withenv({:HOME => nil, :PATH => env_path}) 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
 
     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
 
   context "#replace_file" do
-    describe "on POSIX platforms", :if => Puppet.features.posix? do
-      subject { Puppet::Util }
-      it { should respond_to :replace_file }
+    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
+    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 replace a file when invoked" do
-        # Check that our file has the expected content.
-        File.read(target.path).should == "hello, world\n"
+    it "should fail if no block is given" do
+      expect { subject.replace_file(target.path, 0600) }.to raise_error /block/
+    end
 
-        # Replace the file.
-        subject.replace_file(target.path, 0600) do |fh|
-          fh.puts "I am the passenger..."
-        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"
 
-        # ...and check the replacement was complete.
-        File.read(target.path).should == "I am the passenger...\n"
+      # Replace the file.
+      subject.replace_file(target.path, 0600) do |fh|
+        fh.puts "I am the passenger..."
       end
 
-      [0555, 0600, 0660, 0700, 0770].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
+      # ...and check the replacement was complete.
+      File.read(target.path).should == "I am the passenger...\n"
+    end
 
-      it "should copy the permissions of the source file before yielding" do
-        set_mode(0555, target.path)
-        inode = File.stat(target.path).ino unless Puppet.features.microsoft_windows?
+    [0555, 0600, 0660, 0700, 0770].each do |mode|
+      it "should copy 0#{mode.to_s(8)} permissions from the target file by default" do
+        set_mode(mode, target.path)
 
-        yielded = false
-        subject.replace_file(target.path, 0600) do |fh|
-          get_mode(fh.path).should == 0555
-          yielded = true
-        end
-        yielded.should be_true
+        get_mode(target.path).should == mode
 
-        # We can't check inode on Windows
-        File.stat(target.path).ino.should_not == inode unless Puppet.features.microsoft_windows?
+        subject.replace_file(target.path, 0000) {|fh| fh.puts "bazam" }
 
-        get_mode(target.path).should == 0555
+        get_mode(target.path).should == mode
+        File.read(target.path).should == "bazam\n"
       end
+    end
 
-      it "should use the default permissions if the source file doesn't exist" do
-        new_target = target.path + '.foo'
-        File.should_not be_exist(new_target)
+    it "should copy the permissions of the source file before yielding" do
+      set_mode(0555, target.path)
+      inode = File.stat(target.path).ino unless Puppet.features.microsoft_windows?
 
-        begin
-          subject.replace_file(new_target, 0555) {|fh| fh.puts "foo" }
-          get_mode(new_target).should == 0555
-        ensure
-          File.unlink(new_target) if File.exists?(new_target)
-        end
+      yielded = false
+      subject.replace_file(target.path, 0600) do |fh|
+        get_mode(fh.path).should == 0555
+        yielded = true
       end
+      yielded.should be_true
 
-      it "should not replace the file if an exception is thrown in the block" do
-        yielded = false
-        threw   = false
+      # We can't check inode on Windows
+      File.stat(target.path).ino.should_not == inode unless Puppet.features.microsoft_windows?
 
-        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
+      get_mode(target.path).should == 0555
+    end
 
-        yielded.should be_true
-        threw.should be_true
+    it "should use the default permissions if the source file doesn't exist" do
+      new_target = target.path + '.foo'
+      File.should_not be_exist(new_target)
 
-        # ...and check the replacement was complete.
-        File.read(target.path).should == "hello, world\n"
+      begin
+        subject.replace_file(new_target, 0555) {|fh| fh.puts "foo" }
+        get_mode(new_target).should == 0555
+      ensure
+        File.unlink(new_target) if File.exists?(new_target)
       end
     end
 
-    describe "on Windows platforms" do
-      it "should fail and complain" do
-        Puppet.features.stubs(:microsoft_windows?).returns true
+    it "should not replace the file if an exception is thrown in the block" do
+      yielded = false
+      threw   = false
 
-        expect { Puppet::Util.replace_file("C:/foo", 0644) {} }.to raise_error(Puppet::DevError, "replace_file is non-functional on Windows")
+      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
   end
 end