puppet 7.27.0-x86-mingw32 → 7.29.0-x86-mingw32

data/spec/unit/functions/next_spec.rb

@@ -1,93 +0,0 @@
-require 'spec_helper'
-
-require 'puppet_spec/compiler'
-require 'matchers/resource'
-
-describe 'the next function' do
-  include PuppetSpec::Compiler
-  include Matchers::Resource
-
-  context 'exits a block yielded to iteratively' do
-    it 'with a given value as result for this iteration' do
-      expect(compile_to_catalog(<<-CODE)).to have_resource('Notify[[100, 4, 6]]')
-          $result = String([1,2,3].map |$x| { if $x == 1 { next(100) } $x*2 })
-          notify { $result: }
-        CODE
-    end
-
-    it 'with undef value as result for this iteration when next is not given an argument' do
-      expect(compile_to_catalog(<<-CODE)).to have_resource('Notify[[undef, 4, 6]]')
-          $result = String([1,2,3].map |$x| { if $x == 1 { next() } $x*2 })
-          notify { $result: }
-        CODE
-    end
-  end
-
-  it 'can be called without parentheses around the argument' do
-    expect(compile_to_catalog(<<-CODE)).to have_resource('Notify[[100, 4, 6]]')
-        $result = String([1,2,3].map |$x| { if $x == 1 { next 100 } $x*2 })
-        notify { $result: }
-      CODE
-  end
-
-  it 'has the same effect as a return when called from within a block not used in an iteration' do
-    expect(compile_to_catalog(<<-CODE)).to have_resource('Notify[100]')
-        $result = String(with(1) |$x| { if $x == 1 { next(100) } 200 })
-        notify { $result: }
-      CODE
-  end
-
-  it 'has the same effect as a return when called from within a function' do
-    expect(compile_to_catalog(<<-CODE)).to have_resource('Notify[[102, 200, 300]]')
-        function do_next() {
-          next(100)
-        }
-        $result = String([1,2,3].map |$x| { if $x == 1 { next do_next()+2 } $x*do_next() })
-        notify { $result: }
-      CODE
-  end
-
-  it 'provides early exit from a class and keeps the class' do
-    expect(eval_and_collect_notices(<<-CODE)).to eql(['a', 'c', 'true', 'true'])
-        class notices_c { notice 'c' }
-        class does_next {
-          notice 'a'
-          if 1 == 1 { next() } # avoid making next line statically unreachable
-          notice 'b'
-        }
-        # include two classes to check that next does not do an early return from
-        # the include function.
-        include(does_next, notices_c)
-        notice defined(does_next)
-        notice defined(notices_c)
-      CODE
-  end
-
-  it 'provides early exit from a user defined resource and keeps the resource' do
-    expect(eval_and_collect_notices(<<-CODE)).to eql(['the_doer_of_next', 'copy_cat', 'true', 'true'])
-        define does_next {
-          notice $title
-          if 1 == 1 { next() } # avoid making next line statically unreachable
-          notice 'b'
-        }
-        define checker {
-          notice defined(Does_next['the_doer_of_next'])
-          notice defined(Does_next['copy_cat'])
-        }
-        # create two instances to ensure next does not break the entire
-        # resource expression
-        does_next { ['the_doer_of_next', 'copy_cat']: }
-        checker { 'needed_because_evaluation_order': }
-      CODE
-  end
-
-  it 'can not be called from top scope' do
-    expect do
-      compile_to_catalog(<<-CODE)
-        # line 1
-        # line 2
-        next()
-      CODE
-    end.to raise_error(/next\(\) from context where this is illegal \(file: unknown, line: 3\) on node.*/)
-  end
-end

data/spec/unit/functions/partition_spec.rb

@@ -1,40 +0,0 @@
-require 'spec_helper'
-
-require 'puppet_spec/compiler'
-require 'matchers/resource'
-
-describe 'the partition function' do
-  include PuppetSpec::Compiler
-  include Matchers::Resource
-
-  context 'for an array' do
-    it 'partitions by item' do
-      manifest = "notify { String(partition(['', b, ab]) |$s| { $s.empty }): }"
-      expect(compile_to_catalog(manifest)).to have_resource("Notify[[[''], ['b', 'ab']]]")
-    end
-
-    it 'partitions by index, item' do
-      manifest = "notify { String(partition(['', b, ab]) |$i, $s| { $i == 2 or $s.empty }): }"
-      expect(compile_to_catalog(manifest)).to have_resource("Notify[[['', 'ab'], ['b']]]")
-    end
-  end
-
-  context 'for a hash' do
-    it 'partitions by key-value pair' do
-      manifest = "notify { String(partition(a => [1, 2], b => []) |$kv| { $kv[1].empty }): }"
-      expect(compile_to_catalog(manifest)).to have_resource("Notify[[[['b', []]], [['a', [1, 2]]]]]")
-    end
-
-    it 'partitions by key, value' do
-      manifest = "notify { String(partition(a => [1, 2], b => []) |$k, $v| { $v.empty }): }"
-      expect(compile_to_catalog(manifest)).to have_resource("Notify[[[['b', []]], [['a', [1, 2]]]]]")
-    end
-  end
-
-  context 'for a string' do
-    it 'fails' do
-      manifest = "notify { String(partition('something') |$s| { $s.empty }): }"
-      expect { compile_to_catalog(manifest) }.to raise_error(Puppet::PreformattedError)
-    end
-  end
-end

data/spec/unit/functions/reduce_spec.rb

@@ -1,85 +0,0 @@
-require 'puppet'
-require 'spec_helper'
-require 'puppet_spec/compiler'
-require 'matchers/resource'
-require 'shared_behaviours/iterative_functions'
-
-describe 'the reduce method' do
-  include PuppetSpec::Compiler
-  include Matchers::Resource
-
-  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
-  end
-
-  context "should be callable as" do
-    it 'reduce on an array' do
-      catalog = compile_to_catalog(<<-MANIFEST)
-        $a = [1,2,3]
-        $b = $a.reduce |$memo, $x| { $memo + $x }
-        file { "/file_$b": ensure => present }
-      MANIFEST
-
-      expect(catalog).to have_resource("File[/file_6]").with_parameter(:ensure, 'present')
-    end
-
-    it 'reduce on an array with captures rest in lambda' do
-      catalog = compile_to_catalog(<<-MANIFEST)
-        $a = [1,2,3]
-        $b = $a.reduce |*$mx| { $mx[0] + $mx[1] }
-        file { "/file_$b": ensure => present }
-      MANIFEST
-
-      expect(catalog).to have_resource("File[/file_6]").with_parameter(:ensure, 'present')
-    end
-
-    it 'reduce on enumerable type' do
-      catalog = compile_to_catalog(<<-MANIFEST)
-        $a = Integer[1,3]
-        $b = $a.reduce |$memo, $x| { $memo + $x }
-        file { "/file_$b": ensure => present }
-      MANIFEST
-
-      expect(catalog).to have_resource("File[/file_6]").with_parameter(:ensure, 'present')
-    end
-
-    it 'reduce on an array with start value' do
-      catalog = compile_to_catalog(<<-MANIFEST)
-        $a = [1,2,3]
-        $b = $a.reduce(4) |$memo, $x| { $memo + $x }
-        file { "/file_$b": ensure => present }
-      MANIFEST
-
-      expect(catalog).to have_resource("File[/file_10]").with_parameter(:ensure, 'present')
-    end
-
-    it 'reduce on a hash' do
-      catalog = compile_to_catalog(<<-MANIFEST)
-        $a = {a=>1, b=>2, c=>3}
-        $start = [ignored, 4]
-        $b = $a.reduce |$memo, $x| {['sum', $memo[1] + $x[1]] }
-        file { "/file_${$b[0]}_${$b[1]}": ensure => present }
-      MANIFEST
-
-      expect(catalog).to have_resource("File[/file_sum_6]").with_parameter(:ensure, 'present')
-    end
-
-    it 'reduce on a hash with start value' do
-      catalog = compile_to_catalog(<<-MANIFEST)
-        $a = {a=>1, b=>2, c=>3}
-        $start = ['ignored', 4]
-        $b = $a.reduce($start) |$memo, $x| { ['sum', $memo[1] + $x[1]] }
-        file { "/file_${$b[0]}_${$b[1]}": ensure => present }
-      MANIFEST
-
-      expect(catalog).to have_resource("File[/file_sum_10]").with_parameter(:ensure, 'present')
-    end
-  end
-
-  it_should_behave_like 'all iterative functions argument checks', 'reduce'
-
-end

data/spec/unit/functions/regsubst_spec.rb

@@ -1,114 +0,0 @@
-require 'spec_helper'
-require 'puppet/pops'
-require 'puppet/loaders'
-
-describe 'the regsubst function' do
-
-  before(:each) do
-    loaders = Puppet::Pops::Loaders.new(Puppet::Node::Environment.create(:testing, []))
-    Puppet.push_context({:loaders => loaders}, "test-examples")
-  end
-
-  after(:each) do
-    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.singleton }
-
-  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(/expects between 3 and 5 arguments, got 2/)
-    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(/expects between 3 and 5 arguments, got 6/)
-    end
-
-    it 'should raise an Error if given a bad flag' do
-      expect { regsubst('foo', 'bar', 'gazonk', 'X') }.to raise_error(/parameter 'flags' expects an undef value or a match for Pattern\[\/\^\[GEIM\]\*\$\/\], got 'X'/)
-    end
-
-    it 'should raise an Error if given a bad encoding' do
-      expect { regsubst('foo', 'bar', 'gazonk', nil, 'X') }.to raise_error(/parameter 'encoding' expects a match for Enum\['E', 'N', 'S', 'U'\], got 'X'/)
-    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
-
-    it 'should allow hash as replacement' do
-      expect(regsubst('tuto', '[uo]', { 'u' => 'o', 'o' => 'u' }, 'G')).to eql('totu')
-    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(/expects between 3 and 5 arguments, got 2/)
-    end
-
-    it 'should raise an Error if there is more than 5 arguments' do
-      expect { regsubst('foo', /bar/, 'gazonk', 'G', 'E', 'y') }.to raise_error(/expects between 3 and 5 arguments, got 6/)
-    end
-
-    it 'should raise an Error if given a flag other thant G' do
-      expect { regsubst('foo', /bar/, 'gazonk', 'I') }.to raise_error(/expects one of/)
-    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
-
-    it 'should treat Regexp as Regexp[//]' do
-      expect(regsubst('abc', type_parser.parse("Regexp"), '_', 'G')).to eql('_a_b_c_')
-    end
-
-    it 'should allow hash as replacement' do
-      expect(regsubst('tuto', /[uo]/, { 'u' => 'o', 'o' => 'u' }, 'G')).to eql('totu')
-    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
-
-    it 'should return an empty array if given an empty array and string pattern' do
-      expect(regsubst([], '', '')).to eql([])
-    end
-
-    it 'should return an empty array if given an empty array and regexp pattern' do
-      expect(regsubst([], //, '')).to eql([])
-    end
-
-  end
-end

data/spec/unit/functions/require_spec.rb

@@ -1,82 +0,0 @@
-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/functions/shared'
-
-describe 'The "require" function' do
-  include PuppetSpec::Compiler
-  include ContainmentMatchers
-  include Matchers::Resource
-
-  before(:each) do
-    compiler  = Puppet::Parser::Compiler.new(Puppet::Node.new("foo"))
-    @scope = compiler.topscope
-  end
-
-  it 'includes a class that is not already included' do
-    catalog = compile_to_catalog(<<-MANIFEST)
-      class required {
-        notify { "required": }
-      }
-      require required
-    MANIFEST
-
-    expect(catalog.classes).to include("required")
-  end
-
-  it 'sets the require attribute on the requiring resource' do
-    catalog = compile_to_catalog(<<-MANIFEST)
-      class required {
-        notify { "required": }
-      }
-      class requiring {
-        require required
-      }
-      include requiring
-    MANIFEST
-
-    requiring = catalog.resource("Class", "requiring")
-    expect(requiring["require"]).to be_instance_of(Array)
-    expect(requiring["require"][0]).to be_instance_of(Puppet::Resource)
-    expect(requiring["require"][0].to_s).to eql("Class[Required]")
-  end
-
-  it 'appends to the require attribute on the requiring resource if it already has requirements' do
-    catalog = compile_to_catalog(<<-MANIFEST)
-
-      class required { }
-      class also_required { }
-
-      class requiring {
-        require required
-        require also_required
-      }
-      include requiring
-    MANIFEST
-
-    requiring = catalog.resource("Class", "requiring")
-    expect(requiring["require"]).to be_instance_of(Array)
-    expect(requiring["require"][0]).to be_instance_of(Puppet::Resource)
-    expect(requiring["require"][0].to_s).to eql("Class[Required]")
-    expect(requiring["require"][1]).to be_instance_of(Puppet::Resource)
-    expect(requiring["require"][1].to_s).to eql("Class[Also_required]")
-  end
-
-  it "includes the class when using a fully qualified anchored name" do
-    catalog = compile_to_catalog(<<-MANIFEST)
-      class required {
-        notify { "required": }
-      }
-      require ::required
-    MANIFEST
-
-    expect(catalog.classes).to include("required")
-  end
-
-  it_should_behave_like 'all functions transforming relative to absolute names', :require
-  it_should_behave_like 'an inclusion function, regardless of the type of class reference,', :require
-  it_should_behave_like 'an inclusion function, when --tasks is on,', :require
-end

data/spec/unit/functions/return_spec.rb

@@ -1,105 +0,0 @@
-require 'spec_helper'
-
-require 'puppet_spec/compiler'
-require 'matchers/resource'
-
-describe 'the return function' do
-  include PuppetSpec::Compiler
-  include Matchers::Resource
-
-  context 'returns from outer function when called from nested block' do
-    it 'with a given value as function result' do
-      expect(compile_to_catalog(<<-CODE)).to have_resource('Notify[100]')
-          function please_return() {
-            [1,2,3].map |$x| { if $x == 1 { return(100) } 200 }
-            300
-          }
-          notify { String(please_return()): }
-        CODE
-    end
-
-    it 'with undef value as function result when not given an argument' do
-      expect(compile_to_catalog(<<-CODE)).to have_resource('Notify[xy]')
-          function please_return() {
-            [1,2,3].map |$x| { if $x == 1 { return() } 200 }
-            300
-          }
-          notify { "x${please_return}y": }
-        CODE
-    end
-  end
-
-  it 'can be called without parentheses around the argument' do
-    expect(compile_to_catalog(<<-CODE)).to have_resource('Notify[100]')
-        function please_return() {
-          if 1 == 1 { return 100 }
-          200
-        }
-        notify { String(please_return()): }
-      CODE
-  end
-
-  it 'provides early exit from a class and keeps the class' do
-    expect(eval_and_collect_notices(<<-CODE)).to eql(['a', 'c', 'true', 'true'])
-        class notices_c { notice 'c' }
-        class does_next {
-          notice 'a'
-          if 1 == 1 { return() } # avoid making next line statically unreachable
-          notice 'b'
-        }
-        # include two classes to check that next does not do an early return from
-        # the include function.
-        include(does_next, notices_c)
-        notice defined(does_next)
-        notice defined(notices_c)
-      CODE
-  end
-
-  it 'provides early exit from a user defined resource and keeps the resource' do
-    expect(eval_and_collect_notices(<<-CODE)).to eql(['the_doer_of_next', 'copy_cat', 'true', 'true'])
-        define does_next {
-          notice $title
-          if 1 == 1 { return() } # avoid making next line statically unreachable
-          notice 'b'
-        }
-        define checker {
-          notice defined(Does_next['the_doer_of_next'])
-          notice defined(Does_next['copy_cat'])
-        }
-        # create two instances to ensure next does not break the entire
-        # resource expression
-        does_next { ['the_doer_of_next', 'copy_cat']: }
-        checker { 'needed_because_evaluation_order': }
-      CODE
-  end
-
-  it 'can be called when nested in a function to make that function return' do
-    expect(eval_and_collect_notices(<<-CODE)).to eql(['100'])
-      function nested_return() {
-        with(1) |$x| { with($x) |$x| {return(100) }}
-      }
-      notice nested_return()
-      CODE
-  end
-
-  it 'can not be called nested from top scope' do
-    expect do
-      compile_to_catalog(<<-CODE)
-        # line 1
-        # line 2
-        $result = with(1) |$x| { with($x) |$x| {return(100) }}
-        notice $result
-      CODE
-    end.to raise_error(/return\(\) from context where this is illegal \(file: unknown, line: 3\) on node.*/)
-  end
-
-  it 'can not be called from top scope' do
-    expect do
-      compile_to_catalog(<<-CODE)
-        # line 1
-        # line 2
-        return()
-      CODE
-    end.to raise_error(/return\(\) from context where this is illegal \(file: unknown, line: 3\) on node.*/)
-  end
-end

data/spec/unit/functions/reverse_each_spec.rb

@@ -1,108 +0,0 @@
-require 'puppet'
-require 'spec_helper'
-require 'puppet_spec/compiler'
-
-require 'shared_behaviours/iterative_functions'
-
-describe 'the reverse_each function' do
-  include PuppetSpec::Compiler
-
-  it 'raises an error when given a type that cannot be iterated' do
-    expect do
-      compile_to_catalog(<<-MANIFEST)
-        3.14.reverse_each |$v| {  }
-      MANIFEST
-    end.to raise_error(Puppet::Error, /expects an Iterable value, got Float/)
-  end
-
-  it 'raises an error when called with more than one argument and without a block' do
-    expect do
-      compile_to_catalog(<<-MANIFEST)
-        [1].reverse_each(1)
-      MANIFEST
-    end.to raise_error(Puppet::Error, /expects 1 argument, got 2/)
-  end
-
-  it 'raises an error when called with more than one argument and a block' do
-    expect do
-      compile_to_catalog(<<-MANIFEST)
-        [1].reverse_each(1) |$v| {  }
-      MANIFEST
-    end.to raise_error(Puppet::Error, /expects 1 argument, got 2/)
-  end
-
-  it 'raises an error when called with a block with too many required parameters' do
-    expect do
-      compile_to_catalog(<<-MANIFEST)
-        [1].reverse_each() |$v1, $v2| {  }
-      MANIFEST
-    end.to raise_error(Puppet::Error, /block expects 1 argument, got 2/)
-  end
-
-  it 'raises an error when called with a block with too few parameters' do
-    expect do
-      compile_to_catalog(<<-MANIFEST)
-        [1].reverse_each() | | {  }
-      MANIFEST
-    end.to raise_error(Puppet::Error, /block expects 1 argument, got none/)
-  end
-
-  it 'does not raise an error when called with a block with too many but optional arguments' do
-    expect do
-      compile_to_catalog(<<-MANIFEST)
-        [1].reverse_each() |$v1, $v2=extra| {  }
-      MANIFEST
-    end.to_not raise_error
-  end
-
-  it 'returns an Undef when called with a block' do
-    expect do
-      compile_to_catalog(<<-MANIFEST)
-            assert_type(Undef, [1].reverse_each |$x| { $x })
-      MANIFEST
-    end.not_to raise_error
-  end
-
-  it 'returns an Iterable when called without a block' do
-    expect do
-      compile_to_catalog(<<-MANIFEST)
-            assert_type(Iterable, [1].reverse_each)
-      MANIFEST
-    end.not_to raise_error
-  end
-
-  it 'should produce "times" interval of integer in reverse' do
-    expect(eval_and_collect_notices('5.reverse_each |$x| { notice($x) }')).to eq(['4', '3', '2', '1', '0'])
-  end
-
-  it 'should produce range Integer[5,8] in reverse' do
-    expect(eval_and_collect_notices('Integer[5,8].reverse_each |$x| { notice($x) }')).to eq(['8', '7', '6', '5'])
-  end
-
-  it 'should produce the choices of [first,second,third] in reverse' do
-    expect(eval_and_collect_notices('[first,second,third].reverse_each |$x| { notice($x) }')).to eq(%w(third second first))
-  end
-
-  it 'should produce the choices of {first => 1,second => 2,third => 3} in reverse' do
-    expect(eval_and_collect_notices('{first => 1,second => 2,third => 3}.reverse_each |$t| { notice($t[0]) }')).to eq(%w(third second first))
-  end
-
-  it 'should produce the choices of Enum[first,second,third] in reverse' do
-    expect(eval_and_collect_notices('Enum[first,second,third].reverse_each |$x| { notice($x) }')).to eq(%w(third second first))
-  end
-
-  it 'should produce nth element in reverse of range Integer[5,20] when chained after a step' do
-    expect(eval_and_collect_notices('Integer[5,20].step(4).reverse_each |$x| { notice($x) }')
-    ).to eq(['17', '13', '9', '5'])
-  end
-
-  it 'should produce nth element in reverse of times 5 when chained after a step' do
-    expect(eval_and_collect_notices('5.step(2).reverse_each |$x| { notice($x) }')).to eq(['4', '2', '0'])
-  end
-
-  it 'should produce nth element in reverse of range Integer[5,20] when chained after a step' do
-    expect(eval_and_collect_notices(
-      '[5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20].step(4).reverse_each |$x| { notice($x) }')
-    ).to eq(['17', '13', '9', '5'])
-  end
-end

data/spec/unit/functions/round_spec.rb

@@ -1,41 +0,0 @@
-require 'spec_helper'
-
-require 'puppet_spec/compiler'
-require 'matchers/resource'
-
-describe 'the round function' do
-  include PuppetSpec::Compiler
-  include Matchers::Resource
-
-  context 'for an integer' do
-    [ 0, 1, -1].each do |x|
-      it "called as round(#{x}) results in the same value" do
-        expect(compile_to_catalog("notify { String( round(#{x}) == #{x}): }")).to have_resource("Notify[true]")
-      end
-    end
-  end
-
-  context 'for a float' do
-    {
-      0.0 => 0,
-      1.1 => 1,
-      -1.1 => -1,
-      2.9 => 3,
-      2.1 => 2,
-      2.49 => 2,
-      2.50 => 3,
-      -2.9 => -3,
-    }.each_pair do |x, expected|
-      it "called as round(#{x}) results in #{expected}" do
-        expect(compile_to_catalog("notify { String( round(#{x}) == #{expected}): }")).to have_resource("Notify[true]")
-      end
-    end
-  end
-
-  [[1,2,3], {'a' => 10}, '"42"'].each do |x|
-    it "errors for a value of class #{x.class}" do
-      expect{ compile_to_catalog("round(#{x})") }.to raise_error(/expects a Numeric value/)
-    end
-  end
-
-end