diff --git a/lib/puppet/parser/ast.rb b/lib/puppet/parser/ast.rb
index 2773a240e..54e034acb 100644
--- a/lib/puppet/parser/ast.rb
+++ b/lib/puppet/parser/ast.rb
@@ -1,120 +1,134 @@
 # the parent class for all of our syntactical objects
 
 require 'puppet'
 require 'puppet/util/autoload'
 require 'puppet/file_collection/lookup'
 
 # The base class for all of the objects that make up the parse trees.
 # Handles things like file name, line #, and also does the initialization
 # for all of the parameters of all of the child objects.
 class Puppet::Parser::AST
   # Do this so I don't have to type the full path in all of the subclasses
   AST = Puppet::Parser::AST
 
   include Puppet::FileCollection::Lookup
 
   include Puppet::Util::Errors
   include Puppet::Util::MethodHelper
   include Puppet::Util::Docs
 
   attr_accessor :parent, :scope
 
   # don't fetch lexer comment by default
   def use_docs
     self.class.use_docs
   end
 
   # allow our subclass to specify they want documentation
   class << self
     attr_accessor :use_docs
     def associates_doc
     self.use_docs = true
     end
   end
 
   # Does this ast object set something?  If so, it gets evaluated first.
   def self.settor?
     if defined?(@settor)
       @settor
     else
       false
     end
   end
 
   # Evaluate the current object.  Just a stub method, since the subclass
   # should override this method.
   # of the contained children and evaluates them in turn, returning a
   # list of all of the collected values, rejecting nil values
   def evaluate(*options)
     raise Puppet::DevError, "Did not override #evaluate in #{self.class}"
   end
 
   # Throw a parse error.
   def parsefail(message)
     self.fail(Puppet::ParseError, message)
   end
 
   # Wrap a statemp in a reusable way so we always throw a parse error.
   def parsewrap
     exceptwrap :type => Puppet::ParseError do
       yield
     end
   end
 
   # The version of the evaluate method that should be called, because it
   # correctly handles errors.  It is critical to use this method because
   # it can enable you to catch the error where it happens, rather than
   # much higher up the stack.
   def safeevaluate(*options)
     # We duplicate code here, rather than using exceptwrap, because this
     # is called so many times during parsing.
     begin
       return self.evaluate(*options)
     rescue Puppet::Error => detail
       raise adderrorcontext(detail)
     rescue => detail
       error = Puppet::Error.new(detail.to_s)
       # We can't use self.fail here because it always expects strings,
       # not exceptions.
       raise adderrorcontext(error, detail)
     end
   end
 
   # Initialize the object.  Requires a hash as the argument, and
   # takes each of the parameters of the hash and calls the settor
   # method for them.  This is probably pretty inefficient and should
   # likely be changed at some point.
   def initialize(args)
     set_options(args)
   end
+
+  # evaluate ourselves, and match
+  def evaluate_match(value, scope)
+    obj = self.safeevaluate(scope)
+
+    obj   = obj.downcase   if obj.respond_to?(:downcase)
+    value = value.downcase if value.respond_to?(:downcase)
+
+    obj   = Puppet::Parser::Scope.number?(obj)   || obj
+    value = Puppet::Parser::Scope.number?(value) || value
+
+    # "" == undef for case/selector/if
+    obj == value or (obj == "" and value == :undef)
+  end
 end
 
 # And include all of the AST subclasses.
 require 'puppet/parser/ast/arithmetic_operator'
 require 'puppet/parser/ast/astarray'
 require 'puppet/parser/ast/asthash'
 require 'puppet/parser/ast/branch'
 require 'puppet/parser/ast/boolean_operator'
 require 'puppet/parser/ast/caseopt'
 require 'puppet/parser/ast/casestatement'
 require 'puppet/parser/ast/collection'
 require 'puppet/parser/ast/collexpr'
 require 'puppet/parser/ast/comparison_operator'
 require 'puppet/parser/ast/else'
 require 'puppet/parser/ast/function'
 require 'puppet/parser/ast/ifstatement'
 require 'puppet/parser/ast/in_operator'
 require 'puppet/parser/ast/leaf'
 require 'puppet/parser/ast/match_operator'
 require 'puppet/parser/ast/minus'
 require 'puppet/parser/ast/nop'
 require 'puppet/parser/ast/not'
 require 'puppet/parser/ast/resource'
 require 'puppet/parser/ast/resource_defaults'
 require 'puppet/parser/ast/resource_override'
 require 'puppet/parser/ast/resource_reference'
 require 'puppet/parser/ast/resourceparam'
 require 'puppet/parser/ast/selector'
 require 'puppet/parser/ast/tag'
 require 'puppet/parser/ast/vardef'
 require 'puppet/parser/ast/relationship'
diff --git a/lib/puppet/parser/ast/leaf.rb b/lib/puppet/parser/ast/leaf.rb
index 49f430278..db9788f50 100644
--- a/lib/puppet/parser/ast/leaf.rb
+++ b/lib/puppet/parser/ast/leaf.rb
@@ -1,227 +1,213 @@
 class Puppet::Parser::AST
   # The base class for all of the leaves of the parse trees.  These
   # basically just have types and values.  Both of these parameters
   # are simple values, not AST objects.
   class Leaf < AST
     attr_accessor :value, :type
 
     # Return our value.
     def evaluate(scope)
       @value
     end
 
-    # evaluate ourselves, and match
-    def evaluate_match(value, scope)
-      obj = self.safeevaluate(scope)
-
-      obj   = obj.downcase   if obj.respond_to?(:downcase)
-      value = value.downcase if value.respond_to?(:downcase)
-
-      obj   = Puppet::Parser::Scope.number?(obj)   || obj
-      value = Puppet::Parser::Scope.number?(value) || value
-
-      # "" == undef for case/selector/if
-      obj == value or (obj == "" and value == :undef)
-    end
-
     def match(value)
       @value == value
     end
 
     def to_s
       @value.to_s unless @value.nil?
     end
   end
 
   # The boolean class.  True or false.  Converts the string it receives
   # to a Ruby boolean.
   class Boolean < AST::Leaf
 
     # Use the parent method, but then convert to a real boolean.
     def initialize(hash)
       super
 
       unless @value == true or @value == false
         raise Puppet::DevError,
           "'#{@value}' is not a boolean"
       end
       @value
     end
 
     def to_s
       @value ? "true" : "false"
     end
   end
 
   # The base string class.
   class String < AST::Leaf
     def evaluate(scope)
       @value
     end
 
     def to_s
       "\"#{@value}\""
     end
   end
 
   # An uninterpreted string.
   class FlatString < AST::Leaf
     def evaluate(scope)
       @value
     end
 
     def to_s
       "\"#{@value}\""
     end
   end
 
   class Concat < AST::Leaf
     def evaluate(scope)
       @value.collect { |x| x.evaluate(scope) }.join
     end
 
     def to_s
       "concat(#{@value.join(',')})"
     end
   end
 
   # The 'default' option on case statements and selectors.
   class Default < AST::Leaf; end
 
   # Capitalized words; used mostly for type-defaults, but also
   # get returned by the lexer any other time an unquoted capitalized
   # word is found.
   class Type < AST::Leaf; end
 
   # Lower-case words.
   class Name < AST::Leaf; end
 
   # double-colon separated class names
   class ClassName < AST::Leaf; end
 
   # undef values; equiv to nil
   class Undef < AST::Leaf; end
 
   # Host names, either fully qualified or just the short name, or even a regex
   class HostName < AST::Leaf
     def initialize(hash)
       super
 
       # Note that this is an AST::Regex, not a Regexp
       @value = @value.to_s.downcase unless @value.is_a?(Regex)
       if @value =~ /[^-\w.]/
         raise Puppet::DevError,
           "'#{@value}' is not a valid hostname"
       end
     end
 
     # implementing eql? and hash so that when an HostName is stored
     # in a hash it has the same hashing properties as the underlying value
     def eql?(value)
       value = value.value if value.is_a?(HostName)
       @value.eql?(value)
     end
 
     def hash
       @value.hash
     end
 
     def to_s
       @value.to_s
     end
   end
 
   # A simple variable.  This object is only used during interpolation;
   # the VarDef class is used for assignment.
   class Variable < Name
     # Looks up the value of the object in the scope tree (does
     # not include syntactical constructs, like '$' and '{}').
     def evaluate(scope)
       parsewrap do
         if (var = scope.lookupvar(@value, false)) == :undefined
           var = :undef
         end
         var
       end
     end
 
     def to_s
       "\$#{value}"
     end
   end
 
   class HashOrArrayAccess < AST::Leaf
     attr_accessor :variable, :key
 
     def evaluate_container(scope)
       container = variable.respond_to?(:evaluate) ? variable.safeevaluate(scope) : variable
       (container.is_a?(Hash) or container.is_a?(Array)) ? container : scope.lookupvar(container)
     end
 
     def evaluate_key(scope)
       key.respond_to?(:evaluate) ? key.safeevaluate(scope) : key
     end
 
     def evaluate(scope)
       object = evaluate_container(scope)
 
       raise Puppet::ParseError, "#{variable} is not an hash or array when accessing it with #{accesskey}" unless object.is_a?(Hash) or object.is_a?(Array)
 
       object[evaluate_key(scope)]
     end
 
     # Assign value to this hashkey or array index
     def assign(scope, value)
       object = evaluate_container(scope)
       accesskey = evaluate_key(scope)
 
       if object.is_a?(Hash) and object.include?(accesskey)
         raise Puppet::ParseError, "Assigning to the hash '#{variable}' with an existing key '#{accesskey}' is forbidden"
       end
 
       # assign to hash or array
       object[accesskey] = value
     end
 
     def to_s
       "\$#{variable.to_s}[#{key.to_s}]"
     end
   end
 
   class Regex < AST::Leaf
     def initialize(hash)
       super
       @value = Regexp.new(@value) unless @value.is_a?(Regexp)
     end
 
     # we're returning self here to wrap the regexp and to be used in places
     # where a string would have been used, without modifying any client code.
     # For instance, in many places we have the following code snippet:
     #  val = @val.safeevaluate(@scope)
     #  if val.match(otherval)
     #      ...
     #  end
     # this way, we don't have to modify this test specifically for handling
     # regexes.
     def evaluate(scope)
       self
     end
 
     def evaluate_match(value, scope, options = {})
       value = value.is_a?(String) ? value : value.to_s
 
       if matched = @value.match(value)
         scope.ephemeral_from(matched, options[:file], options[:line])
       end
       matched
     end
 
     def match(value)
       @value.match(value)
     end
 
     def to_s
       "/#{@value.source}/"
     end
   end
 end
diff --git a/spec/unit/parser/ast/leaf_spec.rb b/spec/unit/parser/ast/leaf_spec.rb
index d21cbf573..6729cd278 100755
--- a/spec/unit/parser/ast/leaf_spec.rb
+++ b/spec/unit/parser/ast/leaf_spec.rb
@@ -1,388 +1,331 @@
 #!/usr/bin/env ruby
 
 require File.dirname(__FILE__) + '/../../../spec_helper'
 
 describe Puppet::Parser::AST::Leaf do
   before :each do
     @scope = stub 'scope'
     @value = stub 'value'
     @leaf = Puppet::Parser::AST::Leaf.new(:value => @value)
   end
 
   it "should have a evaluate_match method" do
     Puppet::Parser::AST::Leaf.new(:value => "value").should respond_to(:evaluate_match)
   end
 
-  describe "when evaluate_match is called" do
-    it "should evaluate itself" do
-      @leaf.expects(:safeevaluate).with(@scope)
-
-      @leaf.evaluate_match("value", @scope)
-    end
-
-    it "should match values by equality" do
-      @value.stubs(:==).returns(false)
-      @leaf.stubs(:safeevaluate).with(@scope).returns(@value)
-      @value.expects(:==).with("value")
-
-      @leaf.evaluate_match("value", @scope)
-    end
-
-    it "should downcase the evaluated value if wanted" do
-      @leaf.stubs(:safeevaluate).with(@scope).returns(@value)
-      @value.expects(:downcase).returns("value")
-
-      @leaf.evaluate_match("value", @scope)
-    end
-
-    it "should convert values to number" do
-      @leaf.stubs(:safeevaluate).with(@scope).returns(@value)
-      Puppet::Parser::Scope.expects(:number?).with(@value).returns(2)
-      Puppet::Parser::Scope.expects(:number?).with("23").returns(23)
-
-      @leaf.evaluate_match("23", @scope)
-    end
-
-    it "should compare 'numberized' values" do
-      @leaf.stubs(:safeevaluate).with(@scope).returns(@value)
-      two = stub_everything 'two'
-      one = stub_everything 'one'
-
-      Puppet::Parser::Scope.stubs(:number?).with(@value).returns(one)
-      Puppet::Parser::Scope.stubs(:number?).with("2").returns(two)
-
-      one.expects(:==).with(two)
-
-      @leaf.evaluate_match("2", @scope)
-    end
-
-    it "should match undef if value is an empty string" do
-      @leaf.stubs(:safeevaluate).with(@scope).returns("")
-
-      @leaf.evaluate_match(:undef, @scope).should be_true
-    end
-
-    it "should downcase the parameter value if wanted" do
-      parameter = stub 'parameter'
-      parameter.expects(:downcase).returns("value")
-
-      @leaf.evaluate_match(parameter, @scope)
-    end
-  end
-
   describe "when converting to string" do
     it "should transform its value to string" do
       value = stub 'value', :is_a? => true
       value.expects(:to_s)
       Puppet::Parser::AST::Leaf.new( :value => value ).to_s
     end
   end
 
   it "should have a match method" do
     @leaf.should respond_to(:match)
   end
 
   it "should delegate match to ==" do
     @value.expects(:==).with("value")
 
     @leaf.match("value")
   end
 end
 
 describe Puppet::Parser::AST::FlatString do
   describe "when converting to string" do
     it "should transform its value to a quoted string" do
       value = stub 'value', :is_a? => true, :to_s => "ab"
       Puppet::Parser::AST::FlatString.new( :value => value ).to_s.should == "\"ab\""
     end
   end
 end
 
 describe Puppet::Parser::AST::String do
   describe "when converting to string" do
     it "should transform its value to a quoted string" do
       value = stub 'value', :is_a? => true, :to_s => "ab"
       Puppet::Parser::AST::String.new( :value => value ).to_s.should == "\"ab\""
     end
   end
 end
 
 describe Puppet::Parser::AST::Undef do
   before :each do
     @scope = stub 'scope'
     @undef = Puppet::Parser::AST::Undef.new(:value => :undef)
   end
 
   it "should match undef with undef" do
     @undef.evaluate_match(:undef, @scope).should be_true
   end
 
   it "should not match undef with an empty string" do
     @undef.evaluate_match("", @scope).should be_false
   end
 end
 
 describe Puppet::Parser::AST::HashOrArrayAccess do
   before :each do
     @scope = stub 'scope'
   end
 
   describe "when evaluating" do
     it "should evaluate the variable part if necessary" do
       @scope.stubs(:lookupvar).with("a").returns(["b"])
 
       variable = stub 'variable', :evaluate => "a"
       access = Puppet::Parser::AST::HashOrArrayAccess.new(:variable => variable, :key => 0 )
 
       variable.expects(:safeevaluate).with(@scope).returns("a")
 
       access.evaluate(@scope).should == "b"
     end
 
     it "should evaluate the access key part if necessary" do
       @scope.stubs(:lookupvar).with("a").returns(["b"])
 
       index = stub 'index', :evaluate => 0
       access = Puppet::Parser::AST::HashOrArrayAccess.new(:variable => "a", :key => index )
 
       index.expects(:safeevaluate).with(@scope).returns(0)
 
       access.evaluate(@scope).should == "b"
     end
 
     it "should be able to return an array member" do
       @scope.stubs(:lookupvar).with("a").returns(["val1", "val2", "val3"])
 
       access = Puppet::Parser::AST::HashOrArrayAccess.new(:variable => "a", :key => 1 )
 
       access.evaluate(@scope).should == "val2"
     end
 
     it "should be able to return an hash value" do
       @scope.stubs(:lookupvar).with("a").returns({ "key1" => "val1", "key2" => "val2", "key3" => "val3" })
 
       access = Puppet::Parser::AST::HashOrArrayAccess.new(:variable => "a", :key => "key2" )
 
       access.evaluate(@scope).should == "val2"
     end
 
     it "should raise an error if the variable lookup didn't return an hash or an array" do
       @scope.stubs(:lookupvar).with("a").returns("I'm a string")
 
       access = Puppet::Parser::AST::HashOrArrayAccess.new(:variable => "a", :key => "key2" )
 
       lambda { access.evaluate(@scope) }.should raise_error
     end
 
     it "should raise an error if the variable wasn't in the scope" do
       @scope.stubs(:lookupvar).with("a").returns(nil)
 
       access = Puppet::Parser::AST::HashOrArrayAccess.new(:variable => "a", :key => "key2" )
 
       lambda { access.evaluate(@scope) }.should raise_error
     end
 
     it "should return a correct string representation" do
       access = Puppet::Parser::AST::HashOrArrayAccess.new(:variable => "a", :key => "key2" )
       access.to_s.should == '$a[key2]'
     end
 
     it "should work with recursive hash access" do
       @scope.stubs(:lookupvar).with("a").returns({ "key" => { "subkey" => "b" }})
 
       access1 = Puppet::Parser::AST::HashOrArrayAccess.new(:variable => "a", :key => "key")
       access2 = Puppet::Parser::AST::HashOrArrayAccess.new(:variable => access1, :key => "subkey")
 
       access2.evaluate(@scope).should == 'b'
     end
 
     it "should work with interleaved array and hash access" do
       @scope.stubs(:lookupvar).with("a").returns({ "key" => [ "a" , "b" ]})
 
       access1 = Puppet::Parser::AST::HashOrArrayAccess.new(:variable => "a", :key => "key")
       access2 = Puppet::Parser::AST::HashOrArrayAccess.new(:variable => access1, :key => 1)
 
       access2.evaluate(@scope).should == 'b'
     end
   end
 
   describe "when assigning" do
     it "should add a new key and value" do
       scope = Puppet::Parser::Scope.new
       scope.setvar("a", { 'a' => 'b' })
 
       access = Puppet::Parser::AST::HashOrArrayAccess.new(:variable => "a", :key => "b")
       access.assign(scope, "c" )
 
       scope.lookupvar("a").should be_include("b")
     end
 
     it "should raise an error when trying to overwrite an hash value" do
       @scope.stubs(:lookupvar).with("a").returns({ "key" => [ "a" , "b" ]})
       access = Puppet::Parser::AST::HashOrArrayAccess.new(:variable => "a", :key => "key")
 
       lambda { access.assign(@scope, "test") }.should raise_error
     end
   end
 end
 
 describe Puppet::Parser::AST::Regex do
   before :each do
     @scope = stub 'scope'
   end
 
   describe "when initializing" do
     it "should create a Regexp with its content when value is not a Regexp" do
       Regexp.expects(:new).with("/ab/")
 
       Puppet::Parser::AST::Regex.new :value => "/ab/"
     end
 
     it "should not create a Regexp with its content when value is a Regexp" do
       value = Regexp.new("/ab/")
       Regexp.expects(:new).with("/ab/").never
 
       Puppet::Parser::AST::Regex.new :value => value
     end
   end
 
   describe "when evaluating" do
     it "should return self" do
       val = Puppet::Parser::AST::Regex.new :value => "/ab/"
 
       val.evaluate(@scope).should === val
     end
   end
 
   describe "when evaluate_match" do
     before :each do
       @value = stub 'regex'
       @value.stubs(:match).with("value").returns(true)
       Regexp.stubs(:new).returns(@value)
       @regex = Puppet::Parser::AST::Regex.new :value => "/ab/"
     end
 
     it "should issue the regexp match" do
       @value.expects(:match).with("value")
 
       @regex.evaluate_match("value", @scope)
     end
 
     it "should not downcase the paramater value" do
       @value.expects(:match).with("VaLuE")
 
       @regex.evaluate_match("VaLuE", @scope)
     end
 
     it "should set ephemeral scope vars if there is a match" do
       @scope.expects(:ephemeral_from).with(true, nil, nil)
 
       @regex.evaluate_match("value", @scope)
     end
 
     it "should return the match to the caller" do
       @value.stubs(:match).with("value").returns(:match)
       @scope.stubs(:ephemeral_from)
 
       @regex.evaluate_match("value", @scope)
     end
   end
 
   it "should return the regex source with to_s" do
     regex = stub 'regex'
     Regexp.stubs(:new).returns(regex)
 
     val = Puppet::Parser::AST::Regex.new :value => "/ab/"
 
     regex.expects(:source)
 
     val.to_s
   end
 
   it "should delegate match to the underlying regexp match method" do
     regex = Regexp.new("/ab/")
     val = Puppet::Parser::AST::Regex.new :value => regex
 
     regex.expects(:match).with("value")
 
     val.match("value")
   end
 end
 
 describe Puppet::Parser::AST::Variable do
   before :each do
     @scope = stub 'scope'
     @var = Puppet::Parser::AST::Variable.new(:value => "myvar")
   end
 
   it "should lookup the variable in scope" do
     @scope.expects(:lookupvar).with("myvar", false).returns(:myvalue)
     @var.safeevaluate(@scope).should == :myvalue
   end
 
   it "should return undef if the variable wasn't set" do
     @scope.expects(:lookupvar).with("myvar", false).returns(:undefined)
     @var.safeevaluate(@scope).should == :undef
   end
 
   describe "when converting to string" do
     it "should transform its value to a variable" do
       value = stub 'value', :is_a? => true, :to_s => "myvar"
       Puppet::Parser::AST::Variable.new( :value => value ).to_s.should == "\$myvar"
     end
   end
 end
 
 describe Puppet::Parser::AST::HostName do
   before :each do
     @scope = stub 'scope'
     @value = stub 'value', :=~ => false
     @value.stubs(:to_s).returns(@value)
     @value.stubs(:downcase).returns(@value)
     @host = Puppet::Parser::AST::HostName.new( :value => @value)
   end
 
   it "should raise an error if hostname is not valid" do
     lambda { Puppet::Parser::AST::HostName.new( :value => "not an hostname!" ) }.should raise_error
   end
 
   it "should not raise an error if hostname is a regex" do
     lambda { Puppet::Parser::AST::HostName.new( :value => Puppet::Parser::AST::Regex.new(:value => "/test/") ) }.should_not raise_error
   end
 
   it "should stringify the value" do
     value = stub 'value', :=~ => false
 
     value.expects(:to_s).returns("test")
 
     Puppet::Parser::AST::HostName.new(:value => value)
   end
 
   it "should downcase the value" do
     value = stub 'value', :=~ => false
     value.stubs(:to_s).returns("UPCASED")
     host = Puppet::Parser::AST::HostName.new(:value => value)
 
     host.value == "upcased"
   end
 
   it "should evaluate to its value" do
     @host.evaluate(@scope).should == @value
   end
 
   it "should delegate eql? to the underlying value if it is an HostName" do
     @value.expects(:eql?).with("value")
     @host.eql?("value")
   end
 
   it "should delegate eql? to the underlying value if it is not an HostName" do
     value = stub 'compared', :is_a? => true, :value => "value"
     @value.expects(:eql?).with("value")
     @host.eql?(value)
   end
 
   it "should delegate hash to the underlying value" do
     @value.expects(:hash)
     @host.hash
   end
 end
diff --git a/spec/unit/parser/ast_spec.rb b/spec/unit/parser/ast_spec.rb
index b743cea2e..29dce2b9c 100644
--- a/spec/unit/parser/ast_spec.rb
+++ b/spec/unit/parser/ast_spec.rb
@@ -1,41 +1,111 @@
 #!/usr/bin/env ruby
 
 require File.dirname(__FILE__) + '/../../spec_helper'
 
 require 'puppet/parser/ast'
 
 describe Puppet::Parser::AST do
 
   it "should use the file lookup module" do
     Puppet::Parser::AST.ancestors.should be_include(Puppet::FileCollection::Lookup)
   end
 
   it "should have a doc accessor" do
     ast = Puppet::Parser::AST.new({})
     ast.should respond_to(:doc)
   end
 
   it "should have a use_docs accessor to indicate it wants documentation" do
     ast = Puppet::Parser::AST.new({})
     ast.should respond_to(:use_docs)
   end
 
   [ Puppet::Parser::AST::Collection, Puppet::Parser::AST::Else,
     Puppet::Parser::AST::Function, Puppet::Parser::AST::IfStatement,
     Puppet::Parser::AST::Resource, Puppet::Parser::AST::ResourceDefaults,
     Puppet::Parser::AST::ResourceOverride, Puppet::Parser::AST::VarDef
   ].each do |k|
     it "#{k}.use_docs should return true" do
       ast = k.new({})
       ast.use_docs.should be_true
     end
   end
 
   describe "when initializing" do
     it "should store the doc argument if passed" do
       ast = Puppet::Parser::AST.new(:doc => "documentation")
       ast.doc.should == "documentation"
     end
   end
 
 end
+
+describe 'AST Generic Child' do
+  before :each do
+    @value = stub 'value'
+    class Evaluateable < Puppet::Parser::AST
+      attr_accessor :value
+      def safeevaluate(*options)
+        return value
+      end
+    end
+    @evaluateable = Evaluateable.new(:value => @value)
+    @scope = stubs 'scope'
+  end
+
+  describe "when evaluate_match is called" do
+    it "should evaluate itself" do
+      @evaluateable.expects(:safeevaluate).with(@scope)
+
+      @evaluateable.evaluate_match("value", @scope)
+    end
+
+    it "should match values by equality" do
+      @value.expects(:==).with("value").returns(true)
+
+      @evaluateable.evaluate_match("value", @scope)
+    end
+
+    it "should downcase the evaluated value if wanted" do
+      @value.expects(:downcase).returns("value")
+
+      @evaluateable.evaluate_match("value", @scope)
+    end
+
+    it "should convert values to number" do
+      Puppet::Parser::Scope.expects(:number?).with(@value).returns(2)
+      Puppet::Parser::Scope.expects(:number?).with("23").returns(23)
+
+      @evaluateable.evaluate_match("23", @scope)
+    end
+
+    it "should compare 'numberized' values" do
+      two = stub_everything 'two'
+      one = stub_everything 'one'
+
+      Puppet::Parser::Scope.stubs(:number?).with(@value).returns(one)
+      Puppet::Parser::Scope.stubs(:number?).with("2").returns(two)
+
+      one.expects(:==).with(two)
+
+      @evaluateable.evaluate_match("2", @scope)
+    end
+
+    it "should match undef if value is an empty string" do
+      @evaluateable.value = ''
+      @evaluateable.evaluate_match(:undef, @scope).should be_true
+    end
+
+    it "should downcase the parameter value if wanted" do
+      parameter = stub 'parameter'
+      parameter.expects(:downcase).returns("value")
+
+      @evaluateable.evaluate_match(parameter, @scope)
+    end
+
+    it "should not match '' if value is undef" do
+      @evaluateable.value = :undef
+      @evaluateable.evaluate_match('', @scope).should be_false
+    end
+  end
+end