diff --git a/spec/unit/parser/ast/asthash_spec.rb b/spec/unit/parser/ast/asthash_spec.rb
old mode 100644
new mode 100755
index c70553c56..0fa1f882f
--- a/spec/unit/parser/ast/asthash_spec.rb
+++ b/spec/unit/parser/ast/asthash_spec.rb
@@ -1,98 +1,97 @@
 #!/usr/bin/env ruby
 
 require File.dirname(__FILE__) + '/../../../spec_helper'
 
 describe Puppet::Parser::AST::ASTHash do
   before :each do
     @scope = Puppet::Parser::Scope.new
   end
 
   it "should have a merge functionality" do
     hash = Puppet::Parser::AST::ASTHash.new(:value => {})
     hash.should respond_to(:merge)
   end
 
   it "should be able to merge 2 AST hashes" do
     hash = Puppet::Parser::AST::ASTHash.new(:value => { "a" => "b" })
 
     hash.merge(Puppet::Parser::AST::ASTHash.new(:value => {"c" => "d"}))
 
     hash.value.should == { "a" => "b", "c" => "d" }
   end
 
   it "should be able to merge with a ruby Hash" do
     hash = Puppet::Parser::AST::ASTHash.new(:value => { "a" => "b" })
 
     hash.merge({"c" => "d"})
 
     hash.value.should == { "a" => "b", "c" => "d" }
   end
 
   it "should evaluate each hash value" do
     key1 = stub "key1"
     value1 = stub "value1"
     key2 = stub "key2"
     value2 = stub "value2"
 
     value1.expects(:safeevaluate).with(@scope).returns("b")
     value2.expects(:safeevaluate).with(@scope).returns("d")
 
     operator = Puppet::Parser::AST::ASTHash.new(:value => { key1 => value1, key2 => value2})
     operator.evaluate(@scope)
   end
 
   it "should evaluate the hash keys if they are AST instances" do
     key1 = stub "key1"
     value1 = stub "value1", :safeevaluate => "one"
     key2 = stub "key2"
     value2 = stub "value2", :safeevaluate => "two"
 
     key1.expects(:safeevaluate).with(@scope).returns("1")
     key2.expects(:safeevaluate).with(@scope).returns("2")
 
     operator = Puppet::Parser::AST::ASTHash.new(:value => { key1 => value1, key2 => value2})
     hash = operator.evaluate(@scope)
     hash["1"].should == "one"
     hash["2"].should == "two"
   end
 
   it "should evaluate the hash keys if they are not AST instances" do
     key1 = "1"
     value1 = stub "value1", :safeevaluate => "one"
     key2 = "2"
     value2 = stub "value2", :safeevaluate => "two"
 
     operator = Puppet::Parser::AST::ASTHash.new(:value => { key1 => value1, key2 => value2})
     hash = operator.evaluate(@scope)
     hash["1"].should == "one"
     hash["2"].should == "two"
   end
 
   it "should return an evaluated hash" do
     key1 = stub "key1"
     value1 = stub "value1", :safeevaluate => "b"
     key2 = stub "key2"
     value2 = stub "value2", :safeevaluate => "d"
 
     operator = Puppet::Parser::AST::ASTHash.new(:value => { key1 => value1, key2 => value2})
     operator.evaluate(@scope).should == { key1 => "b", key2 => "d" }
   end
 
   describe "when being initialized without arguments" do
     it "should evaluate to an empty hash" do
       hash = Puppet::Parser::AST::ASTHash.new({})
       hash.evaluate(@scope).should == {}
     end
 
     it "should support merging" do
       hash = Puppet::Parser::AST::ASTHash.new({})
       hash.merge({"a" => "b"}).should == {"a" => "b"}
     end
   end
 
   it "should return a valid string with to_s" do
     hash = Puppet::Parser::AST::ASTHash.new(:value => { "a" => "b", "c" => "d" })
-
-    hash.to_s.should == '{a => b, c => d}'
+    ["{a => b, c => d}", "{c => d, a => b}"].should be_include hash.to_s
   end
 end
diff --git a/spec/unit/property/keyvalue_spec.rb b/spec/unit/property/keyvalue_spec.rb
old mode 100644
new mode 100755
index a44d891d7..a19396df6
--- a/spec/unit/property/keyvalue_spec.rb
+++ b/spec/unit/property/keyvalue_spec.rb
@@ -1,168 +1,171 @@
 #!/usr/bin/env ruby
 
 Dir.chdir(File.dirname(__FILE__)) { (s = lambda { |f| File.exist?(f) ? require(f) : Dir.chdir("..") { s.call(f) } }).call("spec/spec_helper.rb") }
 
 require 'puppet/property/keyvalue'
 
 klass = Puppet::Property::KeyValue
 
 describe klass do
 
   it "should be a subclass of Property" do
     klass.superclass.must == Puppet::Property
   end
 
   describe "as an instance" do
     before do
       # Wow that's a messy interface to the resource.
       klass.initvars
       @resource = stub 'resource', :[]= => nil, :property => nil
       @property = klass.new(:resource => @resource)
     end
 
     it "should have a , as default delimiter" do
       @property.delimiter.should == ";"
     end
 
     it "should have a = as default separator" do
       @property.separator.should == "="
     end
 
     it "should have a :membership as default membership" do
       @property.membership.should == :key_value_membership
     end
 
     it "should return the same value passed into should_to_s" do
       @property.should_to_s({:foo => "baz", :bar => "boo"}) == "foo=baz;bar=boo"
     end
 
-    it "should return the passed in array values joined with the delimiter from is_to_s" do
-      @property.is_to_s({"foo" => "baz" , "bar" => "boo"}).should == "foo=baz;bar=boo"
+    it "should return the passed in hash values joined with the delimiter from is_to_s" do
+      s = @property.is_to_s({"foo" => "baz" , "bar" => "boo"})
+
+      # We can't predict the order the hash is processed in...
+      ["foo=baz;bar=boo", "bar=boo;foo=baz"].should be_include s
     end
 
     describe "when calling inclusive?" do
       it "should use the membership method to look up on the @resource" do
         @property.expects(:membership).returns(:key_value_membership)
         @resource.expects(:[]).with(:key_value_membership)
         @property.inclusive?
       end
 
       it "should return true when @resource[membership] == inclusive" do
         @property.stubs(:membership).returns(:key_value_membership)
         @resource.stubs(:[]).with(:key_value_membership).returns(:inclusive)
         @property.inclusive?.must == true
       end
 
       it "should return false when @resource[membership] != inclusive" do
         @property.stubs(:membership).returns(:key_value_membership)
         @resource.stubs(:[]).with(:key_value_membership).returns(:minimum)
         @property.inclusive?.must == false
       end
     end
 
     describe "when calling process_current_hash" do
       it "should return {} if hash is :absent" do
         @property.process_current_hash(:absent).must == {}
       end
 
       it "should set every key to nil if inclusive?" do
         @property.stubs(:inclusive?).returns(true)
         @property.process_current_hash({:foo => "bar", :do => "re"}).must == { :foo => nil, :do => nil }
       end
 
       it "should return the hash if !inclusive?" do
         @property.stubs(:inclusive?).returns(false)
         @property.process_current_hash({:foo => "bar", :do => "re"}).must == {:foo => "bar", :do => "re"}
       end
     end
 
     describe "when calling should" do
       it "should return nil if @should is nil" do
         @property.should.must == nil
       end
 
       it "should call process_current_hash" do
         @property.should = ["foo=baz", "bar=boo"]
         @property.stubs(:retrieve).returns({:do => "re", :mi => "fa" })
         @property.expects(:process_current_hash).returns({})
         @property.should
       end
 
       it "should return the hashed values of @should and the nilled values of retrieve if inclusive" do
         @property.should = ["foo=baz", "bar=boo"]
         @property.expects(:retrieve).returns({:do => "re", :mi => "fa" })
         @property.expects(:inclusive?).returns(true)
         @property.should.must == { :foo => "baz", :bar => "boo", :do => nil, :mi => nil }
       end
 
       it "should return the hashed @should + the unique values of retrieve if !inclusive" do
         @property.should = ["foo=baz", "bar=boo"]
         @property.expects(:retrieve).returns({:foo => "diff", :do => "re", :mi => "fa"})
         @property.expects(:inclusive?).returns(false)
         @property.should.must == { :foo => "baz", :bar => "boo", :do => "re", :mi => "fa" }
       end
     end
 
     describe "when calling retrieve" do
       before do
         @provider = mock("provider")
         @property.stubs(:provider).returns(@provider)
       end
 
       it "should send 'name' to the provider" do
         @provider.expects(:send).with(:keys)
         @property.expects(:name).returns(:keys)
         @property.retrieve
       end
 
       it "should return a hash with the provider returned info" do
         @provider.stubs(:send).with(:keys).returns({"do" => "re", "mi" => "fa" })
         @property.stubs(:name).returns(:keys)
         @property.retrieve == {"do" => "re", "mi" => "fa" }
       end
 
       it "should return :absent when the provider returns :absent" do
         @provider.stubs(:send).with(:keys).returns(:absent)
         @property.stubs(:name).returns(:keys)
         @property.retrieve == :absent
       end
     end
 
     describe "when calling hashify" do
       it "should return the array hashified" do
         @property.hashify(["foo=baz", "bar=boo"]).must == { :foo => "baz", :bar => "boo" }
       end
     end
 
     describe "when calling safe_insync?" do
       before do
         @provider = mock("provider")
         @property.stubs(:provider).returns(@provider)
         @property.stubs(:name).returns(:prop_name)
       end
 
       it "should return true unless @should is defined and not nil" do
         @property.safe_insync?("foo") == true
       end
 
       it "should return true if the passed in values is nil" do
         @property.should = "foo"
         @property.safe_insync?(nil) == true
       end
 
       it "should return true if hashified should value == (retrieved) value passed in" do
         @provider.stubs(:prop_name).returns({ :foo => "baz", :bar => "boo" })
         @property.should = ["foo=baz", "bar=boo"]
         @property.expects(:inclusive?).returns(true)
         @property.safe_insync?({ :foo => "baz", :bar => "boo" }).must == true
       end
 
       it "should return false if prepared value != should value" do
         @provider.stubs(:prop_name).returns({ "foo" => "bee", "bar" => "boo" })
         @property.should = ["foo=baz", "bar=boo"]
         @property.expects(:inclusive?).returns(true)
         @property.safe_insync?({ "foo" => "bee", "bar" => "boo" }).must == false
       end
     end
   end
 end
diff --git a/spec/unit/util/zaml_spec.rb b/spec/unit/util/zaml_spec.rb
index fd506ea93..caf25e801 100755
--- a/spec/unit/util/zaml_spec.rb
+++ b/spec/unit/util/zaml_spec.rb
@@ -1,90 +1,92 @@
 #!/usr/bin/env ruby
 
 Dir.chdir(File.dirname(__FILE__)) { (s = lambda { |f| File.exist?(f) ? require(f) : Dir.chdir("..") { s.call(f) } }).call("spec/spec_helper.rb") }
 
 require 'puppet/util/monkey_patches'
 
 describe "Pure ruby yaml implementation" do
   {
   7            => "--- 7",
   3.14159      => "--- 3.14159",
   'test'       => "--- test",
   []           => "--- []",
   :symbol      => "--- !ruby/sym symbol",
   {:a => "A"}  => "--- \n  !ruby/sym a: A",
   {:a => "x\ny"} => "--- \n  !ruby/sym a: |-\n    x\n    y" 
   }.each { |o,y|
     it "should convert the #{o.class} #{o.inspect} to yaml" do
       o.to_yaml.should == y
     end
     it "should produce yaml for the #{o.class} #{o.inspect} that can be reconstituted" do
       YAML.load(o.to_yaml).should == o
     end
   }
   #
   # Can't test for equality on raw objects
   {
   Object.new                   => "--- !ruby/object {}",
   [Object.new]                 => "--- \n  - !ruby/object {}",
   {Object.new => Object.new}   => "--- \n  ? !ruby/object {}\n  : !ruby/object {}"
   }.each { |o,y|
     it "should convert the #{o.class} #{o.inspect} to yaml" do
       o.to_yaml.should == y
     end
     it "should produce yaml for the #{o.class} #{o.inspect} that can be reconstituted" do
       lambda { YAML.load(o.to_yaml) }.should_not raise_error
     end
   }
 
-  def set_of_lines(l)
-    l.split("\n").sort
-  end
-
   it "should handle references to Array in Hash values correctly" do
     list = [1]
     data = { "one" => list, "two" => list }
-    data.to_yaml.should == "--- \n  two: &id001 \n    - 1\n  one: *id001"
+    data.to_yaml.should =~ /  two: [&*]id001/
+    data.to_yaml.should =~ /  one: [&*]id001/
     expect { YAML.load(data.to_yaml).should == data }.should_not raise_error
   end
 
   it "should handle references to Hash in Hash values correctly" do
     hash = { 1 => 1 }
     data = { "one" => hash, "two" => hash }
-    # This could still someday fail because the order change would also change which one got the back ref
-    set_of_lines(data.to_yaml).should == set_of_lines("--- \n  two: &id001 \n    1: 1\n  one: *id001")
+    lines = data.to_yaml.split("\n")
+    lines.should be_any {|x| x =~ /--- / }
+    lines.should be_any {|x| x =~ /  one: [*&]id001/ }
+    lines.should be_any {|x| x =~ /  two: [*&]id001/ }
     expect { YAML.load(data.to_yaml).should == data }.should_not raise_error
   end
 
   it "should handle references to Scalar in Hash" do
     str = "hello"
     data = { "one" => str, "two" => str }
-    set_of_lines(data.to_yaml).should == set_of_lines("--- \n  two: hello\n  one: hello")
+    lines = data.to_yaml.split("\n")
+    lines.should be_any {|x| x =~ /--- / }
+    lines.should be_any {|x| x =~ /  one: hello/ }
+    lines.should be_any {|x| x =~ /  two: hello/ }
     expect { YAML.load(data.to_yaml).should == data }.should_not raise_error
   end
 
   class Zaml_test_class_A
     attr_reader :false,:true
     def initialize
       @false = @true = 7
     end
   end
   it "should not blow up when magic strings are used as field names" do
     data = Zaml_test_class_A.new
     data.to_yaml.should == %Q{--- !ruby/object:Zaml_test_class_A\n  \"false\": 7\n  \"true\": 7}
     expect { 
       r = YAML.load(data.to_yaml)
       r.class.should == data.class
       r.true.should == data.true
       r.false.should == data.false
     }.should_not raise_error
   end
 
   it "should not blow up on back references inside arrays" do
     s = [1,2]
     data = [s,s]
     data.to_yaml.should == %Q{--- \n  - &id001 \n    - 1\n    - 2\n  - *id001}
     expect { YAML.load(data.to_yaml).should == data }.should_not raise_error
   end
 
 end