diff --git a/spec/unit/parser/functions/contain_spec.rb b/spec/unit/parser/functions/contain_spec.rb
index 7f585d4b6..3c1ba149a 100644
--- a/spec/unit/parser/functions/contain_spec.rb
+++ b/spec/unit/parser/functions/contain_spec.rb
@@ -1,265 +1,235 @@
 #! /usr/bin/env ruby
 require 'spec_helper'
 require 'puppet_spec/compiler'
 require 'puppet/parser/functions'
 require 'matchers/containment_matchers'
 require 'matchers/resource'
 require 'matchers/include_in_order'
+require 'unit/parser/functions/shared'
+
 
 describe 'The "contain" function' do
   include PuppetSpec::Compiler
   include ContainmentMatchers
   include Matchers::Resource
 
   it "includes the class" do
     catalog = compile_to_catalog(<<-MANIFEST)
       class contained {
         notify { "contained": }
       }
 
       class container {
         contain contained
       }
 
       include container
     MANIFEST
 
     expect(catalog.classes).to include("contained")
   end
 
   it "includes the class when using a fully qualified anchored name" do
     catalog = compile_to_catalog(<<-MANIFEST)
       class contained {
         notify { "contained": }
       }
 
       class container {
         contain ::contained
       }
 
       include container
     MANIFEST
 
     expect(catalog.classes).to include("contained")
   end
 
   it "ensures that the edge is with the correct class" do
     catalog = compile_to_catalog(<<-MANIFEST)
       class outer {
         class named { }
         contain named
       }
 
       class named { }
 
       include named
       include outer
     MANIFEST
 
     expect(catalog).to have_resource("Class[Named]")
     expect(catalog).to have_resource("Class[Outer]")
     expect(catalog).to have_resource("Class[Outer::Named]")
     expect(catalog).to contain_class("outer::named").in("outer")
   end
 
   it "makes the class contained in the current class" do
     catalog = compile_to_catalog(<<-MANIFEST)
       class contained {
         notify { "contained": }
       }
 
       class container {
         contain contained
       }
 
       include container
     MANIFEST
 
     expect(catalog).to contain_class("contained").in("container")
   end
 
   it "can contain multiple classes" do
     catalog = compile_to_catalog(<<-MANIFEST)
       class a {
         notify { "a": }
       }
 
       class b {
         notify { "b": }
       }
 
       class container {
         contain a, b
       }
 
       include container
     MANIFEST
 
     expect(catalog).to contain_class("a").in("container")
     expect(catalog).to contain_class("b").in("container")
   end
 
   context "when containing a class in multiple classes" do
     it "creates a catalog with all containment edges" do
       catalog = compile_to_catalog(<<-MANIFEST)
         class contained {
           notify { "contained": }
         }
 
         class container {
           contain contained
         }
 
         class another {
           contain contained
         }
 
         include container
         include another
       MANIFEST
 
       expect(catalog).to contain_class("contained").in("container")
       expect(catalog).to contain_class("contained").in("another")
     end
 
     it "and there are no dependencies applies successfully" do
       manifest = <<-MANIFEST
         class contained {
           notify { "contained": }
         }
 
         class container {
           contain contained
         }
 
         class another {
           contain contained
         }
 
         include container
         include another
       MANIFEST
 
       expect { apply_compiled_manifest(manifest) }.not_to raise_error
     end
 
     it "and there are explicit dependencies on the containing class causes a dependency cycle" do
       manifest = <<-MANIFEST
         class contained {
           notify { "contained": }
         }
 
         class container {
           contain contained
         }
 
         class another {
           contain contained
         }
 
         include container
         include another
 
         Class["container"] -> Class["another"]
       MANIFEST
 
       expect { apply_compiled_manifest(manifest) }.to raise_error(
         Puppet::Error,
         /Found 1 dependency cycle/
       )
     end
   end
 
   it "does not create duplicate edges" do
     catalog = compile_to_catalog(<<-MANIFEST)
       class contained {
         notify { "contained": }
       }
 
       class container {
         contain contained
         contain contained
       }
 
       include container
     MANIFEST
 
     contained = catalog.resource("Class", "contained")
     container = catalog.resource("Class", "container")
 
     expect(catalog.edges_between(container, contained)).to have(1).item
   end
 
   context "when a containing class has a dependency order" do
     it "the contained class is applied in that order" do
       catalog = compile_to_relationship_graph(<<-MANIFEST)
         class contained {
           notify { "contained": }
         }
 
         class container {
           contain contained
         }
 
         class first {
           notify { "first": }
         }
 
         class last {
           notify { "last": }
         }
 
         include container, first, last
 
         Class["first"] -> Class["container"] -> Class["last"]
       MANIFEST
 
       expect(order_resources_traversed_in(catalog)).to include_in_order(
         "Notify[first]", "Notify[contained]", "Notify[last]"
       )
     end
   end
 
-  context "When the future parser is in use" do
+  describe "When the future parser is in use" do
     require 'puppet/pops'
     before(:each) do
       Puppet[:parser] = 'future'
       compiler  = Puppet::Parser::Compiler.new(Puppet::Node.new("foo"))
       @scope = Puppet::Parser::Scope.new(compiler)
     end
 
-    it 'transforms relative names to absolute' do
-      @scope.compiler.expects(:evaluate_classes).with(["::myclass"], @scope, false)
-      @scope.function_contain(["myclass"])
-    end
-
-    it 'accepts a Class[name] type' do
-      @scope.compiler.expects(:evaluate_classes).with(["::myclass"], @scope, false)
-      @scope.function_include([Puppet::Pops::Types::TypeFactory.host_class('myclass')])
-    end
-
-    it 'accepts a Resource[class, name] type' do
-      @scope.compiler.expects(:evaluate_classes).with(["::myclass"], @scope, false)
-      @scope.function_contain([Puppet::Pops::Types::TypeFactory.resource('class', 'myclass')])
-    end
-
-    it 'raises and error for unspecific Class' do
-      expect {
-      @scope.function_contain([Puppet::Pops::Types::TypeFactory.host_class()])
-      }.to raise_error(ArgumentError, /Cannot use an unspecific Class\[\] Type/)
-    end
-
-    it 'raises and error for Resource that is not of class type' do
-      expect {
-      @scope.function_contain([Puppet::Pops::Types::TypeFactory.resource('file')])
-      }.to raise_error(ArgumentError, /Cannot use a Resource\[file\] where a Resource\['class', name\] is expected/)
-    end
-
-    it 'raises and error for Resource[class] that is unspecific' do
-      expect {
-      @scope.function_contain([Puppet::Pops::Types::TypeFactory.resource('class')])
-      }.to raise_error(ArgumentError, /Cannot use an unspecific Resource\['class'\] where a Resource\['class', name\] is expected/)
-    end
+    it_should_behave_like 'all functions transforming relative to absolute names', :function_contain
   end
-
 end
diff --git a/spec/unit/parser/functions/include_spec.rb b/spec/unit/parser/functions/include_spec.rb
index d0ad539ce..f4246a6e3 100755
--- a/spec/unit/parser/functions/include_spec.rb
+++ b/spec/unit/parser/functions/include_spec.rb
@@ -1,92 +1,62 @@
 #! /usr/bin/env ruby
 require 'spec_helper'
+require 'unit/parser/functions/shared'
 
 describe "the 'include' function" do
   before :all do
     Puppet::Parser::Functions.autoloader.loadall
   end
 
   before :each do
     @compiler = Puppet::Parser::Compiler.new(Puppet::Node.new("foo"))
     @scope = Puppet::Parser::Scope.new(@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 include multiple classes passed in an array" do
     inc = ["foo","bar"]
     @compiler.expects(:evaluate_classes).with {|klasses,parser,lazy| klasses == inc}.returns(inc)
     @scope.function_include([["foo","bar"]])
   end
 
   it "should flatten nested arrays" do
     inc = ["foo","bar","baz"]
     @compiler.expects(:evaluate_classes).with {|klasses,parser,lazy| klasses == inc}.returns(inc)
     @scope.function_include([["foo","bar"],"baz"])
   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
 
   it "should raise if the class is not found" do
     @scope.stubs(:source).returns(true)
     expect { @scope.function_include(["nosuchclass"]) }.to raise_error(Puppet::Error)
   end
 
-  context "When the future parser is in use" do
+  describe "When the future parser is in use" do
     require 'puppet/pops'
     before(:each) do
       Puppet[:parser] = 'future'
+      compiler  = Puppet::Parser::Compiler.new(Puppet::Node.new("foo"))
     end
 
-    it 'transforms relative names to absolute' do
-      @scope.compiler.expects(:evaluate_classes).with(["::myclass"], @scope, false)
-      @scope.function_include(["myclass"])
-    end
-
-    it 'accepts a Class[name] type' do
-      @scope.compiler.expects(:evaluate_classes).with(["::myclass"], @scope, false)
-      @scope.function_include([Puppet::Pops::Types::TypeFactory.host_class('myclass')])
-    end
-
-    it 'accepts a Resource[class, name] type' do
-      @scope.compiler.expects(:evaluate_classes).with(["::myclass"], @scope, false)
-      @scope.function_include([Puppet::Pops::Types::TypeFactory.resource('class', 'myclass')])
-    end
-
-    it 'raises and error for unspecific Class' do
-      expect {
-      @scope.function_include([Puppet::Pops::Types::TypeFactory.host_class()])
-      }.to raise_error(ArgumentError, /Cannot use an unspecific Class\[\] Type/)
-    end
-
-    it 'raises and error for Resource that is not of class type' do
-      expect {
-      @scope.function_include([Puppet::Pops::Types::TypeFactory.resource('file')])
-      }.to raise_error(ArgumentError, /Cannot use a Resource\[file\] where a Resource\['class', name\] is expected/)
-    end
-
-    it 'raises and error for Resource[class] that is unspecific' do
-      expect {
-      @scope.function_include([Puppet::Pops::Types::TypeFactory.resource('class')])
-      }.to raise_error(ArgumentError, /Cannot use an unspecific Resource\['class'\] where a Resource\['class', name\] is expected/)
-    end
+    it_should_behave_like 'all functions transforming relative to absolute names', :function_include
   end
-
 end
diff --git a/spec/unit/parser/functions/require_spec.rb b/spec/unit/parser/functions/require_spec.rb
index b5bb3acc4..02e870712 100755
--- a/spec/unit/parser/functions/require_spec.rb
+++ b/spec/unit/parser/functions/require_spec.rb
@@ -1,101 +1,72 @@
 #! /usr/bin/env ruby
 require 'spec_helper'
+require 'unit/parser/functions/shared'
 
 describe "the require function" do
   before :all do
     Puppet::Parser::Functions.autoloader.loadall
   end
 
   before :each do
     @catalog = stub 'catalog'
 
     node      = Puppet::Node.new('localhost')
     compiler  = Puppet::Parser::Compiler.new(node)
     @scope = Puppet::Parser::Scope.new(compiler)
 
     @scope.stubs(:findresource)
     @klass = stub 'class', :name => "myclass"
     @scope.stubs(:find_hostclass).returns(@klass)
 
     @resource = Puppet::Parser::Resource.new(:file, "/my/file", :scope => @scope, :source => "source")
     @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.compiler.expects(:evaluate_classes).with(["myclass"], @scope, false)
 
     @scope.function_require(["myclass"])
   end
 
   it "should set the 'require' parameter on the resource to a resource reference" do
     @scope.compiler.stubs(:evaluate_classes)
     @scope.function_require(["myclass"])
 
     @resource["require"].should be_instance_of(Array)
     @resource["require"][0].should be_instance_of(Puppet::Resource)
   end
 
   it "should lookup the absolute class path" do
     @scope.compiler.stubs(:evaluate_classes)
 
     @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.compiler.stubs(:evaluate_classes)
 
     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
 
-  context "When the future parser is in use" do
+  describe "When the future parser is in use" do
     require 'puppet/pops'
     before(:each) do
       Puppet[:parser] = 'future'
+      compiler  = Puppet::Parser::Compiler.new(Puppet::Node.new("foo"))
     end
 
-    it 'transforms relative names to absolute' do
-      @scope.compiler.expects(:evaluate_classes).with(["::myclass"], @scope, false)
-      @scope.function_require(["myclass"])
-    end
-
-    it 'accepts a Class[name] type' do
-      @scope.compiler.expects(:evaluate_classes).with(["::myclass"], @scope, false)
-      @scope.function_require([Puppet::Pops::Types::TypeFactory.host_class('myclass')])
-    end
-
-    it 'accepts a Resource[class, name] type' do
-      @scope.compiler.expects(:evaluate_classes).with(["::myclass"], @scope, false)
-      @scope.function_require([Puppet::Pops::Types::TypeFactory.resource('class', 'myclass')])
-    end
-
-    it 'raises and error for unspecific Class' do
-      expect {
-      @scope.function_require([Puppet::Pops::Types::TypeFactory.host_class()])
-      }.to raise_error(ArgumentError, /Cannot use an unspecific Class\[\] Type/)
-    end
-
-    it 'raises and error for Resource that is not of class type' do
-      expect {
-      @scope.function_require([Puppet::Pops::Types::TypeFactory.resource('file')])
-      }.to raise_error(ArgumentError, /Cannot use a Resource\[file\] where a Resource\['class', name\] is expected/)
-    end
-
-    it 'raises and error for Resource[class] that is unspecific' do
-      expect {
-      @scope.function_require([Puppet::Pops::Types::TypeFactory.resource('class')])
-      }.to raise_error(ArgumentError, /Cannot use an unspecific Resource\['class'\] where a Resource\['class', name\] is expected/)
-    end
+    it_should_behave_like 'all functions transforming relative to absolute names', :function_require
   end
 end
diff --git a/spec/unit/parser/functions/shared.rb b/spec/unit/parser/functions/shared.rb
new file mode 100644
index 000000000..586fc2a25
--- /dev/null
+++ b/spec/unit/parser/functions/shared.rb
@@ -0,0 +1,43 @@
+
+shared_examples_for 'all functions transforming relative to absolute names' do |func_method|
+
+  it 'transforms relative names to absolute' do
+    @scope.compiler.expects(:evaluate_classes).with(["::myclass"], @scope, false)
+    @scope.send(func_method, ["myclass"])
+  end
+
+  it 'accepts a Class[name] type' do
+    @scope.compiler.expects(:evaluate_classes).with(["::myclass"], @scope, false)
+    @scope.send(func_method, [Puppet::Pops::Types::TypeFactory.host_class('myclass')])
+  end
+
+  it 'accepts a Resource[class, name] type' do
+    @scope.compiler.expects(:evaluate_classes).with(["::myclass"], @scope, false)
+    @scope.send(func_method, [Puppet::Pops::Types::TypeFactory.resource('class', 'myclass')])
+  end
+
+  it 'raises and error for unspecific Class' do
+    expect {
+      @scope.send(func_method, [Puppet::Pops::Types::TypeFactory.host_class()])
+    }.to raise_error(ArgumentError, /Cannot use an unspecific Class\[\] Type/)
+  end
+
+  it 'raises and error for Resource that is not of class type' do
+    expect {
+      @scope.send(func_method, [Puppet::Pops::Types::TypeFactory.resource('file')])
+    }.to raise_error(ArgumentError, /Cannot use a Resource\[file\] where a Resource\['class', name\] is expected/)
+  end
+
+  it 'raises and error for Resource that is unspecific' do
+    expect {
+      @scope.send(func_method, [Puppet::Pops::Types::TypeFactory.resource()])
+    }.to raise_error(ArgumentError, /Cannot use an unspecific Resource\[\] where a Resource\['class', name\] is expected/)
+  end
+
+  it 'raises and error for Resource[class] that is unspecific' do
+    expect {
+      @scope.send(func_method, [Puppet::Pops::Types::TypeFactory.resource('class')])
+    }.to raise_error(ArgumentError, /Cannot use an unspecific Resource\['class'\] where a Resource\['class', name\] is expected/)
+  end
+
+end