puppet 7.32.1-x64-mingw32 → 8.0.1-x64-mingw32

data/spec/unit/functions/next_spec.rb

@@ -0,0 +1,93 @@
+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

@@ -0,0 +1,40 @@
+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

@@ -0,0 +1,85 @@
+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

@@ -0,0 +1,114 @@
+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

@@ -0,0 +1,82 @@
+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

@@ -0,0 +1,109 @@
+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
+      # strict mode is off so behavior this test is trying to check isn't stubbed out
+      Puppet[:strict_variables] = false
+      Puppet[:strict] = :warning
+
+      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

@@ -0,0 +1,108 @@
+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

@@ -0,0 +1,41 @@
+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