diff --git a/spec/unit/provider/mount/parsed_spec.rb b/spec/unit/provider/mount/parsed_spec.rb
index c86525707..29c3cf020 100755
--- a/spec/unit/provider/mount/parsed_spec.rb
+++ b/spec/unit/provider/mount/parsed_spec.rb
@@ -1,289 +1,289 @@
 #!/usr/bin/env rspec
 require 'spec_helper'
 require 'shared_behaviours/all_parsedfile_providers'
 
 provider_class = Puppet::Type.type(:mount).provider(:parsed)
 
-describe provider_class, :fails_on_windows => true do
+describe provider_class, :unless => Puppet.features.microsoft_windows? do
 
   before :each do
     @mount_class = Puppet::Type.type(:mount)
     @provider = @mount_class.provider(:parsed)
   end
 
   # LAK:FIXME I can't mock Facter because this test happens at parse-time.
   it "should default to /etc/vfstab on Solaris" do
     pending "This test only works on Solaris" unless Facter.value(:operatingsystem) == 'Solaris'
     Puppet::Type.type(:mount).provider(:parsed).default_target.should == '/etc/vfstab'
   end
 
   it "should default to /etc/fstab on anything else" do
     pending "This test does not work on Solaris" if Facter.value(:operatingsystem) == 'Solaris'
     Puppet::Type.type(:mount).provider(:parsed).default_target.should == '/etc/fstab'
   end
 
   describe "when parsing a line" do
 
     it "should not crash on incomplete lines in fstab" do
       parse = @provider.parse <<-FSTAB
 /dev/incomplete
 /dev/device       name
 FSTAB
       lambda{ @provider.to_line(parse[0]) }.should_not raise_error
     end
 
 #   it_should_behave_like "all parsedfile providers",
 #     provider_class, my_fixtures('*.fstab')
 
     describe "on Solaris", :if => Facter.value(:operatingsystem) == 'Solaris', :'fails_on_ruby_1.9.2' => true do
 
       before :each do
         @example_line = "/dev/dsk/c0d0s0 /dev/rdsk/c0d0s0 \t\t    /  \t    ufs     1 no\t-"
       end
 
       it "should extract device from the first field" do
         @provider.parse_line(@example_line)[:device].should == '/dev/dsk/c0d0s0'
       end
 
       it "should extract blockdevice from second field" do
         @provider.parse_line(@example_line)[:blockdevice].should == "/dev/rdsk/c0d0s0"
       end
 
       it "should extract name from third field" do
         @provider.parse_line(@example_line)[:name].should == "/"
       end
 
       it "should extract fstype from fourth field" do
         @provider.parse_line(@example_line)[:fstype].should == "ufs"
       end
 
       it "should extract pass from fifth field" do
         @provider.parse_line(@example_line)[:pass].should == "1"
       end
 
       it "should extract atboot from sixth field" do
         @provider.parse_line(@example_line)[:atboot].should == "no"
       end
 
       it "should extract options from seventh field" do
         @provider.parse_line(@example_line)[:options].should == "-"
       end
 
     end
 
     describe "on other platforms than Solaris", :if => Facter.value(:operatingsystem) != 'Solaris' do
 
       before :each do
         @example_line = "/dev/vg00/lv01\t/spare   \t  \t   ext3    defaults\t1 2"
       end
 
       it "should extract device from the first field" do
         @provider.parse_line(@example_line)[:device].should == '/dev/vg00/lv01'
       end
 
       it "should extract name from second field" do
         @provider.parse_line(@example_line)[:name].should == "/spare"
       end
 
       it "should extract fstype from third field" do
         @provider.parse_line(@example_line)[:fstype].should == "ext3"
       end
 
       it "should extract options from fourth field" do
         @provider.parse_line(@example_line)[:options].should == "defaults"
       end
 
       it "should extract dump from fifth field" do
         @provider.parse_line(@example_line)[:dump].should == "1"
       end
 
       it "should extract options from sixth field" do
         @provider.parse_line(@example_line)[:pass].should == "2"
       end
 
     end
 
   end
 
   describe "mountinstances" do
     it "should get name from mountoutput found on Solaris" do
       Facter.stubs(:value).with(:operatingsystem).returns 'Solaris'
       @provider.stubs(:mountcmd).returns(File.read(my_fixture('solaris.mount')))
       mounts = @provider.mountinstances
       mounts.size.should == 6
       mounts[0].should == { :name => '/', :mounted => :yes }
       mounts[1].should == { :name => '/proc', :mounted => :yes }
       mounts[2].should == { :name => '/etc/mnttab', :mounted => :yes }
       mounts[3].should == { :name => '/tmp', :mounted => :yes }
       mounts[4].should == { :name => '/export/home', :mounted => :yes }
       mounts[5].should == { :name => '/ghost', :mounted => :yes }
     end
 
     it "should get name from mountoutput found on HP-UX" do
       Facter.stubs(:value).with(:operatingsystem).returns 'HP-UX'
       @provider.stubs(:mountcmd).returns(File.read(my_fixture('hpux.mount')))
       mounts = @provider.mountinstances
       mounts.size.should == 17
       mounts[0].should == { :name => '/', :mounted => :yes }
       mounts[1].should == { :name => '/devices', :mounted => :yes }
       mounts[2].should == { :name => '/dev', :mounted => :yes }
       mounts[3].should == { :name => '/system/contract', :mounted => :yes }
       mounts[4].should == { :name => '/proc', :mounted => :yes }
       mounts[5].should == { :name => '/etc/mnttab', :mounted => :yes }
       mounts[6].should == { :name => '/etc/svc/volatile', :mounted => :yes }
       mounts[7].should == { :name => '/system/object', :mounted => :yes }
       mounts[8].should == { :name => '/etc/dfs/sharetab', :mounted => :yes }
       mounts[9].should == { :name => '/lib/libc.so.1', :mounted => :yes }
       mounts[10].should == { :name => '/dev/fd', :mounted => :yes }
       mounts[11].should == { :name => '/tmp', :mounted => :yes }
       mounts[12].should == { :name => '/var/run', :mounted => :yes }
       mounts[13].should == { :name => '/export', :mounted => :yes }
       mounts[14].should == { :name => '/export/home', :mounted => :yes }
       mounts[15].should == { :name => '/rpool', :mounted => :yes }
       mounts[16].should == { :name => '/ghost', :mounted => :yes }
     end
 
     it "should get name from mountoutput found on Darwin" do
       Facter.stubs(:value).with(:operatingsystem).returns 'Darwin'
       @provider.stubs(:mountcmd).returns(File.read(my_fixture('darwin.mount')))
       mounts = @provider.mountinstances
       mounts.size.should == 6
       mounts[0].should == { :name => '/', :mounted => :yes }
       mounts[1].should == { :name => '/dev', :mounted => :yes }
       mounts[2].should == { :name => '/net', :mounted => :yes }
       mounts[3].should == { :name => '/home', :mounted => :yes }
       mounts[4].should == { :name => '/usr', :mounted => :yes }
       mounts[5].should == { :name => '/ghost', :mounted => :yes }
     end
 
     it "should get name from mountoutput found on Linux" do
       Facter.stubs(:value).with(:operatingsystem).returns 'Gentoo'
       @provider.stubs(:mountcmd).returns(File.read(my_fixture('linux.mount')))
       mounts = @provider.mountinstances
       mounts[0].should == { :name => '/', :mounted => :yes }
       mounts[1].should == { :name => '/lib64/rc/init.d', :mounted => :yes }
       mounts[2].should == { :name => '/sys', :mounted => :yes }
       mounts[3].should == { :name => '/usr/portage', :mounted => :yes }
       mounts[4].should == { :name => '/ghost', :mounted => :yes }
     end
 
     it "should get name from mountoutput found on AIX" do
       Facter.stubs(:value).with(:operatingsystem).returns 'AIX'
       @provider.stubs(:mountcmd).returns(File.read(my_fixture('aix.mount')))
       mounts = @provider.mountinstances
       mounts[0].should == { :name => '/', :mounted => :yes }
       mounts[1].should == { :name => '/tmp', :mounted => :yes }
       mounts[2].should == { :name => '/home', :mounted => :yes }
       mounts[3].should == { :name => '/usr', :mounted => :yes }
       mounts[4].should == { :name => '/usr/code', :mounted => :yes }
     end
 
     it "should raise an error if a line is not understandable" do
       @provider.stubs(:mountcmd).returns("bazinga!")
       lambda { @provider.mountinstances }.should raise_error Puppet::Error
     end
 
   end
 
   it "should support AIX's paragraph based /etc/filesystems"
 
   my_fixtures('*.fstab').each do |fstab|
     platform = File.basename(fstab, '.fstab')
 
     describe "when calling instances on #{platform}" do
       before :each do
         if Facter[:operatingsystem] == "Solaris" then
           platform == 'solaris' or
             pending "We need to stub the operatingsystem fact at load time, but can't"
         else
           platform != 'solaris' or
             pending "We need to stub the operatingsystem fact at load time, but can't"
         end
 
         # Stub the mount output to our fixture.
         begin
           mount = my_fixture(platform + '.mount')
           @provider.stubs(:mountcmd).returns File.read(mount)
         rescue
           pending "is #{platform}.mount missing at this point?"
         end
 
         # Note: we have to stub default_target before creating resources
         # because it is used by Puppet::Type::Mount.new to populate the
         # :target property.
         @provider.stubs(:default_target).returns fstab
         @retrieve = @provider.instances.collect { |prov| {:name => prov.get(:name), :ensure => prov.get(:ensure)}}
       end
 
       # Following mountpoint are present in all fstabs/mountoutputs
       it "should include unmounted resources" do
         @retrieve.should include(:name => '/', :ensure => :mounted)
       end
 
       it "should include mounted resources" do
         @retrieve.should include(:name => '/boot', :ensure => :unmounted)
       end
 
       it "should include ghost resources" do
         @retrieve.should include(:name => '/ghost', :ensure => :ghost)
       end
 
     end
 
     describe "when prefetching on #{platform}" do
       before :each do
         if Facter[:operatingsystem] == "Solaris" then
           platform == 'solaris' or
             pending "We need to stub the operatingsystem fact at load time, but can't"
         else
           platform != 'solaris' or
             pending "We need to stub the operatingsystem fact at load time, but can't"
         end
 
         # Stub the mount output to our fixture.
         begin
           mount = my_fixture(platform + '.mount')
           @provider.stubs(:mountcmd).returns File.read(mount)
         rescue
           pending "is #{platform}.mount missing at this point?"
         end
 
         # Note: we have to stub default_target before creating resources
         # because it is used by Puppet::Type::Mount.new to populate the
         # :target property.
         @provider.stubs(:default_target).returns fstab
 
         @res_ghost = Puppet::Type::Mount.new(:name => '/ghost')    # in no fake fstab
         @res_mounted = Puppet::Type::Mount.new(:name => '/')       # in every fake fstab
         @res_unmounted = Puppet::Type::Mount.new(:name => '/boot') # in every fake fstab
         @res_absent = Puppet::Type::Mount.new(:name => '/absent')  # in no fake fstab
 
         # Simulate transaction.rb:prefetch
         @resource_hash = {}
         [@res_ghost, @res_mounted, @res_unmounted, @res_absent].each do |resource|
           @resource_hash[resource.name] = resource
         end
       end
 
       it "should set :ensure to :unmounted if found in fstab but not mounted" do
         @provider.prefetch(@resource_hash)
         @res_unmounted.provider.get(:ensure).should == :unmounted
       end
 
       it "should set :ensure to :ghost if not found in fstab but mounted" do
         @provider.prefetch(@resource_hash)
         @res_ghost.provider.get(:ensure).should == :ghost
       end
 
       it "should set :ensure to :mounted if found in fstab and mounted" do
         @provider.prefetch(@resource_hash)
         @res_mounted.provider.get(:ensure).should == :mounted
       end
 
       it "should set :ensure to :absent if not found in fstab and not mounted" do
         @provider.prefetch(@resource_hash)
         @res_absent.provider.get(:ensure).should == :absent
       end
     end
   end
 end
diff --git a/spec/unit/type/mount_spec.rb b/spec/unit/type/mount_spec.rb
index 9cc4e0f71..82eb563e9 100755
--- a/spec/unit/type/mount_spec.rb
+++ b/spec/unit/type/mount_spec.rb
@@ -1,329 +1,329 @@
 #!/usr/bin/env rspec
 require 'spec_helper'
 
-describe Puppet::Type.type(:mount), :fails_on_windows => true do
+describe Puppet::Type.type(:mount), :unless => Puppet.features.microsoft_windows? do
   it "should have a :refreshable feature that requires the :remount method" do
     Puppet::Type.type(:mount).provider_feature(:refreshable).methods.should == [:remount]
   end
 
   it "should have no default value for :ensure" do
     mount = Puppet::Type.type(:mount).new(:name => "yay")
     mount.should(:ensure).should be_nil
   end
 
   it "should have :name as the only keyattribut" do
     Puppet::Type.type(:mount).key_attributes.should == [:name]
   end
 end
 
 describe Puppet::Type.type(:mount), "when validating attributes" do
   [:name, :remounts, :provider].each do |param|
     it "should have a #{param} parameter" do
       Puppet::Type.type(:mount).attrtype(param).should == :param
     end
   end
 
   [:ensure, :device, :blockdevice, :fstype, :options, :pass, :dump, :atboot, :target].each do |param|
     it "should have a #{param} property" do
       Puppet::Type.type(:mount).attrtype(param).should == :property
     end
   end
 end
 
-describe Puppet::Type.type(:mount)::Ensure, "when validating values", :fails_on_windows => true do
+describe Puppet::Type.type(:mount)::Ensure, "when validating values", :unless => Puppet.features.microsoft_windows? do
   before do
     @provider = stub 'provider', :class => Puppet::Type.type(:mount).defaultprovider, :clear => nil
     Puppet::Type.type(:mount).defaultprovider.expects(:new).returns(@provider)
   end
 
   it "should alias :present to :defined as a value to :ensure" do
     mount = Puppet::Type.type(:mount).new(:name => "yay", :ensure => :present)
     mount.should(:ensure).should == :defined
   end
 
   it "should support :present as a value to :ensure" do
     Puppet::Type.type(:mount).new(:name => "yay", :ensure => :present)
   end
 
   it "should support :defined as a value to :ensure" do
     Puppet::Type.type(:mount).new(:name => "yay", :ensure => :defined)
   end
 
   it "should support :unmounted as a value to :ensure" do
     Puppet::Type.type(:mount).new(:name => "yay", :ensure => :unmounted)
   end
 
   it "should support :absent as a value to :ensure" do
     Puppet::Type.type(:mount).new(:name => "yay", :ensure => :absent)
   end
 
   it "should support :mounted as a value to :ensure" do
     Puppet::Type.type(:mount).new(:name => "yay", :ensure => :mounted)
   end
 end
 
-describe Puppet::Type.type(:mount)::Ensure, :fails_on_windows => true do
+describe Puppet::Type.type(:mount)::Ensure, :unless => Puppet.features.microsoft_windows? do
   before :each do
     provider_properties = {}
     @provider = stub 'provider', :class => Puppet::Type.type(:mount).defaultprovider, :clear => nil, :satisfies? => true, :name => :mock, :property_hash => provider_properties
     Puppet::Type.type(:mount).defaultprovider.stubs(:new).returns(@provider)
     @mount = Puppet::Type.type(:mount).new(:name => "yay", :check => :ensure)
 
     @ensure = @mount.property(:ensure)
   end
 
   def mount_stub(params)
     Puppet::Type.type(:mount).validproperties.each do |prop|
       unless params[prop]
         params[prop] = :absent
         @mount[prop] = :absent
       end
     end
 
     params.each do |param, value|
       @provider.stubs(param).returns(value)
     end
   end
 
   describe Puppet::Type.type(:mount)::Ensure, "when changing the host" do
 
     def test_ensure_change(options)
       @provider.stubs(:get).with(:ensure).returns options[:from]
       @provider.stubs(:ensure).returns options[:from]
       @provider.stubs(:mounted?).returns([:mounted,:ghost].include? options[:from])
       @provider.expects(:create).times(options[:create] || 0)
       @provider.expects(:destroy).times(options[:destroy] || 0)
       @provider.expects(:mount).never
       @provider.expects(:unmount).times(options[:unmount] || 0)
       @ensure.stubs(:syncothers)
       @ensure.should = options[:to]
       @ensure.sync
       (!!@provider.property_hash[:needs_mount]).should == (!!options[:mount])
    end
 
    it "should create itself when changing from :ghost to :present" do
      test_ensure_change(:from => :ghost, :to => :present, :create => 1)
    end
 
    it "should create itself when changing from :absent to :present" do
      test_ensure_change(:from => :absent, :to => :present, :create => 1)
    end
 
    it "should create itself and unmount when changing from :ghost to :unmounted" do
      test_ensure_change(:from => :ghost, :to => :unmounted, :create => 1, :unmount => 1)
    end
 
    it "should unmount resource when changing from :mounted to :unmounted" do
      test_ensure_change(:from => :mounted, :to => :unmounted, :unmount => 1)
    end
 
    it "should create itself when changing from :absent to :unmounted" do
      test_ensure_change(:from => :absent, :to => :unmounted, :create => 1)
    end
 
    it "should unmount resource when changing from :ghost to :absent" do
      test_ensure_change(:from => :ghost, :to => :absent, :unmount => 1)
    end
 
    it "should unmount and destroy itself when changing from :mounted to :absent" do
      test_ensure_change(:from => :mounted, :to => :absent, :destroy => 1, :unmount => 1)
    end
 
    it "should destroy itself when changing from :unmounted to :absent" do
      test_ensure_change(:from => :unmounted, :to => :absent, :destroy => 1)
    end
 
    it "should create itself when changing from :ghost to :mounted" do
      test_ensure_change(:from => :ghost, :to => :mounted, :create => 1)
    end
 
    it "should create itself and mount when changing from :absent to :mounted" do
      test_ensure_change(:from => :absent, :to => :mounted, :create => 1, :mount => 1)
    end
 
    it "should mount resource when changing from :unmounted to :mounted" do
      test_ensure_change(:from => :unmounted, :to => :mounted, :mount => 1)
    end
 
 
    it "should be in sync if it is :absent and should be :absent" do
      @ensure.should = :absent
      @ensure.safe_insync?(:absent).should == true
    end
 
    it "should be out of sync if it is :absent and should be :defined" do
      @ensure.should = :defined
      @ensure.safe_insync?(:absent).should == false
    end
 
    it "should be out of sync if it is :absent and should be :mounted" do
      @ensure.should = :mounted
      @ensure.safe_insync?(:absent).should == false
    end
 
    it "should be out of sync if it is :absent and should be :unmounted" do
      @ensure.should = :unmounted
      @ensure.safe_insync?(:absent).should == false
    end
 
    it "should be out of sync if it is :mounted and should be :absent" do
      @ensure.should = :absent
      @ensure.safe_insync?(:mounted).should == false
    end
 
    it "should be in sync if it is :mounted and should be :defined" do
      @ensure.should = :defined
      @ensure.safe_insync?(:mounted).should == true
    end
 
    it "should be in sync if it is :mounted and should be :mounted" do
      @ensure.should = :mounted
      @ensure.safe_insync?(:mounted).should == true
    end
 
    it "should be out in sync if it is :mounted and should be :unmounted" do
      @ensure.should = :unmounted
      @ensure.safe_insync?(:mounted).should == false
    end
 
 
    it "should be out of sync if it is :unmounted and should be :absent" do
      @ensure.should = :absent
      @ensure.safe_insync?(:unmounted).should == false
    end
 
    it "should be in sync if it is :unmounted and should be :defined" do
      @ensure.should = :defined
      @ensure.safe_insync?(:unmounted).should == true
    end
 
    it "should be out of sync if it is :unmounted and should be :mounted" do
      @ensure.should = :mounted
      @ensure.safe_insync?(:unmounted).should == false
    end
 
    it "should be in sync if it is :unmounted and should be :unmounted" do
      @ensure.should = :unmounted
      @ensure.safe_insync?(:unmounted).should == true
    end
 
 
    it "should be out of sync if it is :ghost and should be :absent" do
      @ensure.should = :absent
      @ensure.safe_insync?(:ghost).should == false
    end
 
    it "should be out of sync if it is :ghost and should be :defined" do
      @ensure.should = :defined
      @ensure.safe_insync?(:ghost).should == false
    end
 
    it "should be out of sync if it is :ghost and should be :mounted" do
      @ensure.should = :mounted
      @ensure.safe_insync?(:ghost).should == false
    end
 
    it "should be out of sync if it is :ghost and should be :unmounted" do
      @ensure.should = :unmounted
      @ensure.safe_insync?(:ghost).should == false
    end
 
  end
 
   describe Puppet::Type.type(:mount), "when responding to refresh" do
     pending "2.6.x specifies slightly different behavior and the desired behavior needs to be clarified and revisited.  See ticket #4904" do
 
       it "should remount if it is supposed to be mounted" do
         @mount[:ensure] = "mounted"
         @provider.expects(:remount)
 
         @mount.refresh
       end
 
       it "should not remount if it is supposed to be present" do
         @mount[:ensure] = "present"
         @provider.expects(:remount).never
 
         @mount.refresh
       end
 
       it "should not remount if it is supposed to be absent" do
         @mount[:ensure] = "absent"
         @provider.expects(:remount).never
 
         @mount.refresh
       end
 
       it "should not remount if it is supposed to be defined" do
         @mount[:ensure] = "defined"
         @provider.expects(:remount).never
 
         @mount.refresh
       end
 
       it "should not remount if it is supposed to be unmounted" do
         @mount[:ensure] = "unmounted"
         @provider.expects(:remount).never
 
         @mount.refresh
       end
 
       it "should not remount swap filesystems" do
         @mount[:ensure] = "mounted"
         @mount[:fstype] = "swap"
         @provider.expects(:remount).never
 
         @mount.refresh
       end
     end
   end
 end
 
-describe Puppet::Type.type(:mount), "when modifying an existing mount entry", :fails_on_windows => true do
+describe Puppet::Type.type(:mount), "when modifying an existing mount entry", :unless => Puppet.features.microsoft_windows? do
   before do
     @provider = stub 'provider', :class => Puppet::Type.type(:mount).defaultprovider, :clear => nil, :satisfies? => true, :name => :mock, :remount => nil
     Puppet::Type.type(:mount).defaultprovider.stubs(:new).returns(@provider)
     @mount = Puppet::Type.type(:mount).new(:name => "yay", :ensure => :mounted)
 
     {:device => "/foo/bar", :blockdevice => "/other/bar", :target => "/what/ever", :fstype => 'eh', :options => "", :pass => 0, :dump => 0, :atboot => 0,
       :ensure => :mounted}.each do
       |param, value|
       @mount.provider.stubs(param).returns value
       @mount[param] = value
     end
 
     @mount.provider.stubs(:mounted?).returns true
 
     # stub this to not try to create state.yaml
     Puppet::Util::Storage.stubs(:store)
 
     @catalog = Puppet::Resource::Catalog.new
     @catalog.add_resource @mount
   end
 
   it "should use the provider to change the dump value" do
     @mount.provider.expects(:dump).returns 0
     @mount.provider.expects(:dump=).with(1)
 
     @mount[:dump] = 1
 
     @catalog.apply
   end
 
   it "should umount before flushing changes to disk" do
     syncorder = sequence('syncorder')
     @mount.provider.expects(:options).returns 'soft'
     @mount.provider.expects(:ensure).returns :mounted
 
     @mount.provider.expects(:unmount).in_sequence(syncorder)
     @mount.provider.expects(:options=).in_sequence(syncorder).with 'hard'
     @mount.expects(:flush).in_sequence(syncorder) # Call inside syncothers
     @mount.expects(:flush).in_sequence(syncorder) # I guess transaction or anything calls flush again
 
     @mount[:ensure] = :unmounted
     @mount[:options] = 'hard'
 
     @catalog.apply
   end
 
 end