diff --git a/test/ral/providers/host/parsed.rb b/test/ral/providers/host/parsed.rb
index c2367d566..955edd5d3 100755
--- a/test/ral/providers/host/parsed.rb
+++ b/test/ral/providers/host/parsed.rb
@@ -1,234 +1,237 @@
 #!/usr/bin/env ruby
 
 require File.dirname(__FILE__) + '/../../../lib/puppettest'
 
 require 'etc'
 require 'puppettest'
 require 'puppettest/fileparsing'
 require 'test/unit'
 
 class TestParsedHostProvider < Test::Unit::TestCase
   include PuppetTest
   include PuppetTest::FileParsing
 
   def setup
     super
     @provider = Puppet::Type.type(:host).provider(:parsed)
 
     @oldfiletype = @provider.filetype
   end
 
   def teardown
     Puppet::Util::FileType.filetype(:ram).clear
     @provider.filetype = @oldfiletype
     @provider.clear
     super
   end
 
   def test_provider_existence
     assert(@provider, "Could not retrieve provider")
   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.filetype = Puppet::Util::FileType.filetype(:ram)
   end
 
   def mkhosthash
     if defined?(@hcount)
       @hcount += 1
     else
       @hcount = 1
     end
 
     return {
       :name => "fakehost#{@hcount}",
       :ip => "192.168.27.#{@hcount}",
       :host_aliases => ["alias#{@hcount}"],
       :ensure => :present
     }
   end
 
   def mkhost
     hash = mkhosthash
 
     fakeresource = fakeresource(:host, hash[:name])
 
     host = @provider.new(fakeresource)
 
     assert(host, "Could not create provider host")
     hash.each do |name, val|
       host.send(name.to_s + "=", val)
     end
 
     host
   end
 
   # Make sure we convert both directlys correctly using a simple host.
   def test_basic_isomorphism
-    hash = {:record_type => :parsed, :name => "myhost", :ip => "192.168.43.56", :host_aliases => %w{another host}}
+    hash = {:record_type => :parsed, :name => "myhost", :ip => "192.168.43.56", :host_aliases => %w{another host},
+            :comment => ''}
 
     str = nil
     assert_nothing_raised do
       str = @provider.to_line(hash)
     end
 
     assert_equal("192.168.43.56\tmyhost\tanother\thost", str)
 
     newhash = nil
     assert_nothing_raised do
       newhash = @provider.parse(str).shift
     end
 
     assert_equal(hash, newhash)
   end
 
   # Make sure parsing gets comments, blanks, and hosts
   def test_blanks_and_comments
     mkfaketype
     text = %{# comment one
 
 192.168.43.56\tmyhost\tanother\thost
     
 # another comment
 192.168.43.57\tanotherhost
 }
 
     instances = nil
     assert_nothing_raised do
       instances = @provider.parse(text)
     end
 
 
           assert_equal(
         [
       {:record_type => :comment, :line => "# comment one"},
       {:record_type => :blank, :line => ""},
-      {:record_type => :parsed, :name => "myhost", :ip => "192.168.43.56", :host_aliases => %w{another host}},
+      {:record_type => :parsed, :name => "myhost", :ip => "192.168.43.56", :host_aliases => %w{another host},
+       :comment => ''},
       {:record_type => :blank, :line => "    "},
       {:record_type => :comment, :line => "# another comment"},
         
-      {:record_type => :parsed, :name => "anotherhost", :ip => "192.168.43.57", :host_aliases => []}
+      {:record_type => :parsed, :name => "anotherhost", :ip => "192.168.43.57", :host_aliases => [],
+       :comment => ''}
     ], instances)
 
     newtext = nil
     assert_nothing_raised do
       newtext = @provider.to_file(instances).gsub(/^# HEADER.+\n/, '')
     end
 
     assert_equal(text, newtext)
   end
 
   def test_simplehost
     mkfaketype
     @provider.default_target = :yayness
     file = @provider.target_object(:yayness)
 
     # Start out with no content.
     assert_nothing_raised {
       assert_equal([], @provider.parse(file.read))
     }
 
     # Now create a provider
     host = nil
     assert_nothing_raised {
       host = mkhost
     }
 
     # Make sure we're still empty
     assert_nothing_raised {
       assert_equal([], @provider.parse(file.read))
     }
 
     # Try storing it
     assert_nothing_raised do
       host.flush
     end
 
     # Make sure we get the host back
     assert_nothing_raised {
 
             assert(
         file.read.include?(host.name),
         
         "Did not flush host to disk")
     }
 
     # Remove a single field and make sure it gets tossed
     name = host.host_aliases
     host.host_aliases = [:absent]
 
     assert_nothing_raised {
       host.flush
 
             assert(
         ! file.read.include?(name[0]),
         
         "Did not remove host_aliases from disk")
     }
 
     # Make sure it throws up if we remove a required field
     host.ip = :absent
 
     assert_raise(ArgumentError) {
       host.flush
     }
 
     # Now remove the whole object
     host.ensure = :absent
     assert_nothing_raised {
       host.flush
       assert_equal([], @provider.parse(file.read))
     }
   end
 
   # Parse our sample data and make sure we regenerate it correctly.
   def test_hostsparse
     fakedata("data/types/hosts").each do |file| fakedataparse(file) end
   end
 
   # Make sure we can modify the file elsewhere and those modifications will
   # get taken into account.
   def test_modifyingfile
     hostfile = tempfile
     @provider.default_target = hostfile
 
     file = @provider.target_object(hostfile)
 
     hosts = []
     3.times {
       h = mkhost
       hosts << h
     }
 
     hosts.each do |host|
       host.flush
     end
 
     newhost = mkhost
     hosts << newhost
 
     # Now store our new host
     newhost.flush
 
     # Verify we can retrieve that info
     assert_nothing_raised("Could not retrieve after second write") {
       @provider.prefetch
     }
 
     text = file.read
 
     instances = @provider.parse(text)
 
     # And verify that we have data for everything
     hosts.each { |host|
       name = host.resource[:name]
       assert(text.include?(name), "Host #{name} is not in file")
       hash = host.property_hash
       assert(! hash.empty?, "Could not find host #{name}")
       assert(hash[:ip], "Could not find ip for host #{name}")
     }
   end
 end