puppet 8.4.0-universal-darwin → 8.5.0-universal-darwin

data/spec/unit/functions/rstrip_spec.rb

@@ -1,30 +0,0 @@
-require 'spec_helper'
-
-require 'puppet_spec/compiler'
-require 'matchers/resource'
-
-describe 'the rstrip function' do
-  include PuppetSpec::Compiler
-  include Matchers::Resource
-
-  it 'removes trailing whitepsace' do
-    expect(compile_to_catalog("notify { String(\" abc\t\n \".rstrip == ' abc'): }")).to have_resource('Notify[true]')
-  end
-
-  it 'returns the value if Numeric' do
-    expect(compile_to_catalog("notify { String(42.rstrip == 42): }")).to have_resource('Notify[true]')
-  end
-
-  it 'returns rstripped version of each entry in an array' do
-    expect(compile_to_catalog("notify { String([' a ', ' b ', ' c '].rstrip == [' a', ' b', ' c']): }")).to have_resource('Notify[true]')
-  end
-
-  it 'returns rstripped version of each entry in an Iterator' do
-    expect(compile_to_catalog("notify { String(['a ', 'b ', 'c '].reverse_each.lstrip == ['c ', 'b ', 'a ']): }")).to have_resource('Notify[true]')
-  end
-
-  it 'errors when given a a nested Array' do
-    expect { compile_to_catalog("['a', 'b', ['c']].lstrip")}.to raise_error(/'lstrip' parameter 'arg' expects a value of type Numeric, String, or Iterable/)
-  end
-
-end

data/spec/unit/functions/scanf_spec.rb

@@ -1,32 +0,0 @@
-require 'spec_helper'
-
-require 'puppet_spec/compiler'
-require 'matchers/resource'
-
-describe 'the scanf function' do
-  include PuppetSpec::Compiler
-  include Matchers::Resource
-
-  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
-
-  it 'scans a value and returns result of a code block' do
-    expect(compile_to_catalog("$x = '42'.scanf('%i')|$x|{$x[0]} + 1; notify { \"test$x\": }")).to have_resource('Notify[test43]')
-  end
-
-  it 'returns empty array if nothing was scanned' do
-    expect(compile_to_catalog("$x = 'no'.scanf('%i')[0]; notify { \"test${x}test\": }")).to have_resource('Notify[testtest]')
-  end
-
-  it 'produces result up to first unsuccessful scan' do
-    expect(compile_to_catalog("$x = '42 no'.scanf('%i'); notify { \"test${x[0]}${x[1]}test\": }")).to have_resource('Notify[test42test]')
-  end
-
-
-  it 'errors when not given enough arguments' do
-    expect do
-      compile_to_catalog("'42'.scanf()")
-    end.to raise_error(/'scanf' expects 2 arguments, got 1/)
-  end
-end

data/spec/unit/functions/shared.rb

@@ -1,94 +0,0 @@
-shared_examples_for 'all functions transforming relative to absolute names' do |func_name|
-  before(:each) do
-    # mock that the class 'myclass' exists which are needed for the 'require' functions
-    # as it checks the existence of the required class
-    @klass = double('class', :name => "myclass")
-    allow(@scope.environment.known_resource_types).to receive(:find_hostclass).and_return(@klass)
-    @resource = Puppet::Parser::Resource.new(:file, "/my/file", :scope => @scope, :source => "source")
-    allow(@scope).to receive(:resource).and_return(@resource)
-  end
-
-  it 'accepts a Class[name] type' do
-    expect(@scope.compiler).to receive(:evaluate_classes).with(["::myclass"], @scope, false)
-    @scope.call_function(func_name, [Puppet::Pops::Types::TypeFactory.host_class('myclass')])
-  end
-
-  it 'accepts a Resource[class, name] type' do
-    expect(@scope.compiler).to receive(:evaluate_classes).with(["::myclass"], @scope, false)
-    @scope.call_function(func_name, [Puppet::Pops::Types::TypeFactory.resource('class', 'myclass')])
-  end
-
-  it 'raises and error for unspecific Class' do
-    expect {
-      @scope.call_function(func_name, [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.call_function(func_name, [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.call_function(func_name, [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.call_function(func_name, [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
-
-shared_examples_for 'an inclusion function, regardless of the type of class reference,' do |function|
-    it "and #{function} a class absolutely, even when a relative namespaced class of the same name is present" do
-      catalog = compile_to_catalog(<<-MANIFEST)
-        class foo {
-          class bar { }
-          #{function} bar
-        }
-        class bar { }
-        include foo
-      MANIFEST
-      expect(catalog.classes).to include('foo','bar')
-    end
-
-    it "and #{function} a class absolutely by Class['type'] reference" do
-      catalog = compile_to_catalog(<<-MANIFEST)
-        class foo {
-          class bar { }
-          #{function} Class['bar'] 
-        }
-        class bar { }
-        include foo
-      MANIFEST
-      expect(catalog.classes).to include('foo','bar')
-    end
-
-    it "and #{function} a class absolutely by Resource['type','title'] reference" do
-      catalog = compile_to_catalog(<<-MANIFEST)
-        class foo {
-          class bar { }
-          #{function} Resource['class','bar'] 
-        }
-        class bar { }
-        include foo
-      MANIFEST
-      expect(catalog.classes).to include('foo','bar')
-    end
-end
-
-shared_examples_for 'an inclusion function, when --tasks is on,' do |function|
-  it "is not available when --tasks is on" do
-    Puppet[:tasks] = true
-    expect do
-      compile_to_catalog(<<-MANIFEST)
-        #{function}(bar)
-      MANIFEST
-    end.to raise_error(Puppet::ParseError, /is only available when compiling a catalog/)
-  end
-end

data/spec/unit/functions/size_spec.rb

@@ -1,50 +0,0 @@
-require 'spec_helper'
-
-require 'puppet_spec/compiler'
-require 'matchers/resource'
-
-describe 'the size function' do
-  include PuppetSpec::Compiler
-  include Matchers::Resource
-
-  context 'for an array it' do
-    it 'returns 0 when empty' do
-      expect(compile_to_catalog("notify { String(size([])): }")).to have_resource('Notify[0]')
-    end
-
-    it 'returns number of elements when not empty' do
-      expect(compile_to_catalog("notify { String(size([1, 2, 3])): }")).to have_resource('Notify[3]')
-    end
-  end
-
-  context 'for a hash it' do
-    it 'returns 0 empty' do
-      expect(compile_to_catalog("notify { String(size({})): }")).to have_resource('Notify[0]')
-    end
-
-    it 'returns number of elements when not empty' do
-      expect(compile_to_catalog("notify { String(size({1=>1,2=>2})): }")).to have_resource('Notify[2]')
-    end
-  end
-
-  context 'for a string it' do
-    it 'returns 0 when empty' do
-      expect(compile_to_catalog("notify { String(size('')): }")).to have_resource('Notify[0]')
-    end
-
-    it 'returns number of characters when not empty' do
-      # note the multibyte characters - åäö each taking two bytes in UTF-8
-      expect(compile_to_catalog('notify { String(size("\u00e5\u00e4\u00f6")): }')).to have_resource('Notify[3]')
-    end
-  end
-
-  context 'for a binary it' do
-    it 'returns 0 when empty' do
-      expect(compile_to_catalog("notify { String(size(Binary(''))): }")).to have_resource('Notify[0]')
-    end
-
-    it 'returns number of bytes when not empty' do
-      expect(compile_to_catalog("notify { String(size(Binary('b25l'))): }")).to have_resource('Notify[3]')
-    end
-  end
-end

data/spec/unit/functions/slice_spec.rb

@@ -1,136 +0,0 @@
-require 'puppet'
-require 'spec_helper'
-require 'puppet_spec/compiler'
-require 'matchers/resource'
-
-describe 'methods' 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 on array as" do
-
-    it 'slice with explicit parameters' do
-      catalog = compile_to_catalog(<<-MANIFEST)
-        $a = [1, present, 2, absent, 3, present]
-        $a.slice(2) |$k,$v| {
-          file { "/file_${$k}": ensure => $v }
-        }
-      MANIFEST
-
-      expect(catalog).to have_resource("File[/file_1]").with_parameter(:ensure, 'present')
-      expect(catalog).to have_resource("File[/file_2]").with_parameter(:ensure, 'absent')
-      expect(catalog).to have_resource("File[/file_3]").with_parameter(:ensure, 'present')
-    end
-
-    it 'slice with captures last' do
-      catalog = compile_to_catalog(<<-MANIFEST)
-        $a = [1, present, 2, absent, 3, present]
-        $a.slice(2) |*$kv| {
-          file { "/file_${$kv[0]}": ensure => $kv[1] }
-        }
-      MANIFEST
-
-      expect(catalog).to have_resource("File[/file_1]").with_parameter(:ensure, 'present')
-      expect(catalog).to have_resource("File[/file_2]").with_parameter(:ensure, 'absent')
-      expect(catalog).to have_resource("File[/file_3]").with_parameter(:ensure, 'present')
-    end
-
-    it 'slice with one parameter' do
-      catalog = compile_to_catalog(<<-MANIFEST)
-        $a = [1, present, 2, absent, 3, present]
-        $a.slice(2) |$k| {
-          file { "/file_${$k[0]}": ensure => $k[1] }
-        }
-      MANIFEST
-
-      expect(catalog).to have_resource("File[/file_1]").with_parameter(:ensure, 'present')
-      expect(catalog).to have_resource("File[/file_2]").with_parameter(:ensure, 'absent')
-      expect(catalog).to have_resource("File[/file_3]").with_parameter(:ensure, 'present')
-    end
-
-    it 'slice with shorter last slice' do
-      catalog = compile_to_catalog(<<-MANIFEST)
-        $a = [1, present, 2, present, 3, absent]
-        $a.slice(4) |$a, $b, $c, $d| {
-          file { "/file_$a.$c": ensure => $b }
-        }
-      MANIFEST
-
-      expect(catalog).to have_resource("File[/file_1.2]").with_parameter(:ensure, 'present')
-      expect(catalog).to have_resource("File[/file_3.]").with_parameter(:ensure, 'absent')
-    end
-  end
-
-  context "should be callable on hash as" do
-    it 'slice with explicit parameters, missing are empty' do
-      catalog = compile_to_catalog(<<-MANIFEST)
-        $a = {1=>present, 2=>present, 3=>absent}
-        $a.slice(2) |$a,$b| {
-          file { "/file_${a[0]}.${b[0]}": ensure => $a[1] }
-        }
-      MANIFEST
-
-      expect(catalog).to have_resource("File[/file_1.2]").with_parameter(:ensure, 'present')
-      expect(catalog).to have_resource("File[/file_3.]").with_parameter(:ensure, 'absent')
-    end
-  end
-
-  context "should be callable on enumerable types as" do
-    it 'slice with integer range' do
-      catalog = compile_to_catalog(<<-MANIFEST)
-        $a = Integer[1,4]
-        $a.slice(2) |$a,$b| {
-          file { "/file_${a}.${b}": ensure => present }
-        }
-      MANIFEST
-
-      expect(catalog).to have_resource("File[/file_1.2]").with_parameter(:ensure, 'present')
-      expect(catalog).to have_resource("File[/file_3.4]").with_parameter(:ensure, 'present')
-    end
-
-    it 'slice with integer' do
-      catalog = compile_to_catalog(<<-MANIFEST)
-        4.slice(2) |$a,$b| {
-          file { "/file_${a}.${b}": ensure => present }
-        }
-      MANIFEST
-
-      expect(catalog).to have_resource("File[/file_0.1]").with_parameter(:ensure, 'present')
-      expect(catalog).to have_resource("File[/file_2.3]").with_parameter(:ensure, 'present')
-    end
-
-    it 'slice with string' do
-      catalog = compile_to_catalog(<<-MANIFEST)
-        'abcd'.slice(2) |$a,$b| {
-          file { "/file_${a}.${b}": ensure => present }
-        }
-      MANIFEST
-
-      expect(catalog).to have_resource("File[/file_a.b]").with_parameter(:ensure, 'present')
-      expect(catalog).to have_resource("File[/file_c.d]").with_parameter(:ensure, 'present')
-    end
-  end
-
-  context "when called without a block" do
-    it "should produce an array with the result" do
-      catalog = compile_to_catalog(<<-MANIFEST)
-        $a = [1, present, 2, absent, 3, present]
-        $a.slice(2).each |$k| {
-          file { "/file_${$k[0]}": ensure => $k[1] }
-        }
-      MANIFEST
-
-      expect(catalog).to have_resource("File[/file_1]").with_parameter(:ensure, 'present')
-      expect(catalog).to have_resource("File[/file_2]").with_parameter(:ensure, 'absent')
-      expect(catalog).to have_resource("File[/file_3]").with_parameter(:ensure, 'present')
-    end
-  end
-end

data/spec/unit/functions/sort_spec.rb

@@ -1,79 +0,0 @@
-require 'spec_helper'
-
-require 'puppet_spec/compiler'
-require 'matchers/resource'
-
-describe 'the sort function' do
-  include PuppetSpec::Compiler
-  include Matchers::Resource
-
-    {
-      "'bac'"     => "'abc'",
-      "'BaC'"     => "'BCa'",
-    }.each_pair do |value, expected|
-      it "sorts characters in a string such that #{value}.sort results in #{expected}" do
-        expect(compile_to_catalog("notify { String( sort(#{value}) == #{expected}): }")).to have_resource("Notify[true]")
-      end
-    end
-
-  {
-     "'bac'"     => "'abc'",
-     "'BaC'"     => "'aBC'",
-   }.each_pair do |value, expected|
-     it "accepts a lambda when sorting characters in a string such that #{value} results in #{expected}" do
-       expect(compile_to_catalog("notify { String( sort(#{value}) |$a,$b| { compare($a,$b) } == #{expected}): }")).to have_resource("Notify[true]")
-     end
-   end
-
-  {
-    ['b', 'a', 'c']     => ['a', 'b', 'c'],
-    ['B', 'a', 'C']     => ['B', 'C', 'a'],
-  }.each_pair do |value, expected|
-    it "sorts strings in an array such that #{value}.sort results in #{expected}" do
-      expect(compile_to_catalog("notify { String( sort(#{value}) == #{expected}): }")).to have_resource("Notify[true]")
-    end
-  end
-
-  {
-    ['b', 'a', 'c']     => ['a', 'b', 'c'],
-    ['B', 'a', 'C']     => ['a', 'B', 'C'],
-  }.each_pair do |value, expected|
-    it "accepts a lambda when sorting an array such that #{value} results in #{expected}" do
-      expect(compile_to_catalog("notify { String( sort(#{value}) |$a,$b| { compare($a,$b) } == #{expected}): }")).to have_resource("Notify[true]")
-    end
-  end
-
-  it 'errors if given a mix of data types' do
-    expect { compile_to_catalog("sort([1, 'a'])")}.to raise_error(/comparison .* failed/)
-  end
-
-  it 'returns empty string for empty string input' do
-    expect(compile_to_catalog("notify { String(sort('') == ''): }")).to have_resource("Notify[true]")
-  end
-
-  it 'returns empty string for empty string input' do
-    expect(compile_to_catalog("notify { String(sort([]) == []): }")).to have_resource("Notify[true]")
-  end
-
-  it 'can sort mixed data types when using a lambda' do
-    # source sorts Numeric before string and uses compare() for same data type
-    src = <<-SRC
-    notify{ String(sort(['b', 3, 'a', 2]) |$a, $b| {
-        case [$a, $b] {
-          [String, Numeric] : { 1 }
-          [Numeric, String] : { -1 }
-          default:            { compare($a, $b) }
-        }
-      } == [2, 3,'a', 'b']):
-    }
-    SRC
-    expect(compile_to_catalog(src)).to have_resource("Notify[true]")
-
-  end
-
-  it 'errors if lambda does not accept 2 arguments' do
-    expect { compile_to_catalog("sort([1, 'a']) || { }")}.to raise_error(/block expects 2 arguments/)
-    expect { compile_to_catalog("sort([1, 'a']) |$x| { }")}.to raise_error(/block expects 2 arguments/)
-    expect { compile_to_catalog("sort([1, 'a']) |$x,$y, $z| { }")}.to raise_error(/block expects 2 arguments/)
-  end
-end

data/spec/unit/functions/split_spec.rb

@@ -1,59 +0,0 @@
-require 'spec_helper'
-require 'puppet/pops'
-require 'puppet/loaders'
-
-describe 'the split 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 split(*args)
-    Puppet.lookup(:loaders).puppet_system_loader.load(:function, 'split').call({}, *args)
-  end
-
-  let(:type_parser) { Puppet::Pops::Types::TypeParser.singleton }
-
-  it 'should raise an Error if there is less than 2 arguments' do
-    expect { split('a,b') }.to raise_error(/'split' expects 2 arguments, got 1/)
-  end
-
-  it 'should raise an Error if there is more than 2 arguments' do
-    expect { split('a,b','foo', 'bar') }.to raise_error(/'split' expects 2 arguments, got 3/)
-  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
-
-  it 'should handle pattern in Regexp Type form with empty regular expression' do
-    expect(split('ab',type_parser.parse('Regexp[//]'))).to eql(['a', 'b'])
-  end
-
-  it 'should handle pattern in Regexp Type form with missing regular expression' do
-    expect(split('ab',type_parser.parse('Regexp'))).to eql(['a', 'b'])
-  end
-
-  it 'should handle sensitive String' do
-    expect(split(Puppet::Pops::Types::PSensitiveType::Sensitive.new('a,b'), ',')).to be_a(Puppet::Pops::Types::PSensitiveType::Sensitive)
-    expect(split(Puppet::Pops::Types::PSensitiveType::Sensitive.new('a,b'), /,/)).to be_a(Puppet::Pops::Types::PSensitiveType::Sensitive)
-    expect(split(Puppet::Pops::Types::PSensitiveType::Sensitive.new('a,b'), type_parser.parse('Regexp[/,/]'))).to be_a(Puppet::Pops::Types::PSensitiveType::Sensitive)
-  end
-end

data/spec/unit/functions/step_spec.rb

@@ -1,113 +0,0 @@
-require 'puppet'
-require 'spec_helper'
-require 'puppet_spec/compiler'
-
-require 'shared_behaviours/iterative_functions'
-
-describe 'the step method' 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.step(1) |$v| {  }
-      MANIFEST
-    end.to raise_error(Puppet::Error, /expects an Iterable value, got Float/)
-  end
-
-  it 'raises an error when called with more than two arguments and a block' do
-    expect do
-      compile_to_catalog(<<-MANIFEST)
-        [1].step(1,2) |$v| {  }
-      MANIFEST
-    end.to raise_error(Puppet::Error, /expects 2 arguments, got 3/)
-  end
-
-  it 'raises an error when called with more than two arguments and without a block' do
-    expect do
-      compile_to_catalog(<<-MANIFEST)
-        [1].step(1,2)
-      MANIFEST
-    end.to raise_error(Puppet::Error, /expects 2 arguments, got 3/)
-  end
-
-  it 'raises an error when called with a block with too many required parameters' do
-    expect do
-      compile_to_catalog(<<-MANIFEST)
-        [1].step(1) |$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].step(1) | | {  }
-      MANIFEST
-    end.to raise_error(Puppet::Error, /block expects 1 argument, got none/)
-  end
-
-  it 'raises an error when called with step == 0' do
-    expect do
-      compile_to_catalog(<<-MANIFEST)
-        [1].step(0) |$x| {  }
-      MANIFEST
-    end.to raise_error(Puppet::Error, /'step' expects an Integer\[1\] value, got Integer\[0, 0\]/)
-  end
-
-  it 'raises an error when step is not an integer' do
-    expect do
-      compile_to_catalog(<<-MANIFEST)
-        [1].step('three') |$x| {  }
-      MANIFEST
-    end.to raise_error(Puppet::Error, /'step' expects an Integer value, got String/)
-  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].step(1) |$v1, $v2=extra| {  }
-      MANIFEST
-    end.to_not raise_error
-  end
-
-  it 'returns Undef when called with a block' do
-    expect do
-      compile_to_catalog(<<-MANIFEST)
-          assert_type(Undef, [1].step(2) |$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].step(2))
-      MANIFEST
-    end.not_to raise_error
-  end
-
-  it 'should produce "times" interval of integer according to step' do
-    expect(eval_and_collect_notices('10.step(2) |$x| { notice($x) }')).to eq(['0', '2', '4', '6', '8'])
-  end
-
-  it 'should produce interval of Integer[5,20] according to step' do
-    expect(eval_and_collect_notices('Integer[5,20].step(4) |$x| { notice($x) }')).to eq(['5', '9', '13', '17'])
-  end
-
-  it 'should produce the elements of [a,b,c,d,e,f,g,h] according to step' do
-    expect(eval_and_collect_notices('[a,b,c,d,e,f,g,h].step(2) |$x| { notice($x) }')).to eq(%w(a c e g))
-  end
-
-  it 'should produce the elements {a=>1,b=>2,c=>3,d=>4,e=>5,f=>6,g=>7,h=>8} according to step' do
-    expect(eval_and_collect_notices('{a=>1,b=>2,c=>3,d=>4,e=>5,f=>6,g=>7,h=>8}.step(2) |$t| { notice($t[1]) }')).to eq(%w(1 3 5 7))
-  end
-
-  it 'should produce the choices of Enum[a,b,c,d,e,f,g,h] according to step' do
-    expect(eval_and_collect_notices('Enum[a,b,c,d,e,f,g,h].step(2) |$x| { notice($x) }')).to eq(%w(a c e g))
-  end
-
-  it 'should produce descending interval of Integer[5,20] when chained after a reverse_each' do
-    expect(eval_and_collect_notices('Integer[5,20].reverse_each.step(4) |$x| { notice($x) }')).to eq(['20', '16', '12', '8'])
-  end
-end