diff --git a/spec/unit/parser/functions/defined_spec.rb b/spec/unit/parser/functions/defined_spec.rb
index 0dd1dadb8..0113c3233 100755
--- a/spec/unit/parser/functions/defined_spec.rb
+++ b/spec/unit/parser/functions/defined_spec.rb
@@ -1,50 +1,53 @@
 #!/usr/bin/env ruby
 
 require File.expand_path(File.dirname(__FILE__) + '/../../../spec_helper')
 
 describe "the 'defined' function" do
+  before :all do
+    Puppet::Parser::Functions.autoloader.loadall
+  end
 
   before :each do
     Puppet::Node::Environment.stubs(:current).returns(nil)
     @compiler = Puppet::Parser::Compiler.new(Puppet::Node.new("foo"))
     @scope = Puppet::Parser::Scope.new(:compiler => @compiler)
   end
 
   it "should exist" do
     Puppet::Parser::Functions.function("defined").should == "function_defined"
   end
 
   it "should be true when the name is defined as a class" do
     @scope.known_resource_types.add Puppet::Resource::Type.new(:hostclass, "yayness")
     @scope.function_defined("yayness").should be_true
   end
 
   it "should be true when the name is defined as a definition" do
     @scope.known_resource_types.add Puppet::Resource::Type.new(:definition, "yayness")
     @scope.function_defined("yayness").should be_true
   end
 
   it "should be true when the name is defined as a builtin type" do
     @scope.function_defined("file").should be_true
   end
 
 
   it "should be true when any of the provided names are defined" do
     @scope.known_resource_types.add Puppet::Resource::Type.new(:definition, "yayness")
     @scope.function_defined(["meh", "yayness", "booness"]).should be_true
   end
 
   it "should be false when a single given name is not defined" do
     @scope.function_defined("meh").should be_false
   end
 
   it "should be false when none of the names are defined" do
     @scope.function_defined(["meh", "yayness", "booness"]).should be_false
   end
 
   it "should be true when a resource reference is provided and the resource is in the catalog" do
     resource = Puppet::Resource.new("file", "/my/file")
     @compiler.add_resource(@scope, resource)
     @scope.function_defined(resource).should be_true
   end
 end
diff --git a/spec/unit/parser/functions/extlookup_spec.rb b/spec/unit/parser/functions/extlookup_spec.rb
index a476dc844..46cd3cc27 100755
--- a/spec/unit/parser/functions/extlookup_spec.rb
+++ b/spec/unit/parser/functions/extlookup_spec.rb
@@ -1,95 +1,96 @@
 #! /usr/bin/env ruby
 
 require File.expand_path(File.dirname(__FILE__) + '/../../../spec_helper')
 require 'tempfile'
 
 describe "the extlookup function" do
+  before :all do
+    Puppet::Parser::Functions.autoloader.loadall
+  end
 
   before :each do
     @scope = Puppet::Parser::Scope.new
-
     @scope.stubs(:environment).returns(Puppet::Node::Environment.new('production'))
-    Puppet::Parser::Functions.function("extlookup")
   end
 
   it "should exist" do
     Puppet::Parser::Functions.function("extlookup").should == "function_extlookup"
   end
 
   it "should raise a ParseError if there is less than 1 arguments" do
     lambda { @scope.function_extlookup([]) }.should( raise_error(Puppet::ParseError))
   end
 
   it "should raise a ParseError if there is more than 3 arguments" do
     lambda { @scope.function_extlookup(["foo", "bar", "baz", "gazonk"]) }.should( raise_error(Puppet::ParseError))
   end
 
   it "should return the default" do
     result = @scope.function_extlookup([ "key", "default"])
     result.should == "default"
   end
 
   it "should lookup the key in a supplied datafile" do
     t = Tempfile.new('extlookup.csv') do
       t.puts 'key,value'
       t.puts 'nonkey,nonvalue'
       t.close
 
       result = @scope.function_extlookup([ "key", "default", t.path])
       result.should == "value"
     end
   end
 
   it "should return an array if the datafile contains more than two columns" do
     t = Tempfile.new('extlookup.csv') do
       t.puts 'key,value1,value2'
       t.puts 'nonkey,nonvalue,nonvalue'
       t.close
 
       result = @scope.function_extlookup([ "key", "default", t.path])
       result.should == ["value1", "value2"]
     end
   end
 
   it "should raise an error if there's no matching key and no default" do
     t = Tempfile.new('extlookup.csv') do
       t.puts 'key,value'
       t.puts 'nonkey,nonvalue'
       t.close
 
       result = @scope.function_extlookup([ "key", nil, t.path])
       result.should == "value"
     end
   end
 
   describe "should look in $extlookup_datadir for data files listed by $extlookup_precedence" do
     before do
       @scope.stubs(:lookupvar).with('extlookup_datadir').returns("/tmp")
       File.open("/tmp/one.csv","w"){|one| one.puts "key,value1" }
       File.open("/tmp/two.csv","w") do |two|
         two.puts "key,value2"
         two.puts "key2,value_two"
       end
     end
 
     it "when the key is in the first file" do
       @scope.stubs(:lookupvar).with('extlookup_precedence').returns(["one","two"])
       result = @scope.function_extlookup([ "key" ])
       result.should == "value1"
     end
 
     it "when the key is in the second file" do
       @scope.stubs(:lookupvar).with('extlookup_precedence').returns(["one","two"])
       result = @scope.function_extlookup([ "key2" ])
       result.should == "value_two"
     end
 
     it "should not modify extlookup_precedence data" do
       variable = '%{fqdn}'
       @scope.stubs(:lookupvar).with('extlookup_precedence').returns([variable,"one"])
       @scope.stubs(:lookupvar).with('fqdn').returns('myfqdn')
       result = @scope.function_extlookup([ "key" ])
       variable.should == '%{fqdn}'
     end
   end
 end
diff --git a/spec/unit/parser/functions/fqdn_rand_spec.rb b/spec/unit/parser/functions/fqdn_rand_spec.rb
old mode 100644
new mode 100755
index 151ebac9a..be2e6fa76
--- a/spec/unit/parser/functions/fqdn_rand_spec.rb
+++ b/spec/unit/parser/functions/fqdn_rand_spec.rb
@@ -1,62 +1,65 @@
 #! /usr/bin/env ruby
 
 require File.expand_path(File.dirname(__FILE__) + '/../../../spec_helper')
 
 describe "the fqdn_rand function" do
+  before :all do
+    Puppet::Parser::Functions.autoloader.loadall
+  end
 
   before :each do
     @scope = Puppet::Parser::Scope.new
   end
 
   it "should exist" do
     Puppet::Parser::Functions.function("fqdn_rand").should == "function_fqdn_rand"
   end
 
   it "should handle 0 arguments" do
     @scope.expects(:lookupvar).with("fqdn").returns("127.0.0.1")
     lambda { @scope.function_fqdn_rand([]) }.should_not raise_error(Puppet::ParseError)
   end
 
   it "should handle 1 argument'}" do
     @scope.expects(:lookupvar).with("fqdn").returns("127.0.0.1")
     lambda { @scope.function_fqdn_rand([3]) }.should_not raise_error(Puppet::ParseError)
   end
 
 
   (1..10).each { |n|
     it "should handle #{n} additional arguments" do
       @scope.expects(:lookupvar).with("fqdn").returns("127.0.0.1")
       lambda { @scope.function_fqdn_rand([3,1,2,3,4,5,6,7,8,9,10][0..n]) }.should_not raise_error(Puppet::ParseError)
     end
     it "should handle #{n} additional string arguments" do
       @scope.expects(:lookupvar).with("fqdn").returns("127.0.0.1")
       lambda { @scope.function_fqdn_rand([3,%w{ 1 2 3 4 5 6 7 8 9 10}].flatten[0..n]) }.should_not raise_error(Puppet::ParseError)
     end
   }
 
   it "should return a value less than max" do
     @scope.expects(:lookupvar).with("fqdn").returns("127.0.0.1")
     @scope.function_fqdn_rand([3]).should satisfy {|n| n.to_i < 3 }
   end
 
   it "should return the same values on subsequent invocations for the same host" do
     @scope.expects(:lookupvar).with("fqdn").returns("127.0.0.1").twice
     @scope.function_fqdn_rand([3,4]).should eql(@scope.function_fqdn_rand([3, 4]))
   end
 
   it "should return different sequences of value for different hosts" do
     @scope.expects(:lookupvar).with("fqdn").returns("127.0.0.1")
     val1 = @scope.function_fqdn_rand([10000000,4])
     @scope.expects(:lookupvar).with("fqdn").returns("127.0.0.2")
     val2 = @scope.function_fqdn_rand([10000000,4])
     val1.should_not eql(val2)
   end
 
   it "should return different values for the same hosts with different seeds" do
     @scope.expects(:lookupvar).with("fqdn").returns("127.0.0.1")
     val1 = @scope.function_fqdn_rand([10000000,4])
     @scope.expects(:lookupvar).with("fqdn").returns("127.0.0.1")
     val2 = @scope.function_fqdn_rand([10000000,42])
     val1.should_not eql(val2)
   end
 end
diff --git a/spec/unit/parser/functions/generate_spec.rb b/spec/unit/parser/functions/generate_spec.rb
index 12f454210..d25015b56 100755
--- a/spec/unit/parser/functions/generate_spec.rb
+++ b/spec/unit/parser/functions/generate_spec.rb
@@ -1,41 +1,44 @@
 #! /usr/bin/env ruby
 
 require File.expand_path(File.dirname(__FILE__) + '/../../../spec_helper')
 
 describe "the generate function" do
+  before :all do
+    Puppet::Parser::Functions.autoloader.loadall
+  end
 
   before :each do
     @scope = Puppet::Parser::Scope.new
   end
 
   it "should exist" do
     Puppet::Parser::Functions.function("generate").should == "function_generate"
   end
 
   it "should accept a fully-qualified path as a command" do
     command = File::SEPARATOR + "command"
     Puppet::Util.expects(:execute).with([command]).returns("yay")
     lambda { @scope.function_generate([command]) }.should_not raise_error(Puppet::ParseError)
   end
 
   it "should not accept a relative path as a command" do
     command = "command"
     lambda { @scope.function_generate([command]) }.should raise_error(Puppet::ParseError)
   end
 
   # Really not sure how to implement this test, just sure it needs
   # to be implemented.
   it "should not accept a command containing illegal characters"
 
   it "should not accept a command containing '..'" do
     command = File::SEPARATOR + "command#{File::SEPARATOR}..#{File::SEPARATOR}"
     lambda { @scope.function_generate([command]) }.should raise_error(Puppet::ParseError)
   end
 
   it "should execute the generate script with the correct working directory" do
     command = File::SEPARATOR + "command"
     Dir.expects(:chdir).with(File.dirname(command)).yields
     Puppet::Util.expects(:execute).with([command]).returns("yay")
     lambda { @scope.function_generate([command]) }.should_not raise_error(Puppet::ParseError)
   end
 end
diff --git a/spec/unit/parser/functions/include_spec.rb b/spec/unit/parser/functions/include_spec.rb
old mode 100644
new mode 100755
index 67227e7d9..cfaadfbb6
--- a/spec/unit/parser/functions/include_spec.rb
+++ b/spec/unit/parser/functions/include_spec.rb
@@ -1,33 +1,36 @@
 #!/usr/bin/env ruby
 
 require File.expand_path(File.dirname(__FILE__) + '/../../../spec_helper')
 
 describe "the 'include' function" do
+  before :all do
+    Puppet::Parser::Functions.autoloader.loadall
+  end
 
   before :each do
     Puppet::Node::Environment.stubs(:current).returns(nil)
     @compiler = Puppet::Parser::Compiler.new(Puppet::Node.new("foo"))
     @scope = Puppet::Parser::Scope.new(:compiler => @compiler)
   end
 
   it "should exist" do
     Puppet::Parser::Functions.function("include").should == "function_include"
   end
 
   it "should include a single class" do
     inc = "foo"
     @compiler.expects(:evaluate_classes).with {|klasses,parser,lazy| klasses == [inc]}.returns([inc])
     @scope.function_include("foo")
   end
 
   it "should include multiple classes" do
     inc = ["foo","bar"]
     @compiler.expects(:evaluate_classes).with {|klasses,parser,lazy| klasses == inc}.returns(inc)
     @scope.function_include(["foo","bar"])
   end
 
   it "should not lazily evaluate the included class" do
     @compiler.expects(:evaluate_classes).with {|klasses,parser,lazy| lazy == false}.returns("foo")
     @scope.function_include("foo")
   end
 end
diff --git a/spec/unit/parser/functions/inline_template_spec.rb b/spec/unit/parser/functions/inline_template_spec.rb
index 36d53778d..712c68c69 100755
--- a/spec/unit/parser/functions/inline_template_spec.rb
+++ b/spec/unit/parser/functions/inline_template_spec.rb
@@ -1,59 +1,62 @@
 #!/usr/bin/env ruby
 
 require File.expand_path(File.dirname(__FILE__) + '/../../../spec_helper')
 
 describe "the inline_template function" do
+  before :all do
+    Puppet::Parser::Functions.autoloader.loadall
+  end
 
   before :each do
     @scope = Puppet::Parser::Scope.new
   end
 
   it "should exist" do
     Puppet::Parser::Functions.function("inline_template").should == "function_inline_template"
   end
 
   it "should create a TemplateWrapper when called" do
     tw = stub_everything 'template_wrapper'
 
     Puppet::Parser::TemplateWrapper.expects(:new).returns(tw)
 
     @scope.function_inline_template("test")
   end
 
   it "should pass the template string to TemplateWrapper.result" do
     tw = stub_everything 'template_wrapper'
     Puppet::Parser::TemplateWrapper.stubs(:new).returns(tw)
 
     tw.expects(:result).with("test")
 
     @scope.function_inline_template("test")
   end
 
   it "should return what TemplateWrapper.result returns" do
     tw = stub_everything 'template_wrapper'
     Puppet::Parser::TemplateWrapper.stubs(:new).returns(tw)
 
     tw.expects(:result).returns("template contents evaluated")
 
     @scope.function_inline_template("test").should == "template contents evaluated"
   end
 
   it "should concatenate template wrapper outputs for multiple templates" do
     tw1 = stub_everything "template_wrapper1"
     tw2 = stub_everything "template_wrapper2"
     Puppet::Parser::TemplateWrapper.stubs(:new).returns(tw1,tw2)
     tw1.stubs(:result).returns("result1")
     tw2.stubs(:result).returns("result2")
 
     @scope.function_inline_template(["1","2"]).should == "result1result2"
   end
 
   it "should raise an error if the template raises an error" do
     tw = stub_everything 'template_wrapper'
     Puppet::Parser::TemplateWrapper.stubs(:new).returns(tw)
     tw.stubs(:result).raises
 
     lambda { @scope.function_inline_template("1") }.should raise_error(Puppet::ParseError)
   end
 
-end
\ No newline at end of file
+end
diff --git a/spec/unit/parser/functions/realize_spec.rb b/spec/unit/parser/functions/realize_spec.rb
index 899f69b01..3106c42b6 100755
--- a/spec/unit/parser/functions/realize_spec.rb
+++ b/spec/unit/parser/functions/realize_spec.rb
@@ -1,51 +1,54 @@
 #!/usr/bin/env ruby
 
 require File.expand_path(File.dirname(__FILE__) + '/../../../spec_helper')
 
 describe "the realize function" do
+  before :all do
+    Puppet::Parser::Functions.autoloader.loadall
+  end
 
   before :each do
     @collector = stub_everything 'collector'
     @scope = Puppet::Parser::Scope.new
     @compiler = stub 'compiler'
     @compiler.stubs(:add_collection).with(@collector)
     @scope.stubs(:compiler).returns(@compiler)
   end
 
   it "should exist" do
     Puppet::Parser::Functions.function("realize").should == "function_realize"
   end
 
   it "should create a Collector when called" do
 
     Puppet::Parser::Collector.expects(:new).returns(@collector)
 
     @scope.function_realize("test")
   end
 
   it "should assign the passed-in resources to the collector" do
     Puppet::Parser::Collector.stubs(:new).returns(@collector)
 
     @collector.expects(:resources=).with(["test"])
 
     @scope.function_realize("test")
   end
 
   it "should flatten the resources assigned to the collector" do
     Puppet::Parser::Collector.stubs(:new).returns(@collector)
 
     @collector.expects(:resources=).with(["test"])
 
     @scope.function_realize([["test"]])
   end
 
   it "should let the compiler know this collector" do
     Puppet::Parser::Collector.stubs(:new).returns(@collector)
     @collector.stubs(:resources=).with(["test"])
 
     @compiler.expects(:add_collection).with(@collector)
 
     @scope.function_realize("test")
   end
 
 end
diff --git a/spec/unit/parser/functions/regsubst_spec.rb b/spec/unit/parser/functions/regsubst_spec.rb
index 09aa92d28..1fb8e410c 100755
--- a/spec/unit/parser/functions/regsubst_spec.rb
+++ b/spec/unit/parser/functions/regsubst_spec.rb
@@ -1,192 +1,195 @@
 #! /usr/bin/env ruby
 
 require File.expand_path(File.dirname(__FILE__) + '/../../../spec_helper')
 
 describe "the regsubst function" do
+  before :all do
+    Puppet::Parser::Functions.autoloader.loadall
+  end
 
   before :each do
     @scope = Puppet::Parser::Scope.new
   end
 
   it "should exist" do
     Puppet::Parser::Functions.function("regsubst").should == "function_regsubst"
   end
 
   it "should raise a ParseError if there is less than 3 arguments" do
     lambda { @scope.function_regsubst(["foo", "bar"]) }.should( raise_error(Puppet::ParseError))
   end
 
   it "should raise a ParseError if there is more than 5 arguments" do
     lambda { @scope.function_regsubst(["foo", "bar", "gazonk", "del", "x", "y"]) }.should( raise_error(Puppet::ParseError))
   end
 
 
   it "should raise a ParseError when given a bad flag" do
     lambda { @scope.function_regsubst(["foo", "bar", "gazonk", "X"]) }.should( raise_error(Puppet::ParseError))
   end
 
   it "should raise a ParseError for non-string and non-array target" do
     lambda { @scope.function_regsubst([4711, "bar", "gazonk"]) }.should( raise_error(Puppet::ParseError))
   end
 
   it "should raise a ParseError for array target with non-string element" do
     lambda { @scope.function_regsubst([["x", ["y"], "z"], "bar", "gazonk"]) }.should( raise_error(Puppet::ParseError))
   end
 
   it "should raise a ParseError for a bad regular expression" do
     lambda { @scope.function_regsubst(["foo", "(bar", "gazonk"]) }.should(
       raise_error(Puppet::ParseError))
   end
 
   it "should raise a ParseError for a non-string regular expression" do
     lambda { @scope.function_regsubst(["foo", ["bar"], "gazonk"]) }.should( raise_error(Puppet::ParseError))
   end
 
   it "should handle groups" do
 
     result = @scope.function_regsubst(
 
       [ '130.236.254.10',
 
         '^([0-9]+)[.]([0-9]+)[.]([0-9]+)[.]([0-9]+)$',
         '\4-\3-\2-\1'
       ])
     result.should(eql("10-254-236-130"))
   end
 
   it "should handle simple regexps" do
 
     result = @scope.function_regsubst(
 
       [ "the monkey breaks banana trees",
         "b[an]*a",
 
         "coconut"
       ])
     result.should(eql("the monkey breaks coconut trees"))
   end
 
   it "should handle case-sensitive regexps" do
 
     result = @scope.function_regsubst(
 
       [ "the monkey breaks baNAna trees",
         "b[an]+a",
 
         "coconut"
       ])
     result.should(eql("the monkey breaks baNAna trees"))
   end
 
   it "should handle case-insensitive regexps" do
 
     result = @scope.function_regsubst(
 
       [ "the monkey breaks baNAna trees",
         "b[an]+a",
         "coconut",
 
         "I"
       ])
       result.should(eql("the monkey breaks coconut trees"))
   end
 
   it "should handle global substitutions" do
 
     result = @scope.function_regsubst(
 
       [ "the monkey breaks\tbanana trees",
         "[ \t]",
         "--",
 
         "G"
       ])
     result.should(eql("the--monkey--breaks--banana--trees"))
   end
 
   it "should handle global substitutions with groups" do
 
     result = @scope.function_regsubst(
 
       [ '130.236.254.10',
 
         '([0-9]+)',
         '<\1>',
         'G'
       ])
     result.should(eql('<130>.<236>.<254>.<10>'))
   end
 
   it "should apply on all elements of an array" do
     data = ['130.236.254.10', 'foo.example.com', 'coconut', '10.20.30.40']
     result = @scope.function_regsubst([ data, '[.]', '-'])
     result.should(eql( ['130-236.254.10', 'foo-example.com', 'coconut', '10-20.30.40']))
   end
 
   it "should apply global substitutions on all elements of an array" do
     data = ['130.236.254.10', 'foo.example.com', 'coconut', '10.20.30.40']
     result = @scope.function_regsubst([ data, '[.]', '-', 'G'])
     result.should(eql( ['130-236-254-10', 'foo-example-com', 'coconut', '10-20-30-40']))
   end
 
   it "should handle groups on all elements of an array" do
     data = ['130.236.254.10', 'foo.example.com', 'coconut', '10.20.30.40']
 
       result = @scope.function_regsubst(
 
         [ data,
 
         '^([0-9]+)[.]([0-9]+)[.]([0-9]+)[.]([0-9]+)$',
         '\4-\3-\2-\1'
       ])
     result.should(eql( ['10-254-236-130', 'foo.example.com', 'coconut', '40-30-20-10']))
   end
 
   it "should handle global substitutions with groups on all elements of an array" do
     data = ['130.236.254.10', 'foo.example.com', 'coconut', '10.20.30.40']
 
       result = @scope.function_regsubst(
 
         [ data,
 
         '([^.]+)',
         '<\1>',
         'G'
       ])
 
         result.should(eql(
 
           ['<130>.<236>.<254>.<10>', '<foo>.<example>.<com>',
 
       '<coconut>', '<10>.<20>.<30>.<40>']))
   end
 
   it "should return an array (not a string) for a single element array parameter" do
     data = ['130.236.254.10']
 
       result = @scope.function_regsubst(
 
         [ data,
 
         '([^.]+)',
         '<\1>',
         'G'
       ])
     result.should(eql(['<130>.<236>.<254>.<10>']))
   end
 
   it "should return a string (not a one element array) for a simple string parameter" do
     data = '130.236.254.10'
 
       result = @scope.function_regsubst(
 
         [ data,
 
         '([^.]+)',
         '<\1>',
         'G'
       ])
     result.should(eql('<130>.<236>.<254>.<10>'))
   end
 
 end
diff --git a/spec/unit/parser/functions/require_spec.rb b/spec/unit/parser/functions/require_spec.rb
index 4afbd5a63..edcbc4ae6 100755
--- a/spec/unit/parser/functions/require_spec.rb
+++ b/spec/unit/parser/functions/require_spec.rb
@@ -1,74 +1,77 @@
 #!/usr/bin/env ruby
 
 require File.expand_path(File.dirname(__FILE__) + '/../../../spec_helper')
 
 describe "the require function" do
+  before :all do
+    Puppet::Parser::Functions.autoloader.loadall
+  end
 
   before :each do
     @catalog = stub 'catalog'
     @compiler = stub 'compiler', :catalog => @catalog, :environment => nil
 
     @scope = Puppet::Parser::Scope.new
     @scope.stubs(:findresource)
     @scope.stubs(:compiler).returns(@compiler)
     @klass = stub 'class', :name => "myclass"
     @scope.stubs(:find_hostclass).returns(@klass)
 
     @resource = Puppet::Parser::Resource.new(:file, "/my/file", :scope => @scope, :source => "source")
     @resource.stubs(:metaparam_compatibility_mode?).returns false
     @scope.stubs(:resource).returns @resource
   end
 
   it "should exist" do
     Puppet::Parser::Functions.function("require").should == "function_require"
   end
 
   it "should delegate to the 'include' puppet function" do
     @scope.expects(:function_include).with("myclass")
 
     @scope.function_require("myclass")
   end
 
   it "should set the 'require' prarameter on the resource to a resource reference" do
     @scope.stubs(:function_include)
     @scope.function_require("myclass")
 
     @resource["require"].should be_instance_of(Array)
     @resource["require"][0].should be_instance_of(Puppet::Resource)
   end
 
   it "should verify the 'include' function is loaded" do
     Puppet::Parser::Functions.expects(:function).with(:include).returns(:function_include)
     @scope.stubs(:function_include)
     @scope.function_require("myclass")
   end
 
   it "should include the class but not add a dependency if used on a client not at least version 0.25" do
     @resource.expects(:metaparam_compatibility_mode?).returns true
     @scope.expects(:warning)
     @resource.expects(:set_parameter).never
     @scope.expects(:function_include)
 
     @scope.function_require("myclass")
   end
 
   it "should lookup the absolute class path" do
     @scope.stubs(:function_include)
 
     @scope.expects(:find_hostclass).with("myclass").returns(@klass)
     @klass.expects(:name).returns("myclass")
 
     @scope.function_require("myclass")
   end
 
   it "should append the required class to the require parameter" do
     @scope.stubs(:function_include)
 
     one = Puppet::Resource.new(:file, "/one")
     @resource[:require] = one
     @scope.function_require("myclass")
 
     @resource[:require].should be_include(one)
     @resource[:require].detect { |r| r.to_s == "Class[Myclass]" }.should be_instance_of(Puppet::Resource)
   end
 end
diff --git a/spec/unit/parser/functions/shellquote_spec.rb b/spec/unit/parser/functions/shellquote_spec.rb
index c8b0d650d..55302b97b 100755
--- a/spec/unit/parser/functions/shellquote_spec.rb
+++ b/spec/unit/parser/functions/shellquote_spec.rb
@@ -1,81 +1,84 @@
 #! /usr/bin/env ruby
 
 require File.expand_path(File.dirname(__FILE__) + '/../../../spec_helper')
 
 describe "the shellquote function" do
+  before :all do
+    Puppet::Parser::Functions.autoloader.loadall
+  end
 
   before :each do
     @scope = Puppet::Parser::Scope.new
   end
 
   it "should exist" do
     Puppet::Parser::Functions.function("shellquote").should == "function_shellquote"
   end
 
 
   it "should handle no arguments" do
     result = @scope.function_shellquote([])
     result.should(eql(""))
   end
 
   it "should handle several simple arguments" do
     result = @scope.function_shellquote( ['foo', 'bar@example.com', 'localhost:/dev/null', 'xyzzy+-4711,23'])
     result.should(eql( 'foo bar@example.com localhost:/dev/null xyzzy+-4711,23'))
   end
 
   it "should handle array arguments" do
 
     result = @scope.function_shellquote(
 
       ['foo', ['bar@example.com', 'localhost:/dev/null'],
 
       'xyzzy+-4711,23'])
     result.should(eql(
       'foo bar@example.com localhost:/dev/null xyzzy+-4711,23'))
   end
 
   it "should quote unsafe characters" do
     result = @scope.function_shellquote( ['/etc/passwd ', '(ls)', '*', '[?]', "'&'"])
     result.should(eql( '"/etc/passwd " "(ls)" "*" "[?]" "\'&\'"'))
   end
 
   it "should deal with double quotes" do
     result = @scope.function_shellquote(
       ['"foo"bar"'])
     result.should(eql(
       '\'"foo"bar"\''))
   end
 
   it "should cope with dollar signs" do
     result = @scope.function_shellquote( ['$PATH', 'foo$bar', '"x$"'])
     result.should(eql( "'$PATH' 'foo$bar' '\"x$\"'"))
   end
 
   it "should deal with apostrophes (single quotes)" do
     result = @scope.function_shellquote(
       ["'foo'bar'", "`$'EDITOR'`"])
     result.should(eql(
       '"\'foo\'bar\'" "\\`\\$\'EDITOR\'\\`"'))
   end
 
   it "should cope with grave accents (backquotes)" do
     result = @scope.function_shellquote( ['`echo *`', '`ls "$MAILPATH"`'])
     result.should(eql( "'`echo *`' '`ls \"$MAILPATH\"`'"))
   end
 
   it "should deal with both single and double quotes" do
     result = @scope.function_shellquote( ['\'foo"bar"xyzzy\'', '"foo\'bar\'xyzzy"'])
     result.should(eql( '"\'foo\\"bar\\"xyzzy\'" "\\"foo\'bar\'xyzzy\\""'))
   end
 
   it "should handle multiple quotes *and* dollars and backquotes" do
     result = @scope.function_shellquote( ['\'foo"$x`bar`"xyzzy\''])
     result.should(eql( '"\'foo\\"\\$x\\`bar\\`\\"xyzzy\'"'))
   end
 
   it "should handle linefeeds" do
     result = @scope.function_shellquote( ["foo \n bar"])
     result.should(eql( "\"foo \n bar\""))
   end
 
 end
diff --git a/spec/unit/parser/functions/split_spec.rb b/spec/unit/parser/functions/split_spec.rb
index 39710003b..b892a5c2a 100755
--- a/spec/unit/parser/functions/split_spec.rb
+++ b/spec/unit/parser/functions/split_spec.rb
@@ -1,49 +1,52 @@
 #! /usr/bin/env ruby
 
 require File.expand_path(File.dirname(__FILE__) + '/../../../spec_helper')
 
 describe "the split function" do
+  before :all do
+    Puppet::Parser::Functions.autoloader.loadall
+  end
 
   before :each do
     @scope = Puppet::Parser::Scope.new
   end
 
   it "should exist" do
     Puppet::Parser::Functions.function("split").should == "function_split"
   end
 
   it "should raise a ParseError if there is less than 2 arguments" do
     lambda { @scope.function_split(["foo"]) }.should( raise_error(Puppet::ParseError))
   end
 
   it "should raise a ParseError if there is more than 2 arguments" do
     lambda { @scope.function_split(["foo", "bar", "gazonk"]) }.should( raise_error(Puppet::ParseError))
   end
 
   it "should raise a RegexpError if the regexp is malformed" do
     lambda { @scope.function_split(["foo", "("]) }.should(
         raise_error(RegexpError))
   end
 
 
   it "should handle simple string without metacharacters" do
     result = @scope.function_split([ "130;236;254;10", ";"])
     result.should(eql(["130", "236", "254", "10"]))
   end
 
   it "should handle simple regexps" do
     result = @scope.function_split([ "130.236;254.;10", "[.;]+"])
     result.should(eql(["130", "236", "254", "10"]))
   end
 
   it "should handle groups" do
     result = @scope.function_split([ "130.236;254.;10", "([.;]+)"])
     result.should(eql(["130", ".", "236", ";", "254", ".;", "10"]))
   end
 
   it "should handle simple string without metacharacters" do
     result = @scope.function_split([ "130.236.254.10", ";"])
     result.should(eql(["130.236.254.10"]))
   end
 
 end
diff --git a/spec/unit/parser/functions/sprintf_spec.rb b/spec/unit/parser/functions/sprintf_spec.rb
index 4f29012b3..69fbb5e97 100755
--- a/spec/unit/parser/functions/sprintf_spec.rb
+++ b/spec/unit/parser/functions/sprintf_spec.rb
@@ -1,41 +1,44 @@
 #! /usr/bin/env ruby
 
 require File.expand_path(File.dirname(__FILE__) + '/../../../spec_helper')
 
 describe "the sprintf function" do
+  before :all do
+    Puppet::Parser::Functions.autoloader.loadall
+  end
 
   before :each do
     @scope = Puppet::Parser::Scope.new
   end
 
   it "should exist" do
     Puppet::Parser::Functions.function("sprintf").should == "function_sprintf"
   end
 
   it "should raise a ParseError if there is less than 1 argument" do
     lambda { @scope.function_sprintf([]) }.should( raise_error(Puppet::ParseError))
   end
 
   it "should format integers" do
     result = @scope.function_sprintf(["%+05d", "23"])
     result.should(eql("+0023"))
   end
 
   it "should format floats" do
     result = @scope.function_sprintf(["%+.2f", "2.7182818284590451"])
     result.should(eql("+2.72"))
   end
 
   it "should format large floats" do
     result = @scope.function_sprintf(["%+.2e", "27182818284590451"])
     result.should(eql("+2.72e+16"))
   end
 
   it "should perform more complex formatting" do
     result = @scope.function_sprintf(
       [ "<%.8s:%#5o %#8X (%-8s)>",
         "overlongstring", "23", "48879", "foo" ])
     result.should(eql("<overlong:  027   0XBEEF (foo     )>"))
   end
 
 end
diff --git a/spec/unit/parser/functions/tag_spec.rb b/spec/unit/parser/functions/tag_spec.rb
index e9b5122c7..b6bb45252 100755
--- a/spec/unit/parser/functions/tag_spec.rb
+++ b/spec/unit/parser/functions/tag_spec.rb
@@ -1,25 +1,28 @@
 #! /usr/bin/env ruby
 
 require File.expand_path(File.dirname(__FILE__) + '/../../../spec_helper')
 
 describe "the 'tag' function" do
+  before :all do
+    Puppet::Parser::Functions.autoloader.loadall
+  end
 
   before :each do
     @scope = Puppet::Parser::Scope.new
     @scope.stubs(:environment).returns(nil)
   end
 
   it "should exist" do
     Puppet::Parser::Functions.function(:tag).should == "function_tag"
   end
 
   it "should tag the resource with any provided tags" do
     resource = Puppet::Parser::Resource.new(:file, "/file", :scope => @scope)
     @scope.expects(:resource).returns resource
 
     @scope.function_tag ["one", "two"]
 
     resource.should be_tagged("one")
     resource.should be_tagged("two")
   end
 end
diff --git a/spec/unit/parser/functions/template_spec.rb b/spec/unit/parser/functions/template_spec.rb
index 9dd5cc947..7eaf3554d 100755
--- a/spec/unit/parser/functions/template_spec.rb
+++ b/spec/unit/parser/functions/template_spec.rb
@@ -1,62 +1,65 @@
 #!/usr/bin/env ruby
 
 require File.expand_path(File.dirname(__FILE__) + '/../../../spec_helper')
 
 describe "the template function" do
+  before :all do
+    Puppet::Parser::Functions.autoloader.loadall
+  end
 
   before :each do
     @scope = Puppet::Parser::Scope.new
   end
 
   it "should exist" do
     Puppet::Parser::Functions.function("template").should == "function_template"
   end
 
   it "should create a TemplateWrapper when called" do
     tw = stub_everything 'template_wrapper'
 
     Puppet::Parser::TemplateWrapper.expects(:new).returns(tw)
 
     @scope.function_template("test")
   end
 
   it "should give the template filename to the TemplateWrapper" do
     tw = stub_everything 'template_wrapper'
     Puppet::Parser::TemplateWrapper.stubs(:new).returns(tw)
 
     tw.expects(:file=).with("test")
 
     @scope.function_template("test")
   end
 
   it "should return what TemplateWrapper.result returns" do
     tw = stub_everything 'template_wrapper'
     Puppet::Parser::TemplateWrapper.stubs(:new).returns(tw)
     tw.stubs(:file=).with("test")
 
     tw.expects(:result).returns("template contents evaluated")
 
     @scope.function_template("test").should == "template contents evaluated"
   end
 
   it "should concatenate template wrapper outputs for multiple templates" do
     tw1 = stub_everything "template_wrapper1"
     tw2 = stub_everything "template_wrapper2"
     Puppet::Parser::TemplateWrapper.stubs(:new).returns(tw1,tw2)
     tw1.stubs(:file=).with("1")
     tw2.stubs(:file=).with("2")
     tw1.stubs(:result).returns("result1")
     tw2.stubs(:result).returns("result2")
 
     @scope.function_template(["1","2"]).should == "result1result2"
   end
 
   it "should raise an error if the template raises an error" do
     tw = stub_everything 'template_wrapper'
     Puppet::Parser::TemplateWrapper.stubs(:new).returns(tw)
     tw.stubs(:result).raises
 
     lambda { @scope.function_template("1") }.should raise_error(Puppet::ParseError)
   end
 
-end
\ No newline at end of file
+end
diff --git a/spec/unit/parser/functions/versioncmp_spec.rb b/spec/unit/parser/functions/versioncmp_spec.rb
index 2bc7be801..ddc79cd85 100755
--- a/spec/unit/parser/functions/versioncmp_spec.rb
+++ b/spec/unit/parser/functions/versioncmp_spec.rb
@@ -1,29 +1,32 @@
 #!/usr/bin/env ruby
 
 require File.expand_path(File.dirname(__FILE__) + '/../../../spec_helper')
 
 describe "the versioncmp function" do
+  before :all do
+    Puppet::Parser::Functions.autoloader.loadall
+  end
 
   before :each do
     @scope = Puppet::Parser::Scope.new
   end
 
   it "should exist" do
     Puppet::Parser::Functions.function("versioncmp").should == "function_versioncmp"
   end
 
   it "should raise a ParseError if there is less than 2 arguments" do
     lambda { @scope.function_versioncmp(["1.2"]) }.should raise_error(Puppet::ParseError)
   end
 
   it "should raise a ParseError if there is more than 2 arguments" do
     lambda { @scope.function_versioncmp(["1.2", "2.4.5", "3.5.6"]) }.should raise_error(Puppet::ParseError)
   end
 
   it "should call Puppet::Util::Package.versioncmp (included in scope)" do
     Puppet::Util::Package.expects(:versioncmp).with("1.2", "1.3").returns(-1)
 
     @scope.function_versioncmp(["1.2", "1.3"])
   end
 
 end