diff --git a/lib/puppet/parser/ast/hostclass.rb b/lib/puppet/parser/ast/hostclass.rb
index 0a8e33970..9c039bb49 100644
--- a/lib/puppet/parser/ast/hostclass.rb
+++ b/lib/puppet/parser/ast/hostclass.rb
@@ -1,78 +1,80 @@
 require 'puppet/parser/ast/definition'
 
 class Puppet::Parser::AST
     # The code associated with a class.  This is different from definitions
     # in that each class is a singleton -- only one will exist for a given
     # node.
     class HostClass < AST::Definition
         @name = :class
 
         # Are we a child of the passed class?  Do a recursive search up our
         # parentage tree to figure it out.
         def child_of?(klass)
             return false unless self.parentclass
 
             if klass == self.parentobj
                 return true
             else
                 return self.parentobj.child_of?(klass)
             end
         end
 
         # Evaluate the code associated with this class.
         def evaluate(options)
             scope = options[:scope]
             raise(ArgumentError, "Classes require resources") unless options[:resource]
             # Verify that we haven't already been evaluated.  This is
             # what provides the singleton aspect.
             if existing_scope = scope.compile.class_scope(self)
                 Puppet.debug "%s class already evaluated" % @type
                 return nil
             end
 
+            scope.compile.configuration.tag(self.classname)
+
             pnames = nil
             if pklass = self.parentobj
                 pklass.safeevaluate :scope => scope, :resource => options[:resource]
 
                 scope = parent_scope(scope, pklass)
                 pnames = scope.namespaces
             end
 
             # Don't create a subscope for the top-level class, since it already
             # has its own scope.
             unless options[:resource].title == :main
                 scope = subscope(scope, options[:resource])
             end
 
             if pnames
                 pnames.each do |ns|
                     scope.add_namespace(ns)
                 end
             end
 
             # Set the class before we do anything else, so that it's set
             # during the evaluation and can be inspected.
             scope.compile.class_set(self.classname, scope)
 
             # Now evaluate our code, yo.
             if self.code
                 return self.code.evaluate(:scope => scope)
             else
                 return nil
             end
         end
 
         def initialize(options)
             @parentclass = nil
             super
         end
 
         def parent_scope(scope, klass)
             if s = scope.compile.class_scope(klass)
                 return s
             else
-                raise Puppet::DevError, "Could not find scope for %s" % klass.fqname
+                raise Puppet::DevError, "Could not find scope for %s" % klass.classname
             end
         end
     end
 end
diff --git a/lib/puppet/parser/functions.rb b/lib/puppet/parser/functions.rb
index 4c747af84..7ffdb6ccb 100644
--- a/lib/puppet/parser/functions.rb
+++ b/lib/puppet/parser/functions.rb
@@ -1,306 +1,307 @@
 require 'puppet/util/autoload'
 require 'puppet/parser/scope'
 
 module Puppet::Parser
 module Functions
     # A module for managing parser functions.  Each specified function
     # becomes an instance method on the Scope class.
 
     class << self
         include Puppet::Util
     end
 
     def self.autoloader
         unless defined? @autoloader
             @autoloader = Puppet::Util::Autoload.new(self,
                 "puppet/parser/functions",
                 :wrap => false
             )
         end
 
         @autoloader
     end
 
     # Create a new function type.
     def self.newfunction(name, options = {}, &block)
         @functions ||= {}
         name = symbolize(name)
 
         if @functions.include? name
             raise Puppet::DevError, "Function %s already defined" % name
         end
 
         # We want to use a separate, hidden module, because we don't want
         # people to be able to call them directly.
         unless defined? FCollection
             eval("module FCollection; end")
         end
 
         ftype = options[:type] || :statement
 
         unless ftype == :statement or ftype == :rvalue
             raise Puppet::DevError, "Invalid statement type %s" % ftype.inspect
         end
 
         fname = "function_" + name.to_s
         Puppet::Parser::Scope.send(:define_method, fname, &block)
 
         # Someday we'll support specifying an arity, but for now, nope
         #@functions[name] = {:arity => arity, :type => ftype}
         @functions[name] = {:type => ftype, :name => fname}
         if options[:doc]
             @functions[name][:doc] = options[:doc]
         end
     end
 
     # Determine if a given name is a function
     def self.function(name)
         name = symbolize(name)
 
         unless @functions.include? name
             autoloader.load(name)
         end
 
         if @functions.include? name
             return @functions[name][:name]
         else
             return false
         end
     end
 
     def self.functiondocs
         autoloader.loadall
 
         ret = ""
 
         @functions.sort { |a,b| a[0].to_s <=> b[0].to_s }.each do |name, hash|
             #ret += "%s\n%s\n" % [name, hash[:type]]
             ret += "%s\n%s\n" % [name, "-" * name.to_s.length]
             if hash[:doc]
                 ret += hash[:doc].gsub(/\n\s*/, ' ')
             else
                 ret += "Undocumented.\n"
             end
 
             ret += "\n\n- **Type**: %s\n\n" % hash[:type]
         end
 
         return ret
     end
 
     def self.functions
         @functions.keys
     end
 
     # Determine if a given function returns a value or not.
     def self.rvalue?(name)
         name = symbolize(name)
 
         if @functions.include? name
             case @functions[name][:type]
             when :statement: return false
             when :rvalue: return true
             end
         else
             return false
         end
     end
 
     # Include the specified classes
     newfunction(:include, :doc => "Evaluate one or more classes.") do |vals|
         vals = [vals] unless vals.is_a?(Array)
         klasses = compile.evaluate_classes(vals, self)
 
         missing = vals.find_all do |klass|
             ! klasses.include?(klass)
         end
 
         unless missing.empty?
             # Throw an error if we didn't evaluate all of the classes.
             str = "Could not find class"
             if missing.length > 1
                 str += "es"
             end
 
             str += " " + missing.join(", ")
 
             if n = namespaces and ! n.empty? and n != [""]
                 str += " in namespaces %s" % @namespaces.join(", ")
             end
             self.fail Puppet::ParseError, str
         end
     end
 
     # Tag the current scope with each passed name
     newfunction(:tag, :doc => "Add the specified tags to the containing class
     or definition.  All contained objects will then acquire that tag, also.
     ") do |vals|
         self.resource.tag(*vals)
     end
 
     # Test whether a given tag is set.  This functions as a big OR -- if any of the
     # specified tags are unset, we return false.
     newfunction(:tagged, :type => :rvalue, :doc => "A boolean function that
     tells you whether the current container is tagged with the specified tags.
     The tags are ANDed, so that all of the specified tags must be included for
     the function to return true.") do |vals|
-        classlist = compile.classlist
+        configtags = compile.configuration.tags
+        resourcetags = resource.tags
 
         retval = true
         vals.each do |val|
-            unless classlist.include?(val) or self.resource.tags.include?(val)
+            unless configtags.include?(val) or resourcetags.include?(val)
                 retval = false
                 break
             end
         end
 
         return retval
     end
 
     # Test whether a given class or definition is defined
     newfunction(:defined, :type => :rvalue, :doc => "Determine whether a given
     type is defined, either as a native type or a defined type, or whether a class is defined.
     This is useful for checking whether a class is defined and only including it if it is.
     This function can also test whether a resource has been defined, using resource references
     (e.g., ``if defined(File['/tmp/myfile'] { ... }``).  This function is unfortunately
     dependent on the parse order of the configuration when testing whether a resource is defined.") do |vals|
         result = false
         vals.each do |val|
             case val
             when String:
                 # For some reason, it doesn't want me to return from here.
                 if Puppet::Type.type(val) or finddefine(val) or findclass(val)
                     result = true
                     break
                 end
             when Puppet::Parser::Resource::Reference:
                 if findresource(val.to_s)
                     result = true
                     break
                 end
             else
                 raise ArgumentError, "Invalid argument of type %s to 'defined'" % val.class
             end
         end
         result
     end
 
     newfunction(:fail, :doc => "Fail with a parse error.") do |vals|
         vals = vals.collect { |s| s.to_s }.join(" ") if vals.is_a? Array
         raise Puppet::ParseError, vals.to_s
     end
 
     # Runs a newfunction to create a function for each of the log levels
     Puppet::Util::Log.levels.each do |level|      
         newfunction(level, :doc => "Log a message on the server at level
         #{level.to_s}.") do |vals| 
             send(level, vals.join(" ")) 
         end 
     end
 
     newfunction(:template, :type => :rvalue, :doc => "Evaluate a template and
     return its value.  See `the templating docs`_
     for more information.  Note that if multiple templates are specified, their
     output is all concatenated and returned as the output of the function.
     
     .. _the templating docs: /trac/puppet/wiki/PuppetTemplating
     ") do |vals|
         require 'erb'
 
         vals.collect do |file|
             # Use a wrapper, so the template can't get access to the full
             # Scope object.
             debug "Retrieving template %s" % file
             wrapper = Puppet::Parser::TemplateWrapper.new(self, file)
 
             begin
                 wrapper.result()
             rescue => detail
                 raise Puppet::ParseError,
                     "Failed to parse template %s: %s" %
                         [file, detail]
             end
         end.join("")
     end
 
     # This is just syntactic sugar for a collection, although it will generally
     # be a good bit faster.
     newfunction(:realize, :doc => "Make a virtual object real.  This is useful
         when you want to know the name of the virtual object and don't want to
         bother with a full collection.  It is slightly faster than a collection,
         and, of course, is a bit shorter.  You must pass the object using a
         reference; e.g.: ``realize User[luke]``." ) do |vals|
         coll = Puppet::Parser::Collector.new(self, :nomatter, nil, nil, :virtual)
         vals = [vals] unless vals.is_a?(Array)
         coll.resources = vals
 
         compile.add_collection(coll)
     end
 
     newfunction(:search, :doc => "Add another namespace for this class to search.
         This allows you to create classes with sets of definitions and add
         those classes to another class's search path.") do |vals|
         vals.each do |val|
             add_namespace(val)
         end
     end
 
     newfunction(:file, :type => :rvalue,
         :doc => "Return the contents of a file.  Multiple files
         can be passed, and the first file that exists will be read in.") do |vals|
             ret = nil
             vals.each do |file|
                 unless file =~ /^#{File::SEPARATOR}/
                     raise Puppet::ParseError, "Files must be fully qualified"
                 end
                 if FileTest.exists?(file)
                     ret = File.read(file)
                     break
                 end
             end
             if ret
                 ret
             else
                 raise Puppet::ParseError, "Could not find any files from %s" %
                     vals.join(", ")
             end
     end
 
     newfunction(:generate, :type => :rvalue,
         :doc => "Calls an external command and returns the results of the
         command.  Any arguments are passed to the external command as
         arguments.  If the generator does not exit with return code of 0,
         the generator is considered to have failed and a parse error is
         thrown.  Generators can only have file separators, alphanumerics, dashes,
         and periods in them.  This function will attempt to protect you from
         malicious generator calls (e.g., those with '..' in them), but it can
         never be entirely safe.  No subshell is used to execute
         generators, so all shell metacharacters are passed directly to
         the generator.") do |args|
 
             unless args[0] =~ /^#{File::SEPARATOR}/
                 raise Puppet::ParseError, "Generators must be fully qualified"
             end
 
             unless args[0] =~ /^[-#{File::SEPARATOR}\w.]+$/
                 raise Puppet::ParseError,
                     "Generators can only contain alphanumerics, file separators, and dashes"
             end
 
             if args[0] =~ /\.\./
                 raise Puppet::ParseError,
                     "Can not use generators with '..' in them."
             end
 
             begin
                 output = Puppet::Util.execute(args)
             rescue Puppet::ExecutionFailure => detail
                 raise Puppet::ParseError, "Failed to execute generator %s: %s" %
                     [args[0], detail]
             end
             output
     end
 end
 end
 
 # $Id$
diff --git a/test/language/ast/hostclass.rb b/test/language/ast/hostclass.rb
index b53f6d5c0..f747779b3 100755
--- a/test/language/ast/hostclass.rb
+++ b/test/language/ast/hostclass.rb
@@ -1,167 +1,184 @@
 #!/usr/bin/env ruby
 #
 #  Created by Luke A. Kanies on 2006-02-20.
 #  Copyright (c) 2006. All rights reserved.
 
 $:.unshift("../../lib") if __FILE__ =~ /\.rb$/
 
 require 'puppettest'
 require 'puppettest/parsertesting'
 require 'puppettest/resourcetesting'
 require 'mocha'
 
 class TestASTHostClass < Test::Unit::TestCase
 	include PuppetTest
 	include PuppetTest::ParserTesting
     include PuppetTest::ResourceTesting
 	AST = Puppet::Parser::AST
 
     def test_hostclass
         scope = mkscope
         parser = scope.compile.parser
 
         # Create the class we're testing, first with no parent
         klass = parser.newclass "first",
             :code => AST::ASTArray.new(
                 :children => [resourcedef("file", "/tmp",
                         "owner" => "nobody", "mode" => "755")]
             )
 
         resource = Puppet::Parser::Resource.new(:type => "class", :title => "first", :scope => scope)
         assert_nothing_raised do
             klass.evaluate(:scope => scope, :resource => resource)
         end
 
         # Then try it again
         assert_nothing_raised do
             klass.evaluate(:scope => scope, :resource => resource)
         end
 
         assert(scope.compile.class_scope(klass), "Class was not considered evaluated")
 
         tmp = scope.findresource("File[/tmp]")
         assert(tmp, "Could not find file /tmp")
         assert_equal("nobody", tmp[:owner])
         assert_equal("755", tmp[:mode])
 
         # Now create a couple more classes.
         newbase = parser.newclass "newbase",
             :code => AST::ASTArray.new(
                 :children => [resourcedef("file", "/tmp/other",
                         "owner" => "nobody", "mode" => "644")]
             )
 
         newsub = parser.newclass "newsub",
             :parent => "newbase",
             :code => AST::ASTArray.new(
                 :children => [resourcedef("file", "/tmp/yay",
                         "owner" => "nobody", "mode" => "755"),
                     resourceoverride("file", "/tmp/other",
                             "owner" => "daemon")
                 ]
             )
 
         # Override a different variable in the top scope.
         moresub = parser.newclass "moresub",
             :parent => "newbase",
             :code => AST::ASTArray.new(
                 :children => [resourceoverride("file", "/tmp/other",
                             "mode" => "755")]
             )
 
         assert_nothing_raised do
             newsub.evaluate(:scope => scope, :resource => resource)
         end
 
         assert_nothing_raised do
             moresub.evaluate(:scope => scope, :resource => resource)
         end
 
         assert(scope.compile.class_scope(newbase), "Did not eval newbase")
         assert(scope.compile.class_scope(newsub), "Did not eval newsub")
 
         yay = scope.findresource("File[/tmp/yay]")
         assert(yay, "Did not find file /tmp/yay")
         assert_equal("nobody", yay[:owner])
         assert_equal("755", yay[:mode])
 
         other = scope.findresource("File[/tmp/other]")
         assert(other, "Did not find file /tmp/other")
         assert_equal("daemon", other[:owner])
         assert_equal("755", other[:mode])
     end
 
     # Make sure that classes set their namespaces to themselves.  This
     # way they start looking for definitions in their own namespace.
     def test_hostclass_namespace
         scope = mkscope
         parser = scope.compile.parser
 
         # Create a new class
         klass = nil
         assert_nothing_raised do
             klass = parser.newclass "funtest"
         end
 
         # Now define a definition in that namespace
 
         define = nil
         assert_nothing_raised do
             define = parser.newdefine "funtest::mydefine"
         end
 
         assert_equal("funtest", klass.namespace,
             "component namespace was not set in the class")
 
         assert_equal("funtest", define.namespace,
             "component namespace was not set in the definition")
 
         newscope = klass.subscope(scope, mock("resource"))
 
         assert_equal(["funtest"], newscope.namespaces,
             "Scope did not inherit namespace")
 
         # Now make sure we can find the define
         assert(newscope.finddefine("mydefine"),
             "Could not find definition in my enclosing class")
     end
 
     # Make sure that our scope is a subscope of the parentclass's scope.
     # At the same time, make sure definitions in the parent class can be
     # found within the subclass (#517).
     def test_parent_scope_from_parentclass
         scope = mkscope
         parser = scope.compile.parser
 
         source = parser.newclass ""
         parser.newclass("base")
         fun = parser.newdefine("base::fun")
         parser.newclass("middle", :parent => "base")
         parser.newclass("sub", :parent => "middle")
         scope = mkscope :parser => parser
 
         ret = nil
         assert_nothing_raised do
             ret = scope.compile.evaluate_classes(["sub"], scope)
         end
         scope.compile.send(:evaluate_generators)
 
         subscope = scope.compile.class_scope(scope.findclass("sub"))
         assert(subscope, "could not find sub scope")
         mscope = scope.compile.class_scope(scope.findclass("middle"))
         assert(mscope, "could not find middle scope")
         pscope = scope.compile.class_scope(scope.findclass("base"))
         assert(pscope, "could not find parent scope")
 
         assert(pscope == mscope.parent, "parent scope of middle was not set correctly")
         assert(mscope == subscope.parent, "parent scope of sub was not set correctly")
 
         result = mscope.finddefine("fun")
         assert(result, "could not find parent-defined definition from middle")
         assert(fun == result, "found incorrect parent-defined definition from middle")
 
         result = subscope.finddefine("fun")
         assert(result, "could not find parent-defined definition from sub")
         assert(fun == result, "found incorrect parent-defined definition from sub")
     end
+
+    # #795 - make sure the subclass's tags get set before we
+    # evaluate the parent class, so we can be sure that the parent
+    # class can switch based on the sub classes.
+    def test_tags_set_before_parent_is_evaluated
+        scope = mkscope
+        parser = scope.compile.parser
+        base = parser.newclass "base"
+        sub = parser.newclass "sub", :parent => "base"
+
+        base.expects(:safeevaluate).with do |args|
+            assert(scope.compile.configuration.tags.include?("sub"), "Did not tag with sub class name before evaluating base class")
+            base.evaluate(args)
+            true
+        end
+        sub.evaluate :scope => scope, :resource => scope.resource
+    end
 end
diff --git a/test/language/functions.rb b/test/language/functions.rb
index 395577cb6..be06d8eac 100755
--- a/test/language/functions.rb
+++ b/test/language/functions.rb
@@ -1,535 +1,539 @@
 #!/usr/bin/env ruby
 
 $:.unshift("../lib").unshift("../../lib") if __FILE__ =~ /\.rb$/
 
 require 'puppet'
 require 'puppet/parser/parser'
 require 'puppet/network/client'
 require 'puppettest'
 require 'puppettest/resourcetesting'
 
 class TestLangFunctions < Test::Unit::TestCase
     include PuppetTest::ParserTesting
     include PuppetTest::ResourceTesting
     def test_functions
         assert_raise(Puppet::ParseError) do
             Puppet::Parser::AST::Function.new(
                 :name => "fakefunction",
                 :arguments => AST::ASTArray.new(
                     :children => [nameobj("avalue")]
                 )
             )
         end
 
         assert_nothing_raised do
             Puppet::Parser::Functions.newfunction(:fakefunction, :type => :rvalue) do |input|
                 return "output %s" % input[0]
             end
         end
 
         func = nil
         assert_nothing_raised do
             func = Puppet::Parser::AST::Function.new(
                 :name => "fakefunction",
                 :ftype => :rvalue,
                 :arguments => AST::ASTArray.new(
                     :children => [nameobj("avalue")]
                 )
             )
         end
 
         scope = mkscope
         val = nil
         assert_nothing_raised do
             val = func.evaluate(:scope => scope)
         end
 
         assert_equal("output avalue", val)
     end
 
     def test_taggedfunction
         scope = mkscope
-        tags = []
-        scope.resource.stubs(:tags).returns(tags)
-
-        tags << "yayness"
+        scope.resource.tag("yayness")
 
+        # Make sure the ast stuff does what it's supposed to
         {"yayness" => true, "booness" => false}.each do |tag, retval|
             func = taggedobj(tag, :rvalue)
 
             val = nil
             assert_nothing_raised do
                 val = func.evaluate(:scope => scope)
             end
 
             assert_equal(retval, val, "'tagged' returned %s for %s" % [val, tag])
         end
+
+        # Now make sure we correctly get tags.
+        scope.resource.tag("resourcetag")
+        assert(scope.function_tagged("resourcetag"), "tagged function did not catch resource tags")
+        scope.compile.configuration.tag("configtag")
+        assert(scope.function_tagged("configtag"), "tagged function did not catch configuration tags")
     end
 
     def test_failfunction
         func = nil
         assert_nothing_raised do
             func = Puppet::Parser::AST::Function.new(
                 :name => "fail",
                 :ftype => :statement,
                 :arguments => AST::ASTArray.new(
                     :children => [stringobj("this is a failure"),
                         stringobj("and another")]
                 )
             )
         end
 
         scope = mkscope
         val = nil
         assert_raise(Puppet::ParseError) do
             val = func.evaluate(:scope => scope)
         end
     end
 
     def test_multipletemplates
         Dir.mkdir(Puppet[:templatedir])
         onep = File.join(Puppet[:templatedir], "one")
         twop = File.join(Puppet[:templatedir], "two")
 
         File.open(onep, "w") do |f|
             f.puts "template <%= one %>"
         end
 
         File.open(twop, "w") do |f|
             f.puts "template <%= two %>"
         end
         func = nil
         assert_nothing_raised do
             func = Puppet::Parser::AST::Function.new(
                 :name => "template",
                 :ftype => :rvalue,
                 :arguments => AST::ASTArray.new(
                     :children => [stringobj("one"),
                         stringobj("two")]
                 )
             )
         end
         ast = varobj("output", func)
 
         scope = mkscope
         assert_raise(Puppet::ParseError) do
             ast.evaluate(:scope => scope)
         end
 
         scope.setvar("one", "One")
         assert_raise(Puppet::ParseError) do
             ast.evaluate(:scope => scope)
         end
         scope.setvar("two", "Two")
         assert_nothing_raised do
             ast.evaluate(:scope => scope)
         end
 
         assert_equal("template One\ntemplate Two\n", scope.lookupvar("output"),
             "Templates were not handled correctly")
     end
 
     # Now make sure we can fully qualify files, and specify just one
     def test_singletemplates
         template = tempfile()
 
         File.open(template, "w") do |f|
             f.puts "template <%= yayness %>"
         end
 
         func = nil
         assert_nothing_raised do
             func = Puppet::Parser::AST::Function.new(
                 :name => "template",
                 :ftype => :rvalue,
                 :arguments => AST::ASTArray.new(
                     :children => [stringobj(template)]
                 )
             )
         end
         ast = varobj("output", func)
 
         scope = mkscope
         assert_raise(Puppet::ParseError) do
             ast.evaluate(:scope => scope)
         end
 
         scope.setvar("yayness", "this is yayness")
 
         assert_nothing_raised do
             ast.evaluate(:scope => scope)
         end
 
         assert_equal("template this is yayness\n", scope.lookupvar("output"),
             "Templates were not handled correctly")
 
     end
 
     def test_tempatefunction_cannot_see_scopes
         template = tempfile()
 
         File.open(template, "w") do |f|
             f.puts "<%= lookupvar('myvar') %>"
         end
 
         func = nil
         assert_nothing_raised do
             func = Puppet::Parser::AST::Function.new(
                 :name => "template",
                 :ftype => :rvalue,
                 :arguments => AST::ASTArray.new(
                     :children => [stringobj(template)]
                 )
             )
         end
         ast = varobj("output", func)
 
         scope = mkscope
         scope.setvar("myvar", "this is yayness")
         assert_raise(Puppet::ParseError) do
             ast.evaluate(:scope => scope)
         end
     end
 
     def test_template_reparses
         template = tempfile()
 
         File.open(template, "w") do |f|
             f.puts "original text"
         end
 
         manifest = tempfile()
         file = tempfile()
         File.open(manifest, "w") do |f|
             f.puts %{file { "#{file}": content => template("#{template}") }}
         end
 
         interp = Puppet::Parser::Interpreter.new(
             :Manifest => manifest,
             :UseNodes => false
         )
         node = mknode
         node.stubs(:environment).returns("yay")
 
         Puppet[:environment] = "yay"
 
         configuration = nil
         assert_nothing_raised {
             configuration = interp.compile(node)
         }
 
         version = configuration.version
 
         fileobj = configuration.vertices.find { |r| r.title == file }
         assert(fileobj, "File was not in configuration")
 
         assert_equal("original text\n", fileobj["content"],
             "Template did not work")
 
         Puppet[:filetimeout] = -5
         # Have to sleep because one second is the fs's time granularity.
         sleep(1)
 
         # Now modify the template
         File.open(template, "w") do |f|
             f.puts "new text"
         end
 
         newversion = interp.compile(node).version
 
         assert(version != newversion, "Parse date did not change")
     end
 
     def test_template_defined_vars
         template = tempfile()
 
         File.open(template, "w") do |f|
             f.puts "template <%= yayness %>"
         end
 
         func = nil
         assert_nothing_raised do
             func = Puppet::Parser::AST::Function.new(
                 :name => "template",
                 :ftype => :rvalue,
                 :arguments => AST::ASTArray.new(
                     :children => [stringobj(template)]
                 )
             )
         end
         ast = varobj("output", func)
 
         {
             "" => "",
             false => "false",
         }.each do |string, value|
             scope = mkscope
             assert_raise(Puppet::ParseError) do
                 ast.evaluate(:scope => scope)
             end
 
             scope.setvar("yayness", string)
             assert_equal(string, scope.lookupvar("yayness", false))
 
             assert_nothing_raised("An empty string was not a valid variable value") do
                 ast.evaluate(:scope => scope)
             end
 
             assert_equal("template #{value}\n", scope.lookupvar("output"),
                          "%s did not get evaluated correctly" % string.inspect)
         end
     end
 
     def test_autoloading_functions
         assert_equal(false, Puppet::Parser::Functions.function(:autofunc),
             "Got told autofunc already exists")
 
         dir = tempfile()
         $: << dir
         newpath = File.join(dir, "puppet", "parser", "functions")
         FileUtils.mkdir_p(newpath)
 
         File.open(File.join(newpath, "autofunc.rb"), "w") { |f|
             f.puts %{
                 Puppet::Parser::Functions.newfunction(:autofunc, :type => :rvalue) do |vals|
                     Puppet.wanring vals.inspect
                 end
             }
         }
 
         obj = nil
         assert_nothing_raised {
             obj = Puppet::Parser::Functions.function(:autofunc)
         }
 
         assert(obj, "Did not autoload function")
         assert(Puppet::Parser::Scope.method_defined?(:function_autofunc),
             "Did not set function correctly")
     end
 
     def test_realize
         scope = mkscope
         parser = scope.compile.parser
     
         # Make a definition
         parser.newdefine("mytype")
         
         [%w{file /tmp/virtual}, %w{mytype yay}].each do |type, title|
             # Make a virtual resource
             virtual = mkresource(:type => type, :title => title,
                 :virtual => true, :params => {}, :scope => scope)
         
             scope.compile.store_resource(scope, virtual)
 
             ref = Puppet::Parser::Resource::Reference.new(
                 :type => type, :title => title,
                 :scope => scope
             )
             # Now call the realize function
             assert_nothing_raised do
                 scope.function_realize(ref)
             end
 
             # Make sure it created a collection
             assert_equal(1, scope.compile.collections.length,
                 "Did not set collection")
 
             assert_nothing_raised do
                 scope.compile.collections.each do |coll| coll.evaluate end
             end
             scope.compile.collections.clear
 
             # Now make sure the virtual resource is no longer virtual
             assert(! virtual.virtual?, "Did not make virtual resource real")
         end
 
         # Make sure we puke on any resource that doesn't exist
         none = Puppet::Parser::Resource::Reference.new(
             :type => "file", :title => "/tmp/nosuchfile",
             :scope => scope
         )
 
         # The function works
         assert_nothing_raised do
             scope.function_realize(none.to_s)
         end
 
         # Make sure it created a collection
         assert_equal(1, scope.compile.collections.length,
             "Did not set collection")
 
         # And the collection has our resource in it
         assert_equal([none.to_s], scope.compile.collections[0].resources,
             "Did not set resources in collection")
     end
     
     def test_defined
         scope = mkscope
         parser = scope.compile.parser
         
         parser.newclass("yayness")
         parser.newdefine("rahness")
         
         assert_nothing_raised do
             assert(scope.function_defined("yayness"), "yayness class was not considered defined")
             assert(scope.function_defined("rahness"), "rahness definition was not considered defined")
             assert(scope.function_defined("service"), "service type was not considered defined")
             assert(! scope.function_defined("fakness"), "fakeness was considered defined")
         end
         
         # Now make sure any match in a list will work
         assert(scope.function_defined(["booness", "yayness", "fakeness"]),
             "A single answer was not sufficient to return true")
         
         # and make sure multiple falses are still false
         assert(! scope.function_defined(%w{no otherno stillno}),
             "Multiple falses were somehow true")
         
         # Now make sure we can test resources
         scope.compile.store_resource(scope, mkresource(:type => "file", :title => "/tmp/rahness",
             :scope => scope, :source => scope.source,
             :params => {:owner => "root"}))
         
         yep = Puppet::Parser::Resource::Reference.new(:type => "file", :title => "/tmp/rahness")
         nope = Puppet::Parser::Resource::Reference.new(:type => "file", :title => "/tmp/fooness")
         
         assert(scope.function_defined([yep]), "valid resource was not considered defined")
         assert(! scope.function_defined([nope]), "invalid resource was considered defined")
     end
 
     def test_search
         parser = mkparser
         scope = mkscope(:parser => parser)
         
         fun = parser.newdefine("yay::ness")
         foo = parser.newdefine("foo::bar")
 
         search = Puppet::Parser::Functions.function(:search)
         assert_nothing_raised do
             scope.function_search(["foo", "yay"])
         end
 
         ffun = ffoo = nil
         assert_nothing_raised("Search path change did not work") do
             ffun = scope.finddefine("ness")
             ffoo = scope.finddefine('bar')
         end
 
         assert(ffun, "Could not find definition in 'fun' namespace")
         assert(ffoo, "Could not find definition in 'foo' namespace")
     end
 
     def test_include
         scope = mkscope
         parser = scope.compile.parser
 
         assert_raise(Puppet::ParseError, "did not throw error on missing class") do
             scope.function_include("nosuchclass")
         end
 
         parser.newclass("myclass")
 
         assert_nothing_raised do
             scope.function_include "myclass"
         end
 
         assert(scope.compile.resources.find { |r| r.to_s == "Class[myclass]" }, 
             "class was not evaluated")
 
         # Now try multiple classes at once
         classes = %w{one two three}.each { |c| parser.newclass(c) }
 
         assert_nothing_raised do
             scope.function_include classes
         end
 
         classes.each do |c|
             assert(scope.compile.resources.find { |r| r.to_s == "Class[#{c}]" },
                 "class %s was not evaluated" % c)
         end
 
         # Now try a scoped class
         parser.newclass("os::redhat")
 
         assert_nothing_raised("Could not include qualified class name") do
             scope.function_include("os::redhat")
         end
     end
 
     def test_file
         parser = mkparser
         scope = mkscope(:parser => parser)
 
         file1 = tempfile
         file2 = tempfile
         file3 = tempfile
 
         File.open(file2, "w") { |f| f.puts "yaytest" }
 
         val = nil
         assert_nothing_raised("Failed to call file with one arg") do
             val = scope.function_file([file2])
         end
 
         assert_equal("yaytest\n", val, "file() failed")
 
         assert_nothing_raised("Failed to call file with two args") do
             val = scope.function_file([file1, file2])
         end
 
         assert_equal("yaytest\n", val, "file() failed")
 
         assert_raise(Puppet::ParseError, "did not fail when files are missing") do
             val = scope.function_file([file1, file3])
         end
     end
 
     def test_generate
         command = tempfile
         sh = %x{which sh}
         File.open(command, "w") do |f|
             f.puts %{#!#{sh}
             if [ -n "$1" ]; then
                 echo "yay-$1"
             else
                 echo yay
             fi
             }
         end
         File.chmod(0755, command)
         assert_equal("yay\n", %x{#{command}}, "command did not work")
         assert_equal("yay-foo\n", %x{#{command} foo}, "command did not work")
 
         scope = mkscope
         parser = scope.compile.parser
 
         val = nil
         assert_nothing_raised("Could not call generator with no args") do
             val = scope.function_generate([command])
         end
         assert_equal("yay\n", val, "generator returned wrong results")
 
         assert_nothing_raised("Could not call generator with args") do
             val = scope.function_generate([command, "foo"])
         end
         assert_equal("yay-foo\n", val, "generator returned wrong results")
 
         assert_raise(Puppet::ParseError, "Did not fail with an unqualified path") do
             val = scope.function_generate([File.basename(command), "foo"])
         end
 
         assert_raise(Puppet::ParseError, "Did not fail when command failed") do
             val = scope.function_generate([%x{which touch}.chomp, "/this/dir/does/not/exist"])
         end
 
         fake = File.join(File.dirname(command), "..")
         dir = File.dirname(command)
         dirname = File.basename(dir)
         bad = File.join(dir, "..", dirname, File.basename(command))
         assert_raise(Puppet::ParseError, "Did not fail when command failed") do
             val = scope.function_generate([bad])
         end
     end
 end
 
 # $Id$