diff --git a/lib/puppet/parser/resource.rb b/lib/puppet/parser/resource.rb
index 651ed4224..ee8788651 100644
--- a/lib/puppet/parser/resource.rb
+++ b/lib/puppet/parser/resource.rb
@@ -1,412 +1,418 @@
 # A resource that we're managing.  This handles making sure that only subclasses
 # can set parameters.
 class Puppet::Parser::Resource
     require 'puppet/parser/resource/param'
     require 'puppet/parser/resource/reference'
     require 'puppet/util/tagging'
     require 'puppet/file_collection/lookup'
     require 'puppet/parser/yaml_trimmer'
 
     include Puppet::FileCollection::Lookup
 
     include Puppet::Util
     include Puppet::Util::MethodHelper
     include Puppet::Util::Errors
     include Puppet::Util::Logging
     include Puppet::Util::Tagging
     include Puppet::Parser::YamlTrimmer
 
     attr_accessor :source, :scope, :rails_id
     attr_accessor :virtual, :override, :translated, :catalog
 
     attr_reader :exported, :evaluated, :params
 
     # Determine whether the provided parameter name is a relationship parameter.
     def self.relationship_parameter?(name)
         unless defined?(@relationship_names)
             @relationship_names = Puppet::Type.relationship_params.collect { |p| p.name }
         end
         @relationship_names.include?(name)
     end
 
     # Proxy a few methods to our @ref object.
     [:builtin?, :type, :title].each do |method|
         define_method(method) do
             @ref.send(method)
         end
     end
 
     # Set up some boolean test methods
     [:exported, :translated, :override, :virtual, :evaluated].each do |method|
         newmeth = (method.to_s + "?").intern
         define_method(newmeth) do
             self.send(method)
         end
     end
 
     def [](param)
         param = symbolize(param)
         if param == :title
             return self.title
         end
         if @params.has_key?(param)
             @params[param].value
         else
             nil
         end
     end
 
     def builtin=(bool)
         @ref.builtin = bool
     end
 
     def eachparam
         @params.each do |name, param|
             yield param
         end
     end
 
     # Retrieve the associated definition and evaluate it.
     def evaluate
         if klass = @ref.definedtype
             finish()
             return klass.evaluate_code(self)
         elsif builtin?
             devfail "Cannot evaluate a builtin type"
         else
             self.fail "Cannot find definition %s" % self.type
         end
     ensure
         @evaluated = true
     end
 
     # Mark this resource as both exported and virtual,
     # or remove the exported mark.
     def exported=(value)
         if value
             @virtual = true
             @exported = value
         else
             @exported = value
         end
     end
 
     # Do any finishing work on this object, called before evaluation or
     # before storage/translation.
     def finish
         return if finished?
         @finished = true
         add_defaults()
         add_metaparams()
         add_scope_tags()
         validate()
     end
 
     # Has this resource already been finished?
     def finished?
         defined?(@finished) and @finished
     end
 
     def initialize(options)
         # Set all of the options we can.
         options.each do |option, value|
             if respond_to?(option.to_s + "=")
                 send(option.to_s + "=", value)
                 options.delete(option)
             end
         end
 
         unless self.scope
             raise ArgumentError, "Resources require a scope"
         end
         @source ||= scope.source
 
         options = symbolize_options(options)
 
         # Set up our reference.
         if type = options[:type] and title = options[:title]
             options.delete(:type)
             options.delete(:title)
         else
             raise ArgumentError, "Resources require a type and title"
         end
 
         @ref = Reference.new(:type => type, :title => title, :scope => self.scope)
 
         @params = {}
 
         # Define all of the parameters
         if params = options[:params]
             options.delete(:params)
             params.each do |param|
                 # Don't set the same parameter twice
                 if @params[param.name]
                     self.fail Puppet::ParseError, "Duplicate parameter '%s' for on %s" %
                         [param.name, self.to_s]
                 end
 
                 set_parameter(param)
             end
         end
 
         # Throw an exception if we've got any arguments left to set.
         unless options.empty?
             raise ArgumentError, "Resources do not accept %s" % options.keys.collect { |k| k.to_s }.join(", ")
         end
 
         tag(@ref.type)
         tag(@ref.title) if valid_tag?(@ref.title.to_s)
     end
 
     # Is this resource modeling an isomorphic resource type?
     def isomorphic?
         if builtin?
             return @ref.builtintype.isomorphic?
         else
             return true
         end
     end
 
     # Merge an override resource in.  This will throw exceptions if
     # any overrides aren't allowed.
     def merge(resource)
         # Test the resource scope, to make sure the resource is even allowed
         # to override.
         unless self.source.object_id == resource.source.object_id || resource.source.child_of?(self.source)
             raise Puppet::ParseError.new("Only subclasses can override parameters", resource.line, resource.file)
         end
         # Some of these might fail, but they'll fail in the way we want.
         resource.params.each do |name, param|
             override_parameter(param)
         end
     end
 
     # Unless we're running >= 0.25, we're in compat mode.
     def metaparam_compatibility_mode?
         ! (catalog and version = catalog.client_version and version = version.split(".") and version[0] == "0" and version[1].to_i >= 25)
     end
 
     # Return the resource name, or the title if no name
     # was specified.
     def name
         unless defined? @name
             @name = self[:name] || self.title
         end
         @name
     end
 
     # This *significantly* reduces the number of calls to Puppet.[].
     def paramcheck?
         unless defined? @@paramcheck
             @@paramcheck = Puppet[:paramcheck]
         end
         @@paramcheck
     end
 
     # A temporary occasion, until I get paths in the scopes figured out.
     def path
         to_s
     end
 
     # Return the short version of our name.
     def ref
         @ref.to_s
     end
 
     # Define a parameter in our resource.
     # if we ever receive a parameter named 'tag', set
     # the resource tags with its value.
     def set_parameter(param, value = nil)
         if value
             param = Puppet::Parser::Resource::Param.new(
                 :name => param, :value => value, :source => self.source
             )
         elsif ! param.is_a?(Puppet::Parser::Resource::Param)
             raise ArgumentError, "Must pass a parameter or all necessary values"
         end
 
         tag(*param.value) if param.name == :tag
 
         # And store it in our parameter hash.
         @params[param.name] = param
     end
 
     def to_hash
         @params.inject({}) do |hash, ary|
             param = ary[1]
             # Skip "undef" values.
             if param.value != :undef
                 hash[param.name] = param.value
             end
             hash
         end
     end
 
 
     # Create a Puppet::Resource instance from this parser resource.
     # We plan, at some point, on not needing to do this conversion, but
     # it's sufficient for now.
     def to_resource
         result = Puppet::Resource.new(type, title)
 
         to_hash.each do |p, v|
             if v.is_a?(Puppet::Parser::Resource::Reference)
                 v = Puppet::Resource::Reference.new(v.type, v.title)
             elsif v.is_a?(Array)
                 # flatten resource references arrays
                 if v.flatten.find { |av| av.is_a?(Puppet::Parser::Resource::Reference) }
                     v = v.flatten
                 end
                 v = v.collect do |av|
                     if av.is_a?(Puppet::Parser::Resource::Reference)
                         av = Puppet::Resource::Reference.new(av.type, av.title)
                     end
                     av
                 end
             end
 
             # If the value is an array with only one value, then
             # convert it to a single value.  This is largely so that
             # the database interaction doesn't have to worry about
             # whether it returns an array or a string.
             result[p] = if v.is_a?(Array) and v.length == 1
                               v[0]
                           else
                               v
                           end
         end
 
         result.file = self.file
         result.line = self.line
         result.exported = self.exported
         result.virtual = self.virtual
         result.tag(*self.tags)
 
         return result
     end
 
     def to_s
         self.ref
     end
 
     # Translate our object to a transportable object.
     def to_trans
         return nil if virtual?
 
         return to_resource.to_trans
     end
 
     # Convert this resource to a RAL resource.  We hackishly go via the
     # transportable stuff.
     def to_ral
         to_resource.to_ral
     end
 
     private
 
     # Add default values from our definition.
     def add_defaults
         scope.lookupdefaults(self.type).each do |name, param|
             unless @params.include?(name)
                 self.debug "Adding default for %s" % name
 
                 @params[name] = param.dup
             end
         end
     end
 
     def add_backward_compatible_relationship_param(name)
         # Skip metaparams for which we get no value.
         return unless val = scope.lookupvar(name.to_s, false) and val != :undefined
 
         # The default case: just set the value
         set_parameter(name, val) and return unless @params[name]
 
         # For relationship params, though, join the values (a la #446).
         @params[name].value = [@params[name].value, val].flatten
     end
 
     # Add any metaparams defined in our scope. This actually adds any metaparams
     # from any parent scope, and there's currently no way to turn that off.
     def add_metaparams
         compat_mode = metaparam_compatibility_mode?
 
         Puppet::Type.eachmetaparam do |name|
             if self.class.relationship_parameter?(name)
                 add_backward_compatible_relationship_param(name) if compat_mode
                 next
             end
 
             next if @params[name]
 
             # Skip metaparams for which we get no value.
             next unless val = scope.lookupvar(name.to_s, false) and val != :undefined
 
             set_parameter(name, val)
         end
     end
 
     def add_scope_tags
         if scope_resource = scope.resource
             tag(*scope_resource.tags)
         end
     end
 
     # Accept a parameter from an override.
     def override_parameter(param)
         # This can happen if the override is defining a new parameter, rather
         # than replacing an existing one.
         (set_parameter(param) and return) unless current = @params[param.name]
 
         # The parameter is already set.  Fail if they're not allowed to override it.
         unless param.source.child_of?(current.source)
             puts caller if Puppet[:trace]
             msg = "Parameter '%s' is already set on %s" % [param.name, self.to_s]
             if current.source.to_s != ""
                 msg += " by %s" % current.source
             end
             if current.file or current.line
                 fields = []
                 fields << current.file if current.file
                 fields << current.line.to_s if current.line
                 msg += " at %s" % fields.join(":")
             end
             msg += "; cannot redefine"
             raise Puppet::ParseError.new(msg, param.line, param.file)
         end
 
         # If we've gotten this far, we're allowed to override.
 
-        # Merge with previous value, if the parameter was generated with the +> syntax.
-        # It's important that we use the new param instance here, not the old one,
-        # so that the source is registered correctly for later overrides.
-        param.value = [current.value, param.value].flatten if param.add
+        # Merge with previous value, if the parameter was generated with the +> 
+        # syntax.  It's important that we use a copy of the new param instance 
+        # here, not the old one, and not the original new one, so that the source 
+        # is registered correctly for later overrides but the values aren't 
+        # implcitly shared when multiple resources are overrriden at once (see
+        # ticket #3556).
+        if param.add
+            param = param.dup 
+            param.value = [current.value, param.value].flatten
+        end
 
         set_parameter(param)
     end
 
     # Verify that all passed parameters are valid.  This throws an error if
     #  there's a problem, so we don't have to worry about the return value.
     def paramcheck(param)
         param = param.to_s
         # Now make sure it's a valid argument to our class.  These checks
         # are organized in order of commonhood -- most types, it's a valid
         # argument and paramcheck is enabled.
         if @ref.typeclass.validattr?(param)
             true
         elsif %w{name title}.include?(param) # always allow these
             true
         elsif paramcheck?
             self.fail Puppet::ParseError, "Invalid parameter '%s' for type '%s'" %
                     [param, @ref.type]
         end
     end
 
     # Make sure the resource's parameters are all valid for the type.
     def validate
         @params.each do |name, param|
             # Make sure it's a valid parameter.
             paramcheck(name)
         end
     end
 end
diff --git a/spec/unit/parser/resource.rb b/spec/unit/parser/resource.rb
index d41d4f48b..9924bbecb 100755
--- a/spec/unit/parser/resource.rb
+++ b/spec/unit/parser/resource.rb
@@ -1,511 +1,529 @@
 #!/usr/bin/env ruby
 
 require File.dirname(__FILE__) + '/../../spec_helper'
 
 # LAK: FIXME This is just new tests for resources; I have
 # not moved all tests over yet.
 
 describe Puppet::Parser::Resource do
     before do
         @parser = Puppet::Parser::Parser.new :Code => ""
         @source = @parser.newclass ""
         @node = Puppet::Node.new("yaynode")
         @compiler = Puppet::Parser::Compiler.new(@node, @parser)
         @scope = @compiler.topscope
     end
 
     def mkresource(args = {})
         args[:source] ||= "source"
         args[:scope] ||= stub('scope', :source => mock('source'))
 
         {:type => "resource", :title => "testing", :source => "source", :scope => "scope"}.each do |param, value|
             args[param] ||= value
         end
 
         params = args[:params] || {:one => "yay", :three => "rah"}
         if args[:params] == :none
             args.delete(:params)
         elsif not args[:params].is_a? Array
             args[:params] = paramify(args[:source], params)
         end
 
         Puppet::Parser::Resource.new(args)
     end
 
     def param(name, value, source)
         Puppet::Parser::Resource::Param.new(:name => name, :value => value, :source => source)
     end
 
     def paramify(source, hash)
         hash.collect do |name, value|
             Puppet::Parser::Resource::Param.new(
                 :name => name, :value => value, :source => source
             )
         end
     end
 
     it "should use the file lookup module" do
         Puppet::Parser::Resource.ancestors.should be_include(Puppet::FileCollection::Lookup)
     end
 
     it "should be isomorphic if it is builtin and models an isomorphic type" do
         Puppet::Type.type(:file).expects(:isomorphic?).returns(true)
         @resource = Puppet::Parser::Resource.new(:type => "file", :title => "whatever", :scope => @scope, :source => @source).isomorphic?.should be_true
     end
 
     it "should not be isomorphic if it is builtin and models a non-isomorphic type" do
         Puppet::Type.type(:file).expects(:isomorphic?).returns(false)
         @resource = Puppet::Parser::Resource.new(:type => "file", :title => "whatever", :scope => @scope, :source => @source).isomorphic?.should be_false
     end
 
     it "should be isomorphic if it is not builtin" do
         @parser.newdefine "whatever"
         @resource = Puppet::Parser::Resource.new(:type => "whatever", :title => "whatever", :scope => @scope, :source => @source).isomorphic?.should be_true
     end
 
     it "should have a array-indexing method for retrieving parameter values" do
         @resource = mkresource
         @resource[:one].should == "yay"
     end
 
     it "should use a Puppet::Resource for converting to a ral resource" do
         trans = mock 'resource', :to_ral => "yay"
         @resource = mkresource
         @resource.expects(:to_resource).returns trans
         @resource.to_ral.should == "yay"
     end
 
     describe "when initializing" do
         before do
             @arguments = {:type => "resource", :title => "testing", :scope => stub('scope', :source => mock('source'))}
         end
 
         [:type, :title, :scope].each do |name|
             it "should fail unless #{name.to_s} is specified" do
                 try = @arguments.dup
                 try.delete(name)
                 lambda { Puppet::Parser::Resource.new(try) }.should raise_error(ArgumentError)
             end
         end
 
         it "should set the reference correctly" do
             res = Puppet::Parser::Resource.new(@arguments)
             res.ref.should == "Resource[testing]"
         end
 
         it "should be tagged with user tags" do
             tags = [ "tag1", "tag2" ]
             @arguments[:params] = [ param(:tag, tags , :source) ]
             res = Puppet::Parser::Resource.new(@arguments)
             (res.tags & tags).should == tags
         end
     end
 
     describe "when refering to a resource with name canonicalization" do
         before do
             @arguments = {:type => "file", :title => "/path/", :scope => stub('scope', :source => mock('source'))}
         end
 
         it "should canonicalize its own name" do
             res = Puppet::Parser::Resource.new(@arguments)
             res.ref.should == "File[/path]"
         end
     end
 
     describe "when evaluating" do
         before do
             @type = Puppet::Parser::Resource
 
             @definition = @parser.newdefine "mydefine"
             @class = @parser.newclass "myclass"
             @nodedef = @parser.newnode("mynode")[0]
         end
 
         it "should evaluate the associated AST definition" do
             res = @type.new(:type => "mydefine", :title => "whatever", :scope => @scope, :source => @source)
             @definition.expects(:evaluate_code).with(res)
 
             res.evaluate
         end
 
         it "should evaluate the associated AST class" do
             res = @type.new(:type => "class", :title => "myclass", :scope => @scope, :source => @source)
             @class.expects(:evaluate_code).with(res)
             res.evaluate
         end
 
         it "should evaluate the associated AST node" do
             res = @type.new(:type => "node", :title => "mynode", :scope => @scope, :source => @source)
             @nodedef.expects(:evaluate_code).with(res)
             res.evaluate
         end
     end
 
     describe "when finishing" do
         before do
             @class = @parser.newclass "myclass"
             @nodedef = @parser.newnode("mynode")[0]
 
             @resource = Puppet::Parser::Resource.new(:type => "file", :title => "whatever", :scope => @scope, :source => @source)
         end
 
         it "should do nothing if it has already been finished" do
             @resource.finish
             @resource.expects(:add_metaparams).never
             @resource.finish
         end
 
         it "should add all defaults available from the scope" do
             @resource.scope.expects(:lookupdefaults).with(@resource.type).returns(:owner => param(:owner, "default", @resource.source))
             @resource.finish
 
             @resource[:owner].should == "default"
         end
 
         it "should not replace existing parameters with defaults" do
             @resource.set_parameter :owner, "oldvalue"
             @resource.scope.expects(:lookupdefaults).with(@resource.type).returns(:owner => :replaced)
             @resource.finish
 
             @resource[:owner].should == "oldvalue"
         end
 
         it "should add a copy of each default, rather than the actual default parameter instance" do
             newparam = param(:owner, "default", @resource.source)
             other = newparam.dup
             other.value = "other"
             newparam.expects(:dup).returns(other)
             @resource.scope.expects(:lookupdefaults).with(@resource.type).returns(:owner => newparam)
             @resource.finish
 
             @resource[:owner].should == "other"
         end
 
         it "should be running in metaparam compatibility mode if running a version below 0.25" do
             catalog = stub 'catalog', :client_version => "0.24.8"
             @resource.stubs(:catalog).returns catalog
             @resource.should be_metaparam_compatibility_mode
         end
 
         it "should be running in metaparam compatibility mode if running no client version is available" do
             catalog = stub 'catalog', :client_version => nil
             @resource.stubs(:catalog).returns catalog
             @resource.should be_metaparam_compatibility_mode
         end
 
         it "should not be running in metaparam compatibility mode if running a version at or above 0.25" do
             catalog = stub 'catalog', :client_version => "0.25.0"
             @resource.stubs(:catalog).returns catalog
             @resource.should_not be_metaparam_compatibility_mode
         end
 
         it "should copy metaparams from its scope" do
             @scope.setvar("noop", "true")
 
             @resource.class.publicize_methods(:add_metaparams)  { @resource.add_metaparams }
 
             @resource["noop"].should == "true"
         end
 
         it "should not copy metaparams that it already has" do
             @resource.set_parameter("noop", "false")
             @scope.setvar("noop", "true")
 
             @resource.class.publicize_methods(:add_metaparams)  { @resource.add_metaparams }
 
             @resource["noop"].should == "false"
         end
 
         it "should not copy relationship metaparams when not in metaparam compatibility mode" do
             @scope.setvar("require", "bar")
 
             @resource.stubs(:metaparam_compatibility_mode?).returns false
             @resource.class.publicize_methods(:add_metaparams)  { @resource.add_metaparams }
 
             @resource["require"].should be_nil
         end
 
         it "should copy relationship metaparams when in metaparam compatibility mode" do
             @scope.setvar("require", "bar")
 
             @resource.stubs(:metaparam_compatibility_mode?).returns true
             @resource.class.publicize_methods(:add_metaparams)  { @resource.add_metaparams }
 
             @resource["require"].should == "bar"
         end
 
         it "should stack relationship metaparams when in metaparam compatibility mode" do
             @resource.set_parameter("require", "foo")
             @scope.setvar("require", "bar")
 
             @resource.stubs(:metaparam_compatibility_mode?).returns true
             @resource.class.publicize_methods(:add_metaparams)  { @resource.add_metaparams }
 
             @resource["require"].should == ["foo", "bar"]
         end
 
         it "should copy all metaparams that it finds" do
             @scope.setvar("noop", "foo")
             @scope.setvar("schedule", "bar")
 
             @resource.class.publicize_methods(:add_metaparams)  { @resource.add_metaparams }
 
             @resource["noop"].should == "foo"
             @resource["schedule"].should == "bar"
         end
 
         it "should add any tags from the scope resource" do
             scope_resource = stub 'scope_resource', :tags => %w{one two}
             @scope.stubs(:resource).returns(scope_resource)
 
             @resource.class.publicize_methods(:add_scope_tags)  { @resource.add_scope_tags }
 
             @resource.tags.should be_include("one")
             @resource.tags.should be_include("two")
         end
     end
 
     describe "when being tagged" do
         before do
             @scope_resource = stub 'scope_resource', :tags => %w{srone srtwo}
             @scope = stub 'scope', :resource => @scope_resource
             @resource = Puppet::Parser::Resource.new(:type => "file", :title => "yay", :scope => @scope, :source => mock('source'))
         end
 
         it "should get tagged with the resource type" do
             @resource.tags.should be_include("file")
         end
 
         it "should get tagged with the title" do
             @resource.tags.should be_include("yay")
         end
 
         it "should get tagged with each name in the title if the title is a qualified class name" do
             resource = Puppet::Parser::Resource.new(:type => "file", :title => "one::two", :scope => @scope, :source => mock('source'))
             resource.tags.should be_include("one")
             resource.tags.should be_include("two")
         end
 
         it "should get tagged with each name in the type if the type is a qualified class name" do
             resource = Puppet::Parser::Resource.new(:type => "one::two", :title => "whatever", :scope => @scope, :source => mock('source'))
             resource.tags.should be_include("one")
             resource.tags.should be_include("two")
         end
 
         it "should not get tagged with non-alphanumeric titles" do
             resource = Puppet::Parser::Resource.new(:type => "file", :title => "this is a test", :scope => @scope, :source => mock('source'))
             resource.tags.should_not be_include("this is a test")
         end
 
         it "should fail on tags containing '*' characters" do
             lambda { @resource.tag("bad*tag") }.should raise_error(Puppet::ParseError)
         end
 
         it "should fail on tags starting with '-' characters" do
             lambda { @resource.tag("-badtag") }.should raise_error(Puppet::ParseError)
         end
 
         it "should fail on tags containing ' ' characters" do
             lambda { @resource.tag("bad tag") }.should raise_error(Puppet::ParseError)
         end
 
         it "should allow alpha tags" do
             lambda { @resource.tag("good_tag") }.should_not raise_error(Puppet::ParseError)
         end
     end
 
     describe "when merging overrides" do
         before do
             @source = "source1"
             @resource = mkresource :source => @source
             @override = mkresource :source => @source
         end
 
         it "should fail when the override was not created by a parent class" do
             @override.source = "source2"
             @override.source.expects(:child_of?).with("source1").returns(false)
             lambda { @resource.merge(@override) }.should raise_error(Puppet::ParseError)
         end
 
         it "should succeed when the override was created in the current scope" do
             @resource.source = "source3"
             @override.source = @resource.source
             @override.source.expects(:child_of?).with("source3").never
             params = {:a => :b, :c => :d}
             @override.expects(:params).returns(params)
             @resource.expects(:override_parameter).with(:b)
             @resource.expects(:override_parameter).with(:d)
             @resource.merge(@override)
         end
 
         it "should succeed when a parent class created the override" do
             @resource.source = "source3"
             @override.source = "source4"
             @override.source.expects(:child_of?).with("source3").returns(true)
             params = {:a => :b, :c => :d}
             @override.expects(:params).returns(params)
             @resource.expects(:override_parameter).with(:b)
             @resource.expects(:override_parameter).with(:d)
             @resource.merge(@override)
         end
 
         it "should add new parameters when the parameter is not set" do
             @source.stubs(:child_of?).returns true
             @override.set_parameter(:testing, "value")
             @resource.merge(@override)
 
             @resource[:testing].should == "value"
         end
 
         it "should replace existing parameter values" do
             @source.stubs(:child_of?).returns true
             @resource.set_parameter(:testing, "old")
             @override.set_parameter(:testing, "value")
 
             @resource.merge(@override)
 
             @resource[:testing].should == "value"
         end
 
         it "should add values to the parameter when the override was created with the '+>' syntax" do
             @source.stubs(:child_of?).returns true
             param = Puppet::Parser::Resource::Param.new(:name => :testing, :value => "testing", :source => @resource.source)
             param.add = true
 
             @override.set_parameter(param)
 
             @resource.set_parameter(:testing, "other")
 
             @resource.merge(@override)
 
             @resource[:testing].should == %w{other testing}
         end
 
+        it "should not merge parameter values when multiple resources are overriden with '+>' at once " do
+            @resource_2 = mkresource :source => @source
+
+            @resource.  set_parameter(:testing, "old_val_1")
+            @resource_2.set_parameter(:testing, "old_val_2")
+
+            @source.stubs(:child_of?).returns true
+            param = Puppet::Parser::Resource::Param.new(:name => :testing, :value => "new_val", :source => @resource.source)
+            param.add = true
+            @override.set_parameter(param)
+
+            @resource.  merge(@override)
+            @resource_2.merge(@override)
+
+            @resource  [:testing].should == %w{old_val_1 new_val}
+            @resource_2[:testing].should == %w{old_val_2 new_val}
+        end
+
         it "should promote tag overrides to real tags" do
             @source.stubs(:child_of?).returns true
             param = Puppet::Parser::Resource::Param.new(:name => :tag, :value => "testing", :source => @resource.source)
 
             @override.set_parameter(param)
 
             @resource.merge(@override)
 
             @resource.tagged?("testing").should be_true
         end
 
     end
 
     it "should be able to be converted to a normal resource" do
         @source = stub 'scope', :name => "myscope"
         @resource = mkresource :source => @source
         @resource.should respond_to(:to_resource)
     end
 
     it "should use its resource converter to convert to a transportable resource" do
         @source = stub 'scope', :name => "myscope"
         @resource = mkresource :source => @source
 
         newresource = Puppet::Resource.new(:file, "/my")
         Puppet::Resource.expects(:new).returns(newresource)
 
         newresource.expects(:to_trans).returns "mytrans"
 
         @resource.to_trans.should == "mytrans"
     end
 
     it "should return nil if converted to a transportable resource and it is virtual" do
         @source = stub 'scope', :name => "myscope"
         @resource = mkresource :source => @source
 
         @resource.expects(:virtual?).returns true
         @resource.to_trans.should be_nil
     end
 
     describe "when being converted to a resource" do
         before do
             @source = stub 'scope', :name => "myscope"
             @parser_resource = mkresource :source => @source, :params => {:foo => "bar", :fee => "fum"}
         end
 
         it "should create an instance of Puppet::Resource" do
             @parser_resource.to_resource.should be_instance_of(Puppet::Resource)
         end
 
         it "should set the type correctly on the Puppet::Resource" do
             @parser_resource.to_resource.type.should == @parser_resource.type
         end
 
         it "should set the title correctly on the Puppet::Resource" do
             @parser_resource.to_resource.title.should == @parser_resource.title
         end
 
         it "should copy over all of the parameters" do
             result = @parser_resource.to_resource.to_hash
 
             # The name will be in here, also.
             result[:foo].should == "bar"
             result[:fee].should == "fum"
         end
 
         it "should copy over the tags" do
             @parser_resource.tag "foo"
             @parser_resource.tag "bar"
 
             @parser_resource.to_resource.tags.should == @parser_resource.tags
         end
 
         it "should copy over the line" do
             @parser_resource.line = 40
             @parser_resource.to_resource.line.should == 40
         end
 
         it "should copy over the file" do
             @parser_resource.file = "/my/file"
             @parser_resource.to_resource.file.should == "/my/file"
         end
 
         it "should copy over the 'exported' value" do
             @parser_resource.exported = true
             @parser_resource.to_resource.exported.should be_true
         end
 
         it "should copy over the 'virtual' value" do
             @parser_resource.virtual = true
             @parser_resource.to_resource.virtual.should be_true
         end
 
         it "should convert any parser resource references to Puppet::Resource::Reference instances" do
             ref = Puppet::Parser::Resource::Reference.new(:title => "/my/file", :type => "file")
             @parser_resource = mkresource :source => @source, :params => {:foo => "bar", :fee => ref}
             result = @parser_resource.to_resource
             result[:fee].should == Puppet::Resource::Reference.new(:file, "/my/file")
         end
 
         it "should convert any parser resource references to Puppet::Resource::Reference instances even if they are in an array" do
             ref = Puppet::Parser::Resource::Reference.new(:title => "/my/file", :type => "file")
             @parser_resource = mkresource :source => @source, :params => {:foo => "bar", :fee => ["a", ref]}
             result = @parser_resource.to_resource
             result[:fee].should == ["a", Puppet::Resource::Reference.new(:file, "/my/file")]
         end
 
         it "should convert any parser resource references to Puppet::Resource::Reference instances even if they are in an array of array, and even deeper" do
             ref1 = Puppet::Parser::Resource::Reference.new(:title => "/my/file1", :type => "file")
             ref2 = Puppet::Parser::Resource::Reference.new(:title => "/my/file2", :type => "file")
             @parser_resource = mkresource :source => @source, :params => {:foo => "bar", :fee => ["a", [ref1,ref2]]}
             result = @parser_resource.to_resource
             result[:fee].should == ["a", Puppet::Resource::Reference.new(:file, "/my/file1"), Puppet::Resource::Reference.new(:file, "/my/file2")]
         end
 
         it "should fail if the same param is declared twice" do
             lambda do 
                 @parser_resource = mkresource :source => @source, :params => [
                     Puppet::Parser::Resource::Param.new(
                         :name => :foo, :value => "bar", :source => @source
                     ),
                     Puppet::Parser::Resource::Param.new(
                         :name => :foo, :value => "baz", :source => @source
                     )
                 ]
             end.should raise_error(Puppet::ParseError)
         end
     end
 end