puppet 3.8.7-x64-mingw32 → 4.0.0.rc1-x64-mingw32

data/spec/unit/functions/map_spec.rb

@@ -5,15 +5,10 @@ require 'matchers/resource'
 
 require 'shared_behaviours/iterative_functions'
 
-describe 'the map method' do
+describe 'the map method can' do
   include PuppetSpec::Compiler
   include Matchers::Resource
 
-  before :each do
-    Puppet[:parser] = "future"
-  end
-
-  context "using future parser" do
     it 'map on an array (multiplying each value by 2)' do
       catalog = compile_to_catalog(<<-MANIFEST)
         $a = [1,2,3]
@@ -165,5 +160,4 @@ describe 'the map method' do
 
   it_should_behave_like 'all iterative functions argument checks', 'map'
   it_should_behave_like 'all iterative functions hash handling', 'map'
-  end
 end

data/spec/unit/functions/reduce_spec.rb

@@ -8,23 +8,12 @@ describe 'the reduce method' do
   include PuppetSpec::Compiler
   include Matchers::Resource
 
-  before :all do
-    # enable switching back 
-    @saved_parser = Puppet[:parser]
-    # These tests only work with future parser
-  end
-  after :all do
-    # switch back to original 
-    Puppet[:parser] = @saved_parser
-  end
-
   before :each do
     node      = Puppet::Node.new("floppy", :environment => 'production')
     @compiler = Puppet::Parser::Compiler.new(node)
     @scope    = Puppet::Parser::Scope.new(@compiler)
     @topscope = @scope.compiler.topscope
     @scope.parent = @topscope
-    Puppet[:parser] = 'future'
   end
 
   context "should be callable as" do

data/spec/unit/functions/regsubst_spec.rb

@@ -0,0 +1,94 @@
+require 'spec_helper'
+require 'puppet/pops'
+require 'puppet/loaders'
+
+describe 'the regsubst function' do
+
+  before(:all) do
+    loaders = Puppet::Pops::Loaders.new(Puppet::Node::Environment.create(:testing, []))
+    Puppet.push_context({:loaders => loaders}, "test-examples")
+  end
+
+  after(:all) do
+    Puppet::Pops::Loaders.clear
+    Puppet::pop_context()
+  end
+
+  def regsubst(*args)
+    Puppet.lookup(:loaders).puppet_system_loader.load(:function, 'regsubst').call({}, *args)
+  end
+
+  let(:type_parser) { Puppet::Pops::Types::TypeParser.new }
+
+  context 'when using a string pattern' do
+    it 'should raise an Error if there is less than 3 arguments' do
+      expect { regsubst('foo', 'bar') }.to raise_error(/called with mis-matched arguments/)
+    end
+
+    it 'should raise an Error if there is more than 5 arguments' do
+      expect { regsubst('foo', 'bar', 'gazonk', 'G', 'U', 'y') }.to raise_error(/called with mis-matched arguments/)
+    end
+
+    it 'should raise an Error if given a bad flag' do
+      expect { regsubst('foo', 'bar', 'gazonk', 'X') }.to raise_error(/called with mis-matched arguments/)
+    end
+
+    it 'should raise an Error if given a bad encoding' do
+      expect { regsubst('foo', 'bar', 'gazonk', nil, 'X') }.to raise_error(/called with mis-matched arguments/)
+    end
+
+    it 'should raise an Error if given a bad regular expression' do
+      expect { regsubst('foo', '(', 'gazonk') }.to raise_error(/pattern with unmatched parenthesis/)
+    end
+
+    it 'should handle case insensitive flag' do
+      expect(regsubst('the monkey breaks baNAna trees', 'b[an]+a', 'coconut', 'I')).to eql('the monkey breaks coconut trees')
+    end
+  end
+
+  context 'when using a regexp pattern' do
+    it 'should raise an Error if there is less than 3 arguments' do
+      expect { regsubst('foo', /bar/) }.to raise_error(/called with mis-matched arguments/)
+    end
+
+    it 'should raise an Error if there is more than 4 arguments' do
+      expect { regsubst('foo', /bar/, 'gazonk', 'G', 'y') }.to raise_error(/called with mis-matched arguments/)
+    end
+
+    it 'should raise an Error if given a flag other thant G' do
+      expect { regsubst('foo', /bar/, 'gazonk', 'I') }.to raise_error(/called with mis-matched arguments/)
+    end
+
+    it 'should handle global substitutions' do
+      expect(regsubst("the monkey breaks\tbanana trees", /[ \t]/, '--', 'G')).to eql('the--monkey--breaks--banana--trees')
+    end
+
+    it 'should accept Type[Regexp]' do
+      expect(regsubst('abc', type_parser.parse("Regexp['b']"), '_')).to eql('a_c')
+    end
+  end
+
+  context 'when using an array target' do
+
+    it 'should perform substitutions in all elements and return array when using regexp pattern' do
+      expect(regsubst(['a#a', 'b#b', 'c#c'], /#/, '_')).to eql(['a_a', 'b_b', 'c_c'])
+    end
+
+    it 'should perform substitutions in all elements when using string pattern' do
+      expect(regsubst(['a#a', 'b#b', 'c#c'], '#', '_')).to eql(['a_a', 'b_b', 'c_c'])
+    end
+
+    it 'should perform substitutions in all elements when using Type[Regexp] pattern' do
+      expect(regsubst(['a#a', 'b#b', 'c#c'], type_parser.parse('Regexp[/#/]'), '_')).to eql(['a_a', 'b_b', 'c_c'])
+    end
+
+    it 'should handle global substitutions with groups on all elements' do
+      expect(regsubst(
+                 ['130.236.254.10', 'foo.example.com', 'coconut', '10.20.30.40'],
+                 /([^.]+)/,
+                 '<\1>',
+                 'G')
+      ).to eql(['<130>.<236>.<254>.<10>', '<foo>.<example>.<com>','<coconut>', '<10>.<20>.<30>.<40>'])
+    end
+  end
+end

data/spec/unit/functions/scanf_spec.rb

@@ -7,10 +7,6 @@ describe 'the scanf function' do
   include PuppetSpec::Compiler
   include Matchers::Resource
 
-  before :each do
-    Puppet[:parser] = 'future'
-  end
-
   it 'scans a value and returns an array' do
     expect(compile_to_catalog("$x = '42'.scanf('%i')[0] + 1; notify { \"test$x\": }")).to have_resource('Notify[test43]')
   end

data/spec/unit/functions/slice_spec.rb

@@ -7,24 +7,12 @@ describe 'methods' do
   include PuppetSpec::Compiler
   include Matchers::Resource
 
-  before :all do
-    # enable switching back 
-    @saved_parser = Puppet[:parser]
-    # These tests only work with future parser
-    Puppet[:parser] = 'future'
-  end
-  after :all do
-    # switch back to original 
-    Puppet[:parser] = @saved_parser
-  end
-
   before :each do
     node      = Puppet::Node.new("floppy", :environment => 'production')
     @compiler = Puppet::Parser::Compiler.new(node)
     @scope    = Puppet::Parser::Scope.new(@compiler)
     @topscope = @scope.compiler.topscope
     @scope.parent = @topscope
-    Puppet[:parser] = 'future'
   end
 
   context "should be callable on array as" do

data/spec/unit/functions/split_spec.rb

@@ -0,0 +1,46 @@
+require 'spec_helper'
+require 'puppet/pops'
+require 'puppet/loaders'
+
+describe 'the split function' do
+
+  before(:all) do
+    loaders = Puppet::Pops::Loaders.new(Puppet::Node::Environment.create(:testing, []))
+    Puppet.push_context({:loaders => loaders}, "test-examples")
+  end
+
+  after(:all) do
+    Puppet::Pops::Loaders.clear
+    Puppet::pop_context()
+  end
+
+  def split(*args)
+    Puppet.lookup(:loaders).puppet_system_loader.load(:function, 'split').call({}, *args)
+  end
+
+  let(:type_parser) { Puppet::Pops::Types::TypeParser.new }
+
+  it 'should raise an Error if there is less than 2 arguments' do
+    expect { split('a,b') }.to raise_error(/called with mis-matched arguments/)
+  end
+
+  it 'should raise an Error if there is more than 2 arguments' do
+    expect { split('a,b','foo', 'bar') }.to raise_error(/called with mis-matched arguments/)
+  end
+
+  it 'should raise a RegexpError if the regexp is malformed' do
+    expect { split('a,b',')') }.to raise_error(/unmatched close parenthesis/)
+  end
+
+  it 'should handle pattern in string form' do
+    expect(split('a,b',',')).to eql(['a', 'b'])
+  end
+
+  it 'should handle pattern in Regexp form' do
+    expect(split('a,b',/,/)).to eql(['a', 'b'])
+  end
+
+  it 'should handle pattern in Regexp Type form' do
+    expect(split('a,b',type_parser.parse('Regexp[/,/]'))).to eql(['a', 'b'])
+  end
+end

data/spec/unit/functions/with_spec.rb

@@ -7,10 +7,6 @@ describe 'the with function' do
   include PuppetSpec::Compiler
   include Matchers::Resource
 
-  before :each do
-    Puppet[:parser] = 'future'
-  end
-
   it 'calls a lambda passing no arguments' do
     expect(compile_to_catalog("with() || { notify { testing: } }")).to have_resource('Notify[testing]')
   end
@@ -27,14 +23,9 @@ describe 'the with function' do
     expect(compile_to_catalog('notify { test: message => "data" } with(Notify[test]) |$x| { notify { "${x[message]}": } }')).to have_resource('Notify[data]')
   end
 
-  # Conditinoally left out for Ruby 1.8.x since the Proc created for the expected number of arguments will accept
-  # a call with fewer arguments and then pass all arguments to the closure. The closure then receives an argument
-  # array of correct size with nil values instead of an array with too few arguments
-  unless RUBY_VERSION[0,3] == '1.8'
-    it 'errors when not given enough arguments for the lambda' do
-      expect do
-        compile_to_catalog('with(1) |$x, $y| { }')
-      end.to raise_error(/Parameter \$y is required but no value was given/m)
-    end
+  it 'errors when not given enough arguments for the lambda' do
+    expect do
+      compile_to_catalog('with(1) |$x, $y| { }')
+    end.to raise_error(/Parameter \$y is required but no value was given/m)
   end
 end

data/spec/unit/functions4_spec.rb

@@ -53,6 +53,18 @@ describe 'the 4x function api' do
     end.to raise_error(ArgumentError, 'Functions must be based on Puppet::Pops::Functions::Function. Got Object')
   end
 
+  it 'refuses to create functions with parameters that are not named with a symbol' do
+    expect do
+      Puppet::Functions.create_function('testing') do
+        dispatch :test do
+          param 'Integer', 'not_symbol'
+        end
+        def test(x)
+        end
+      end
+    end.to raise_error(ArgumentError, /Parameter name argument must be a Symbol/)
+  end
+
   it 'a function without arguments can be defined and called without dispatch declaration' do
     f = create_noargs_function_class()
     func = f.new(:closure_scope, :loader)
@@ -73,7 +85,7 @@ actual:
     f = create_min_function_class()
     # TODO: Bogus parameters, not yet used
     func = f.new(:closure_scope, :loader)
-    expect(func.is_a?(Puppet::Functions::Function)).to be_true
+    expect(func.is_a?(Puppet::Functions::Function)).to be_truthy
     expect(func.call({}, 10,20)).to eql(10)
   end
 
@@ -81,12 +93,8 @@ actual:
     f = create_min_function_class()
     # TODO: Bogus parameters, not yet used
     func = f.new(:closure_scope, :loader)
-    expect(func.is_a?(Puppet::Functions::Function)).to be_true
-    signature = if RUBY_VERSION =~ /^1\.8/
-      'Any{2}'
-    else
-      'Any x, Any y'
-    end
+    expect(func.is_a?(Puppet::Functions::Function)).to be_truthy
+    signature = 'Any x, Any y'
     expect do
       func.call({}, 10)
     end.to raise_error(ArgumentError, "function 'min' called with mis-matched arguments
@@ -100,12 +108,8 @@ actual:
     f = create_min_function_class()
     # TODO: Bogus parameters, not yet used
     func = f.new(:closure_scope, :loader)
-    expect(func.is_a?(Puppet::Functions::Function)).to be_true
-    signature = if RUBY_VERSION =~ /^1\.8/
-      'Any{2}'
-    else
-      'Any x, Any y'
-    end
+    expect(func.is_a?(Puppet::Functions::Function)).to be_truthy
+    signature = 'Any x, Any y'
     expect do
       func.call({}, 10, 10, 10)
     end.to raise_error(ArgumentError, Regexp.new(Regexp.escape(
@@ -145,7 +149,7 @@ actual:
       f = create_min_function_class_using_dispatch()
       # TODO: Bogus parameters, not yet used
       func = f.new(:closure_scope, :loader)
-      expect(func.is_a?(Puppet::Functions::Function)).to be_true
+      expect(func.is_a?(Puppet::Functions::Function)).to be_truthy
       expect do
         func.call({}, 10, 10, 10)
       end.to raise_error(ArgumentError, Regexp.new(Regexp.escape(
@@ -160,12 +164,8 @@ actual:
       f = create_function_with_optionals_and_varargs()
       # TODO: Bogus parameters, not yet used
       func = f.new(:closure_scope, :loader)
-      expect(func.is_a?(Puppet::Functions::Function)).to be_true
-      signature = if RUBY_VERSION =~ /^1\.8/
-        'Any{2,}'
-      else
-        'Any x, Any y, Any a?, Any b?, Any c{0,}'
-      end
+      expect(func.is_a?(Puppet::Functions::Function)).to be_truthy
+      signature = 'Any x, Any y, Any a?, Any b?, Any c{0,}'
       expect do
         func.call({}, 10)
       end.to raise_error(ArgumentError,
@@ -177,10 +177,10 @@ actual:
     end
 
     it 'an error includes optional indicators and count for last element when defined via dispatch' do
-      f = create_function_with_optionals_and_repeated_via_dispatch()
+      f = create_function_with_optionals_and_varargs_via_dispatch()
       # TODO: Bogus parameters, not yet used
       func = f.new(:closure_scope, :loader)
-      expect(func.is_a?(Puppet::Functions::Function)).to be_true
+      expect(func.is_a?(Puppet::Functions::Function)).to be_truthy
       expect do
         func.call({}, 10)
       end.to raise_error(ArgumentError,
@@ -191,39 +191,6 @@ actual:
   min(Integer) - arg count {1}")
     end
 
-    it 'can create optional repeated parameter' do
-      f = create_function_with_repeated
-      func = f.new(:closure_scope, :loader)
-      expect(func.call({})).to eql(0)
-      expect(func.call({}, 1)).to eql(1)
-      expect(func.call({}, 1, 2)).to eql(2)
-
-      f = create_function_with_optional_repeated
-      func = f.new(:closure_scope, :loader)
-      expect(func.call({})).to eql(0)
-      expect(func.call({}, 1)).to eql(1)
-      expect(func.call({}, 1, 2)).to eql(2)
-    end
-
-    it 'can create required repeated parameter' do
-      f = create_function_with_required_repeated
-      func = f.new(:closure_scope, :loader)
-      expect(func.call({}, 1)).to eql(1)
-      expect(func.call({}, 1, 2)).to eql(2)
-      expect { func.call({}) }.to raise_error(ArgumentError,
-"function 'count_args' called with mis-matched arguments
-expected:
-  count_args(Any c{1,}) - arg count {1,}
-actual:
-  count_args(Undef{0}) - arg count {0}")
-    end
-
-    it 'can create scope_param followed by repeated  parameter' do
-      f = create_function_with_scope_param_required_repeat
-      func = f.new(:closure_scope, :loader)
-      expect(func.call({}, 'yay', 1,2,3)).to eql([{}, 'yay',1,2,3])
-    end
-
     it 'a function can use inexact argument mapping' do
       f = create_function_with_inexact_dispatch
       func = f.new(:closure_scope, :loader)
@@ -246,15 +213,11 @@ actual:
       expect { create_function_with_rq_after_opt }.to raise_error(ArgumentError, 'A required parameter cannot be added after an optional parameter')
     end
 
-    it 'a function can not be created with required repeated parameters declared after optional ones' do
-      expect { create_function_with_rq_repeated_after_opt }.to raise_error(ArgumentError, 'A required repeated parameter cannot be added after an optional parameter')
-    end
-
     it 'an error is raised with reference to multiple methods when called with mis-matched arguments' do
       f = create_min_function_class_disptaching_to_two_methods()
       # TODO: Bogus parameters, not yet used
       func = f.new(:closure_scope, :loader)
-      expect(func.is_a?(Puppet::Functions::Function)).to be_true
+      expect(func.is_a?(Puppet::Functions::Function)).to be_truthy
       expect do
         func.call({}, 10, 10, 10)
       end.to raise_error(ArgumentError,
@@ -365,14 +328,14 @@ actual:
         signatures = fc.signatures
         expect(signatures.size).to eql(1)
         signature = signatures[0]
-        expect(signature.last_captures_rest?).to be_true
+        expect(signature.last_captures_rest?).to be_truthy
       end
 
       it 'about optional and required parameters' do
         fc = create_function_with_optionals_and_varargs
         signature = fc.signatures[0]
-        expect(signature.args_range).to eql( [2, Puppet::Pops::Types::INFINITY ] )
-        expect(signature.infinity?(signature.args_range[1])).to be_true
+        expect(signature.args_range).to eql( [2, Float::INFINITY ] )
+        expect(signature.infinity?(signature.args_range[1])).to be_truthy
       end
 
       it 'about block not being allowed' do
@@ -402,41 +365,38 @@ actual:
         expect(signature.type.class).to be(Puppet::Pops::Types::PCallableType)
       end
 
-      # conditional on Ruby 1.8.7 which does not do parameter introspection
-      if Method.method_defined?(:parameters)
-        it 'about parameter names obtained from ruby introspection' do
-          fc = create_min_function_class
-          signature = fc.signatures[0]
-          expect(signature.parameter_names).to eql(['x', 'y'])
-        end
+      it 'about parameter names obtained from ruby introspection' do
+        fc = create_min_function_class
+        signature = fc.signatures[0]
+        expect(signature.parameter_names).to eql(['x', 'y'])
       end
 
       it 'about parameter names specified with dispatch' do
         fc = create_min_function_class_using_dispatch
         signature = fc.signatures[0]
-        expect(signature.parameter_names).to eql(['a', 'b'])
+        expect(signature.parameter_names).to eql([:a, :b])
       end
 
       it 'about block_name when it is *not* given in the definition' do
         # neither type, nor name
         fc = create_function_with_required_block_all_defaults
         signature = fc.signatures[0]
-        expect(signature.block_name).to eql('block')
+        expect(signature.block_name).to eql(:block)
         # no name given, only type
         fc = create_function_with_required_block_given_type
         signature = fc.signatures[0]
-        expect(signature.block_name).to eql('block')
+        expect(signature.block_name).to eql(:block)
       end
 
       it 'about block_name when it *is* given in the definition' do
         # neither type, nor name
         fc = create_function_with_required_block_default_type
         signature = fc.signatures[0]
-        expect(signature.block_name).to eql('the_block')
+        expect(signature.block_name).to eql(:the_block)
         # no name given, only type
         fc = create_function_with_required_block_fully_specified
         signature = fc.signatures[0]
-        expect(signature.block_name).to eql('the_block')
+        expect(signature.block_name).to eql(:the_block)
       end
     end
 
@@ -450,7 +410,7 @@ actual:
       end
 
       it 'such that, other functions are callable by name' do
-        fc = Puppet::Functions.create_function(:test) do
+        fc = Puppet::Functions.create_function('test') do
           def test()
             # Call a function available in the puppet system
             call_function('assert_type', 'Integer', 10)
@@ -462,7 +422,7 @@ actual:
       end
 
       it 'such that, calling a non existing function raises an error' do
-        fc = Puppet::Functions.create_function(:test) do
+        fc = Puppet::Functions.create_function('test') do
           def test()
             # Call a function not available in the puppet system
             call_function('no_such_function', 'Integer', 'hello')
@@ -485,13 +445,6 @@ actual:
 
       before(:each) do
         Puppet[:strict_variables] = true
-
-        # These must be set since the is 3x logic that triggers on these even if the tests are explicit
-        # about selection of parser and evaluator
-        #
-        Puppet[:parser] = 'future'
-        # Puppetx cannot be loaded until the correct parser has been set (injector is turned off otherwise)
-        require 'puppetx'
       end
 
       let(:parser) {  Puppet::Pops::Parser::EvaluatingParser.new }
@@ -502,7 +455,7 @@ actual:
         # construct ruby function to call
         fc = Puppet::Functions.create_function('testing::test') do
           dispatch :test do
-            param 'Integer', 'x'
+            param 'Integer', :x
             # block called 'the_block', and using "all_callables"
             required_block_param #(all_callables(), 'the_block')
           end
@@ -560,8 +513,8 @@ actual:
   def create_min_function_class_using_dispatch
     f = Puppet::Functions.create_function('min') do
         dispatch :min do
-          param 'Numeric', 'a'
-          param 'Numeric', 'b'
+          param 'Numeric', :a
+          param 'Numeric', :b
         end
       def min(x,y)
         x <= y ? x : y
@@ -572,13 +525,13 @@ actual:
   def create_min_function_class_disptaching_to_two_methods
     f = Puppet::Functions.create_function('min') do
       dispatch :min do
-        param 'Numeric', 'a'
-        param 'Numeric', 'b'
+        param 'Numeric', :a
+        param 'Numeric', :b
       end
 
       dispatch :min_s do
-        param 'String', 's1'
-        param 'String', 's2'
+        param 'String', :s1
+        param 'String', :s2
       end
 
       def min(x,y)
@@ -600,7 +553,7 @@ actual:
     end
   end
 
-  def create_function_with_optionals_and_repeated_via_dispatch
+  def create_function_with_optionals_and_varargs_via_dispatch
     f = Puppet::Functions.create_function('min') do
       dispatch :min do
         param 'Numeric', :x
@@ -615,39 +568,6 @@ actual:
     end
   end
 
-  def create_function_with_repeated
-    f = Puppet::Functions.create_function('count_args') do
-      dispatch :count_args do
-        repeated_param 'Any', :c
-      end
-      def count_args(*c)
-        c.size
-      end
-    end
-  end
-
-  def create_function_with_optional_repeated
-    f = Puppet::Functions.create_function('count_args') do
-      dispatch :count_args do
-        optional_repeated_param 'Any', :c
-      end
-      def count_args(*c)
-        c.size
-      end
-    end
-  end
-
-  def create_function_with_required_repeated
-    f = Puppet::Functions.create_function('count_args') do
-      dispatch :count_args do
-        required_repeated_param 'Any', :c
-      end
-      def count_args(*c)
-        c.size
-      end
-    end
-  end
-
   def create_function_with_inexact_dispatch
     f = Puppet::Functions.create_function('t1') do
       dispatch :t1 do
@@ -678,18 +598,6 @@ actual:
     end
   end
 
-  def create_function_with_rq_repeated_after_opt
-    f = Puppet::Functions.create_function('t1') do
-      dispatch :t1 do
-        optional_param 'Numeric', :x
-        required_repeated_param 'Numeric', :y
-      end
-      def t1(x, *y)
-        x
-      end
-    end
-  end
-
   def create_function_with_param_after_repeated
     f = Puppet::Functions.create_function('t1') do
       dispatch :t1 do
@@ -721,10 +629,10 @@ actual:
       attr_injected_producer Puppet::Pops::Types::TypeFactory.integer(), :serial, "an_int"
 
       dispatch :test do
-        injected_param Puppet::Pops::Types::TypeFactory.string, 'x', 'a_string'
-        injected_producer_param Puppet::Pops::Types::TypeFactory.integer, 'y', 'an_int'
-        param 'Scalar', 'a'
-        param 'Scalar', 'b'
+        injected_param Puppet::Pops::Types::TypeFactory.string, :x, 'a_string'
+        injected_producer_param Puppet::Pops::Types::TypeFactory.integer, :y, 'an_int'
+        param 'Scalar', :a
+        param 'Scalar', :b
       end
 
       def test(x,y,a,b)
@@ -737,7 +645,7 @@ actual:
   def create_function_with_required_block_all_defaults
     f = Puppet::Functions.create_function('test') do
       dispatch :test do
-        param 'Integer', 'x'
+        param 'Integer', :x
         # use defaults, any callable, name is 'block'
         block_param
       end
@@ -751,7 +659,7 @@ actual:
     f = Puppet::Functions.create_function('test', Puppet::Functions::InternalFunction) do
       dispatch :test do
         scope_param
-        param 'Integer', 'x'
+        param 'Integer', :x
         # use defaults, any callable, name is 'block'
         required_block_param
       end
@@ -764,9 +672,9 @@ actual:
   def create_function_with_required_block_default_type
     f = Puppet::Functions.create_function('test') do
       dispatch :test do
-        param 'Integer', 'x'
+        param 'Integer', :x
         # use defaults, any callable, name is 'block'
-        required_block_param 'the_block'
+        required_block_param :the_block
       end
       def test(x)
         yield
@@ -774,23 +682,10 @@ actual:
     end
   end
 
-  def create_function_with_scope_param_required_repeat
-    f = Puppet::Functions.create_function('test', Puppet::Functions::InternalFunction) do
-      dispatch :test do
-        scope_param
-        param 'Any', 'extra'
-        repeated_param 'Any', 'the_block'
-      end
-      def test(scope, *args)
-        [scope, *args]
-      end
-    end
-  end
-
   def create_function_with_required_block_given_type
     f = Puppet::Functions.create_function('test') do
       dispatch :test do
-        param 'Integer', 'x'
+        param 'Integer', :x
         required_block_param
       end
       def test(x)
@@ -802,9 +697,9 @@ actual:
   def create_function_with_required_block_fully_specified
     f = Puppet::Functions.create_function('test') do
       dispatch :test do
-        param 'Integer', 'x'
+        param 'Integer', :x
         # use defaults, any callable, name is 'block'
-        required_block_param('Callable', 'the_block')
+        required_block_param('Callable', :the_block)
       end
       def test(x)
         yield
@@ -815,7 +710,7 @@ actual:
   def create_function_with_optional_block_all_defaults
     f = Puppet::Functions.create_function('test') do
       dispatch :test do
-        param 'Integer', 'x'
+        param 'Integer', :x
         # use defaults, any callable, name is 'block'
         optional_block_param
       end