diff --git a/spec/integration/provider/mailalias/aliases_spec.rb b/spec/integration/provider/mailalias/aliases_spec.rb
index c9c252600..19e430ba1 100755
--- a/spec/integration/provider/mailalias/aliases_spec.rb
+++ b/spec/integration/provider/mailalias/aliases_spec.rb
@@ -1,22 +1,10 @@
 #!/usr/bin/env ruby
-
 require File.expand_path(File.dirname(__FILE__) + '/../../../spec_helper')
-
-require 'puppettest/fileparsing'
+require 'shared_behaviours/all_parsedfile_providers'
 
 provider_class = Puppet::Type.type(:mailalias).provider(:aliases)
 
 describe provider_class do
-  include PuppetTest::FileParsing
-
-  before :each do
-    @provider = provider_class
-  end
-
-  # #1560
-  it "should be able to parse the mailalias examples" do
-    my_fixtures do |file|
-      fakedataparse(file)
-    end
-  end
+  # #1560, in which we corrupt the format of complex mail aliases.
+  it_should_behave_like "all parsedfile providers", provider_class
 end
diff --git a/spec/shared_behaviours/all_parsedfile_providers.rb b/spec/shared_behaviours/all_parsedfile_providers.rb
new file mode 100644
index 000000000..9cb199b5f
--- /dev/null
+++ b/spec/shared_behaviours/all_parsedfile_providers.rb
@@ -0,0 +1,21 @@
+shared_examples_for "all parsedfile providers" do |provider, *files|
+  if files.empty? then
+    files = my_fixtures
+  end
+
+  files.flatten.each do |file|
+    it "should rewrite #{file} reasonably unchanged" do
+      provider.stubs(:default_target).returns(file)
+      provider.prefetch
+
+      text = provider.to_file(provider.target_records(file))
+      text.gsub!(/^# HEADER.+\n/, '')
+
+      oldlines = File.readlines(file)
+      newlines = text.chomp.split "\n"
+      oldlines.zip(newlines).each do |old, new|
+        new.gsub(/\s+/, '').should == old.chomp.gsub(/\s+/, '')
+      end
+    end
+  end
+end
diff --git a/spec/unit/provider/host/parsed_spec.rb b/spec/unit/provider/host/parsed_spec.rb
index 4a616f34b..3ed479974 100755
--- a/spec/unit/provider/host/parsed_spec.rb
+++ b/spec/unit/provider/host/parsed_spec.rb
@@ -1,202 +1,197 @@
 #!/usr/bin/env ruby
 
 require File.expand_path(File.dirname(__FILE__) + '/../../../spec_helper')
 
 require 'puppet_spec/files'
-require 'puppettest/fileparsing'
 
 provider_class = Puppet::Type.type(:host).provider(:parsed)
 
 describe provider_class do
   include PuppetSpec::Files
-  include PuppetTest::FileParsing
 
   before do
     @host_class = Puppet::Type.type(:host)
     @provider = @host_class.provider(:parsed)
     @hostfile = tmpfile('hosts')
     @provider.any_instance.stubs(:target).returns @hostfile
   end
 
   after :each do
     @provider.initvars
   end
 
   def mkhost(args)
     hostresource = Puppet::Type::Host.new(:name => args[:name])
     hostresource.stubs(:should).with(:target).returns @hostfile
 
     # Using setters of provider to build our testobject
     # Note: We already proved, that in case of host_aliases
     # the provider setter "host_aliases=(value)" will be
     # called with the joined array, so we just simulate that
     host = @provider.new(hostresource)
     args.each do |property,value|
       value = value.join(" ") if property == :host_aliases and value.is_a?(Array)
       host.send("#{property}=", value)
     end
     host
   end
 
   def genhost(host)
     @provider.stubs(:filetype).returns(Puppet::Util::FileType::FileTypeRam)
     File.stubs(:chown)
     File.stubs(:chmod)
     Puppet::Util::SUIDManager.stubs(:asuser).yields
     host.flush
     @provider.target_object(@hostfile).read
   end
 
   describe "when parsing a line with ip and hostname" do
 
     it "should parse an ipv4 from the first field" do
       @provider.parse_line("127.0.0.1    localhost")[:ip].should == "127.0.0.1"
     end
 
     it "should parse an ipv6 from the first field" do
       @provider.parse_line("::1     localhost")[:ip].should == "::1"
     end
 
     it "should parse the name from the second field" do
       @provider.parse_line("::1     localhost")[:name].should == "localhost"
     end
 
     it "should set an empty comment" do
       @provider.parse_line("::1     localhost")[:comment].should == ""
     end
 
     it "should set host_aliases to :absent" do
       @provider.parse_line("::1     localhost")[:host_aliases].should == :absent
     end
 
   end
 
   describe "when parsing a line with ip, hostname and comment" do
     before do
       @testline = "127.0.0.1   localhost # A comment with a #-char"
     end
 
     it "should parse the ip from the first field" do
       @provider.parse_line(@testline)[:ip].should == "127.0.0.1"
     end
 
     it "should parse the hostname from the second field" do
       @provider.parse_line(@testline)[:name].should == "localhost"
     end
 
     it "should parse the comment after the first '#' character" do
       @provider.parse_line(@testline)[:comment].should == 'A comment with a #-char'
     end
 
   end
 
   describe "when parsing a line with ip, hostname and aliases" do
 
     it "should parse alias from the third field" do
       @provider.parse_line("127.0.0.1   localhost   localhost.localdomain")[:host_aliases].should == "localhost.localdomain"
     end
 
     it "should parse multiple aliases" do
       @provider.parse_line("127.0.0.1 host alias1 alias2")[:host_aliases].should == 'alias1 alias2'
       @provider.parse_line("127.0.0.1 host alias1\talias2")[:host_aliases].should == 'alias1 alias2'
       @provider.parse_line("127.0.0.1 host alias1\talias2   alias3")[:host_aliases].should == 'alias1 alias2 alias3'
     end
 
   end
 
   describe "when parsing a line with ip, hostname, aliases and comment" do
 
     before do
       # Just playing with a few different delimiters
       @testline = "127.0.0.1\t   host  alias1\talias2   alias3   #   A comment with a #-char"
     end
 
     it "should parse the ip from the first field" do
       @provider.parse_line(@testline)[:ip].should == "127.0.0.1"
     end
 
     it "should parse the hostname from the second field" do
       @provider.parse_line(@testline)[:name].should == "host"
     end
 
     it "should parse all host_aliases from the third field" do
       @provider.parse_line(@testline)[:host_aliases].should == 'alias1 alias2 alias3'
     end
 
     it "should parse the comment after the first '#' character" do
       @provider.parse_line(@testline)[:comment].should == 'A comment with a #-char'
     end
 
   end
 
   describe "when operating on /etc/hosts like files" do
-    my_fixtures('valid*') do |file|
-      it "should be able to parse #{file}" do
-       fakedataparse(file)
-      end
-    end
+    it_should_behave_like "all parsedfile providers",
+      provider_class, my_fixtures('valid*')
 
     it "should be able to generate a simple hostfile entry" do
       host = mkhost(
         :name   => 'localhost',
         :ip     => '127.0.0.1',
         :ensure => :present
       )
       genhost(host).should == "127.0.0.1\tlocalhost\n"
     end
 
     it "should be able to generate an entry with one alias" do
       host = mkhost(
         :name   => 'localhost.localdomain',
         :ip     => '127.0.0.1',
         :host_aliases => 'localhost',
         :ensure => :present
       )
       genhost(host).should == "127.0.0.1\tlocalhost.localdomain\tlocalhost\n"
     end
 
     it "should be able to generate an entry with more than one alias" do
       host = mkhost(
         :name       => 'host',
         :ip         => '192.0.0.1',
         :host_aliases => [ 'a1','a2','a3','a4' ],
         :ensure     => :present
       )
       genhost(host).should == "192.0.0.1\thost\ta1 a2 a3 a4\n"
     end
 
     it "should be able to generate a simple hostfile entry with comments" do
       host = mkhost(
         :name    => 'localhost',
         :ip      => '127.0.0.1',
         :comment => 'Bazinga!',
         :ensure  => :present
       )
       genhost(host).should == "127.0.0.1\tlocalhost\t# Bazinga!\n"
     end
 
     it "should be able to generate an entry with one alias and a comment" do
       host = mkhost(
         :name   => 'localhost.localdomain',
         :ip     => '127.0.0.1',
         :host_aliases => 'localhost',
         :comment => 'Bazinga!',
         :ensure => :present
       )
       genhost(host).should == "127.0.0.1\tlocalhost.localdomain\tlocalhost\t# Bazinga!\n"
     end
 
     it "should be able to generate an entry with more than one alias and a comment" do
       host = mkhost(
         :name         => 'host',
         :ip           => '192.0.0.1',
         :host_aliases => [ 'a1','a2','a3','a4' ],
         :comment      => 'Bazinga!',
         :ensure       => :present
       )
       genhost(host).should == "192.0.0.1\thost\ta1 a2 a3 a4\t# Bazinga!\n"
     end
 
   end
 
 end
diff --git a/spec/unit/provider/mount/parsed_spec.rb b/spec/unit/provider/mount/parsed_spec.rb
index 0eb473978..01262f94c 100755
--- a/spec/unit/provider/mount/parsed_spec.rb
+++ b/spec/unit/provider/mount/parsed_spec.rb
@@ -1,190 +1,179 @@
 #!/usr/bin/env ruby
 #
 #  Created by Luke Kanies on 2007-9-12.
 #  Copyright (c) 2006. All rights reserved.
 
 require File.expand_path(File.dirname(__FILE__) + '/../../../spec_helper')
-
-require 'puppettest/fileparsing'
+require 'shared_behaviours/all_parsedfile_providers'
 
 module ParsedMountTesting
-  include PuppetTest::FileParsing
-
-  def fake_fstab
-    os = Facter['operatingsystem']
-    if os == "Solaris"
-      name = "solaris.fstab"
-    elsif os == "FreeBSD"
-      name = "freebsd.fstab"
-    else
-      # Catchall for other fstabs
-      name = "linux.fstab"
-    end
-    oldpath = @provider_class.default_target
-    my_fixture(name)
-  end
-
   def mkmountargs
     mount = nil
 
     if defined?(@pcount)
       @pcount += 1
     else
       @pcount = 1
     end
     args = {
       :name => "/fspuppet#{@pcount}",
       :device => "/dev/dsk#{@pcount}",
     }
 
     @provider_class.fields(:parsed).each do |field|
       args[field] = "fake#{field}#{@pcount}" unless args.include? field
     end
 
     args
   end
 
   def mkmount
     hash = mkmountargs
     #hash[:provider] = @provider_class.name
 
     fakeresource = stub :type => :mount, :name => hash[:name]
     fakeresource.stubs(:[]).with(:name).returns(hash[:name])
     fakeresource.stubs(:should).with(:target).returns(nil)
 
     mount = @provider_class.new(fakeresource)
     hash[:record_type] = :parsed
     hash[:ensure] = :present
     mount.property_hash = hash
 
     mount
   end
 
   # Here we just create a fake host type that answers to all of the methods
   # but does not modify our actual system.
   def mkfaketype
     @provider.stubs(:filetype).returns(Puppet::Util::FileType.filetype(:ram))
   end
 end
 
 provider_class = Puppet::Type.type(:mount).provider(:parsed)
 
 describe provider_class do
   before :each do
     @mount_class = Puppet::Type.type(:mount)
     @provider_class = @mount_class.provider(:parsed)
   end
 
 
   describe provider_class do
     include ParsedMountTesting
 
+    it_should_behave_like "all parsedfile providers",
+      provider_class, my_fixtures('*.fstab')
+
     it "should be able to parse all of the example mount tabs" do
+      pending "REVISIT: these may want to be dropped, or maybe rewritten."
+      # fake_fstab was just one of the *.fstab files, based on running OS,
+      # despite the claim in the title of this test. --daniel 2011-03-03
       tab = fake_fstab
       @provider = @provider_class
 
       # LAK:FIXME Again, a relatively bad test, but I don't know how to rspec-ify this.
       # I suppose this is more of an integration test?  I dunno.
       fakedataparse(tab) do
         # Now just make we've got some mounts we know will be there
         hashes = @provider_class.target_records(tab).find_all { |i| i.is_a? Hash }
         (hashes.length > 0).should be_true
         root = hashes.find { |i| i[:name] == "/" }
 
         proc { @provider_class.to_file(hashes) }.should_not raise_error
       end
     end
 
     # LAK:FIXME I can't mock Facter because this test happens at parse-time.
     it "should default to /etc/vfstab on Solaris and /etc/fstab everywhere else" do
       should = case Facter.value(:operatingsystem)
         when "Solaris"; "/etc/vfstab"
         else
           "/etc/fstab"
         end
       Puppet::Type.type(:mount).provider(:parsed).default_target.should == should
     end
 
     it "should not crash on incomplete lines in fstab" do
       parse = @provider_class.parse <<-FSTAB
 /dev/incomplete
 /dev/device       name
       FSTAB
 
       lambda{ @provider_class.to_line(parse[0]) }.should_not raise_error
     end
   end
 
   describe provider_class, " when mounting an absent filesystem" do
     include ParsedMountTesting
 
     # #730 - Make sure 'flush' is called when a mount is moving from absent to mounted
     it "should flush the fstab to disk" do
       mount = mkmount
 
       # Mark the mount as absent
       mount.property_hash[:ensure] = :absent
 
       mount.stubs(:mountcmd) # just so we don't actually try to mount anything
 
       mount.expects(:flush)
       mount.mount
     end
   end
 
   describe provider_class, " when modifying the filesystem tab" do
     include ParsedMountTesting
     before do
       Puppet.settings.stubs(:use)
       # Never write to disk, only to RAM.
       #@provider_class.stubs(:filetype).returns(Puppet::Util::FileType.filetype(:ram))
       @provider_class.stubs(:target_object).returns(Puppet::Util::FileType.filetype(:ram).new("eh"))
       @provider_class.clear
 
       @mount = mkmount
       @target = @provider_class.default_target
     end
 
     it "should write the mount to disk when :flush is called" do
       old_text = @provider_class.target_object(@provider_class.default_target).read
 
       @mount.flush
 
       text = @provider_class.target_object(@provider_class.default_target).read
       text.should == old_text + @mount.class.to_line(@mount.property_hash) + "\n"
     end
   end
 
   describe provider_class, " when parsing information about the root filesystem", :if => Facter["operatingsystem"].value != "Darwin" do
     include ParsedMountTesting
 
     before do
       @mount = @mount_class.new :name => "/"
       @provider = @mount.provider
     end
 
     it "should have a filesystem tab" do
       FileTest.should be_exist(@provider_class.default_target)
     end
 
     it "should find the root filesystem" do
       @provider_class.prefetch("/" => @mount)
       @mount.provider.property_hash[:ensure].should == :present
     end
 
     it "should determine that the root fs is mounted" do
       @provider_class.prefetch("/" => @mount)
       @mount.provider.should be_mounted
     end
   end
 
   describe provider_class, " when mounting and unmounting" do
     include ParsedMountTesting
 
     it "should call the 'mount' command to mount the filesystem"
 
     it "should call the 'unmount' command to unmount the filesystem"
 
     it "should specify the filesystem when remounting a filesystem"
   end
 end
diff --git a/spec/unit/provider/ssh_authorized_key/parsed_spec.rb b/spec/unit/provider/ssh_authorized_key/parsed_spec.rb
index b951b0a38..6d67ee3bb 100755
--- a/spec/unit/provider/ssh_authorized_key/parsed_spec.rb
+++ b/spec/unit/provider/ssh_authorized_key/parsed_spec.rb
@@ -1,227 +1,221 @@
 #!/usr/bin/env ruby
 
 require File.expand_path(File.dirname(__FILE__) + '/../../../spec_helper')
 
 require 'puppet_spec/files'
-require 'puppettest/fileparsing'
 require 'puppettest/fakes'
 
 provider_class = Puppet::Type.type(:ssh_authorized_key).provider(:parsed)
 
 describe provider_class do
   include PuppetSpec::Files
   include PuppetTest
-  include PuppetTest::FileParsing
 
   before :each do
     @sshauthkey_class = Puppet::Type.type(:ssh_authorized_key)
     @provider = @sshauthkey_class.provider(:parsed)
     @keyfile = tmpfile('authorized_keys')
     @provider.any_instance.stubs(:target).returns @keyfile
     @user = 'random_bob'
     Puppet::Util.stubs(:uid).with(@user).returns 12345
   end
 
   after :each do
     @provider.initvars
   end
 
   def mkkey(args)
     fakeresource = fakeresource(:ssh_authorized_key, args[:name])
     fakeresource.stubs(:should).with(:user).returns @user
     fakeresource.stubs(:should).with(:target).returns @keyfile
 
     key = @provider.new(fakeresource)
     args.each do |p,v|
       key.send(p.to_s + "=", v)
     end
 
     key
   end
 
   def genkey(key)
     @provider.stubs(:filetype).returns(Puppet::Util::FileType::FileTypeRam)
     File.stubs(:chown)
     File.stubs(:chmod)
     Puppet::Util::SUIDManager.stubs(:asuser).yields
     key.flush
     @provider.target_object(@keyfile).read
   end
 
-  my_fixtures do |file|
-    it "should be able to parse example data in #{file}" do
-      fakedataparse(file)
-    end
-  end
+  it_should_behave_like "all parsedfile providers", provider_class
 
   it "should be able to generate a basic authorized_keys file" do
 
     key = mkkey(
       {
         :name => "Just Testing",
         :key => "AAAAfsfddsjldjgksdflgkjsfdlgkj",
         :type => "ssh-dss",
         :ensure => :present,
 
         :options => [:absent]
     })
 
     genkey(key).should == "ssh-dss AAAAfsfddsjldjgksdflgkjsfdlgkj Just Testing\n"
   end
 
   it "should be able to generate a authorized_keys file with options" do
 
     key = mkkey(
       {
         :name => "root@localhost",
         :key => "AAAAfsfddsjldjgksdflgkjsfdlgkj",
         :type => "ssh-rsa",
         :ensure => :present,
 
         :options => ['from="192.168.1.1"', "no-pty", "no-X11-forwarding"]
     })
 
     genkey(key).should == "from=\"192.168.1.1\",no-pty,no-X11-forwarding ssh-rsa AAAAfsfddsjldjgksdflgkjsfdlgkj root@localhost\n"
   end
 
   it "should be able to parse options containing commas via its parse_options method" do
     options = %w{from="host1.reductlivelabs.com,host.reductivelabs.com" command="/usr/local/bin/run" ssh-pty}
     optionstr = options.join(", ")
 
     @provider.parse_options(optionstr).should == options
   end
 
   it "should use '' as name for entries that lack a comment" do
     line = "ssh-rsa AAAAB3NzaC1yc2EAAAABIwAAAQEAut8aOSxenjOqF527dlsdHWV4MNoAsX14l9M297+SQXaQ5Z3BedIxZaoQthkDALlV/25A1COELrg9J2MqJNQc8Xe9XQOIkBQWWinUlD/BXwoOTWEy8C8zSZPHZ3getMMNhGTBO+q/O+qiJx3y5cA4MTbw2zSxukfWC87qWwcZ64UUlegIM056vPsdZWFclS9hsROVEa57YUMrehQ1EGxT4Z5j6zIopufGFiAPjZigq/vqgcAqhAKP6yu4/gwO6S9tatBeEjZ8fafvj1pmvvIplZeMr96gHE7xS3pEEQqnB3nd4RY7AF6j9kFixnsytAUO7STPh/M3pLiVQBN89TvWPQ=="
 
     @provider.parse(line)[0][:name].should == ""
   end
 end
 
 describe provider_class do
   before :each do
     @resource = stub("resource", :name => "foo")
     @resource.stubs(:[]).returns "foo"
 
     @provider = provider_class.new(@resource)
     provider_class.stubs(:filetype).returns(Puppet::Util::FileType::FileTypeRam)
     Puppet::Util::SUIDManager.stubs(:asuser).yields
   end
 
   describe "when flushing" do
     before :each do
       # Stub file and directory operations
       Dir.stubs(:mkdir)
       File.stubs(:chmod)
       File.stubs(:chown)
     end
 
     describe "and both a user and a target have been specified" do
       before :each do
         Puppet::Util.stubs(:uid).with("random_bob").returns 12345
         @resource.stubs(:should).with(:user).returns "random_bob"
         target = "/tmp/.ssh_dir/place_to_put_authorized_keys"
         @resource.stubs(:should).with(:target).returns target
       end
 
       it "should create the directory" do
         File.stubs(:exist?).with("/tmp/.ssh_dir").returns false
         Dir.expects(:mkdir).with("/tmp/.ssh_dir", 0700)
         @provider.flush
       end
 
       it "should chown the directory to the user" do
         uid = Puppet::Util.uid("random_bob")
         File.expects(:chown).with(uid, nil, "/tmp/.ssh_dir")
         @provider.flush
       end
 
       it "should chown the key file to the user" do
         uid = Puppet::Util.uid("random_bob")
         File.expects(:chown).with(uid, nil, "/tmp/.ssh_dir/place_to_put_authorized_keys")
         @provider.flush
       end
 
       it "should chmod the key file to 0600" do
         File.expects(:chmod).with(0600, "/tmp/.ssh_dir/place_to_put_authorized_keys")
         @provider.flush
       end
     end
 
     describe "and a user has been specified with no target" do
       before :each do
         @resource.stubs(:should).with(:user).returns "nobody"
         @resource.stubs(:should).with(:target).returns nil
         #
         # I'd like to use random_bob here and something like
         #
         #    File.stubs(:expand_path).with("~random_bob/.ssh").returns "/users/r/random_bob/.ssh"
         #
         # but mocha objects strenuously to stubbing File.expand_path
         # so I'm left with using nobody.
         @dir = File.expand_path("~nobody/.ssh")
       end
 
       it "should create the directory if it doesn't exist" do
         File.stubs(:exist?).with(@dir).returns false
         Dir.expects(:mkdir).with(@dir,0700)
         @provider.flush
       end
 
       it "should not create or chown the directory if it already exist" do
         File.stubs(:exist?).with(@dir).returns false
         Dir.expects(:mkdir).never
         @provider.flush
       end
 
       it "should chown the directory to the user if it creates it" do
         File.stubs(:exist?).with(@dir).returns false
         Dir.stubs(:mkdir).with(@dir,0700)
         uid = Puppet::Util.uid("nobody")
         File.expects(:chown).with(uid, nil, @dir)
         @provider.flush
       end
 
       it "should not create or chown the directory if it already exist" do
         File.stubs(:exist?).with(@dir).returns false
         Dir.expects(:mkdir).never
         File.expects(:chown).never
         @provider.flush
       end
 
       it "should chown the key file to the user" do
         uid = Puppet::Util.uid("nobody")
         File.expects(:chown).with(uid, nil, File.expand_path("~nobody/.ssh/authorized_keys"))
         @provider.flush
       end
 
       it "should chmod the key file to 0600" do
         File.expects(:chmod).with(0600, File.expand_path("~nobody/.ssh/authorized_keys"))
         @provider.flush
       end
     end
 
     describe "and a target has been specified with no user" do
       before :each do
         @resource.stubs(:should).with(:user).returns nil
         @resource.stubs(:should).with(:target).returns("/tmp/.ssh_dir/place_to_put_authorized_keys")
       end
 
       it "should raise an error" do
         proc { @provider.flush }.should raise_error
       end
     end
 
     describe "and a invalid user has been specified with no target" do
       before :each do
         @resource.stubs(:should).with(:user).returns "thisusershouldnotexist"
         @resource.stubs(:should).with(:target).returns nil
       end
 
       it "should catch an exception and raise a Puppet error" do
         lambda { @provider.flush }.should raise_error(Puppet::Error)
       end
     end
 
   end
 end