puppet 7.27.0-x64-mingw32 → 7.29.0-x64-mingw32

data/spec/unit/pops/types/string_converter_spec.rb

@@ -1,1202 +0,0 @@
-require 'spec_helper'
-require 'puppet/pops'
-
-describe 'The string converter' do
-  let(:converter) { Puppet::Pops::Types::StringConverter.singleton }
-  let(:factory) { Puppet::Pops::Types::TypeFactory }
-  let(:format) { Puppet::Pops::Types::StringConverter::Format }
-  let(:binary) { Puppet::Pops::Types::PBinaryType::Binary }
-
-  describe 'helper Format' do
-    it 'parses a single character like "%d" as a format' do
-      fmt = format.new("%d")
-      expect(fmt.format()).to be(:d)
-      expect(fmt.alt()).to be(false)
-      expect(fmt.left()).to be(false)
-      expect(fmt.width()).to be_nil
-      expect(fmt.prec()).to be_nil
-      expect(fmt.plus()).to eq(:ignore)
-    end
-
-    it 'alternative form can be given with "%#d"' do
-      fmt = format.new("%#d")
-      expect(fmt.format()).to be(:d)
-      expect(fmt.alt()).to be(true)
-    end
-
-    it 'left adjust can be given with "%-d"' do
-      fmt = format.new("%-d")
-      expect(fmt.format()).to be(:d)
-      expect(fmt.left()).to be(true)
-    end
-
-    it 'plus sign can be used to indicate how positive numbers are displayed' do
-      fmt = format.new("%+d")
-      expect(fmt.format()).to be(:d)
-      expect(fmt.plus()).to eq(:plus)
-    end
-
-    it 'a space can be used to output " " instead of "+" for positive numbers' do
-      fmt = format.new("% d")
-      expect(fmt.format()).to be(:d)
-      expect(fmt.plus()).to eq(:space)
-    end
-
-    it 'padding with zero can be specified with a "0" flag' do
-      fmt = format.new("%0d")
-      expect(fmt.format()).to be(:d)
-      expect(fmt.zero_pad()).to be(true)
-    end
-
-    it 'width can be specified as an integer >= 1' do
-      fmt = format.new("%1d")
-      expect(fmt.format()).to be(:d)
-      expect(fmt.width()).to be(1)
-      fmt = format.new("%10d")
-      expect(fmt.width()).to be(10)
-    end
-
-    it 'precision can be specified as an integer >= 0' do
-      fmt = format.new("%.0d")
-      expect(fmt.format()).to be(:d)
-      expect(fmt.prec()).to be(0)
-      fmt = format.new("%.10d")
-      expect(fmt.prec()).to be(10)
-    end
-
-    it 'width and precision can both be specified' do
-      fmt = format.new("%2.3d")
-      expect(fmt.format()).to be(:d)
-      expect(fmt.width()).to be(2)
-      expect(fmt.prec()).to be(3)
-    end
-
-    [
-      '[', '{', '(', '<', '|',
-    ].each do | delim |
-      it "a container delimiter pair can be set with '#{delim}'" do
-        fmt = format.new("%#{delim}d")
-        expect(fmt.format()).to be(:d)
-        expect(fmt.delimiters()).to eql(delim)
-      end
-    end
-
-    it "Is an error to specify different delimiters at the same time" do
-      expect do
-        format.new("%[{d")
-      end.to raise_error(/Only one of the delimiters/)
-    end
-
-    it "Is an error to have trailing characters after the format" do
-      expect do
-        format.new("%dv")
-      end.to raise_error(/The format '%dv' is not a valid format/)
-    end
-
-    it "Is an error to specify the same flag more than once" do
-      expect do
-        format.new("%[[d")
-      end.to raise_error(/The same flag can only be used once/)
-    end
-  end
-
-  context 'when converting to string' do
-    {
-      42                   => "42",
-      3.14                 => "3.140000",
-      "hello world"        => "hello world",
-      "hello\tworld"       => "hello\tworld",
-    }.each do |from, to|
-      it "the string value of #{from} is '#{to}'" do
-        expect(converter.convert(from, :default)).to eq(to)
-      end
-    end
-
-    it 'float point value decimal digits can be specified' do
-      string_formats = { Puppet::Pops::Types::PFloatType::DEFAULT => '%.2f'}
-      expect(converter.convert(3.14, string_formats)).to eq('3.14')
-    end
-
-    it 'when specifying format for one type, other formats are not affected' do
-      string_formats = { Puppet::Pops::Types::PFloatType::DEFAULT => '%.2f'}
-      expect(converter.convert('3.1415', string_formats)).to eq('3.1415')
-    end
-
-    context 'The %p format for string produces' do
-      let!(:string_formats) { { Puppet::Pops::Types::PStringType::DEFAULT => '%p'} }
-      it 'double quoted result for string that contains control characters' do
-         expect(converter.convert("hello\tworld.\r\nSun is brigth today.", string_formats)).to eq('"hello\\tworld.\\r\\nSun is brigth today."')
-      end
-
-      it 'single quoted result for string that is plain ascii without \\, $ or control characters' do
-        expect(converter.convert('hello world', string_formats)).to eq("'hello world'")
-      end
-
-      it 'double quoted result when using %#p if it would otherwise be single quoted' do
-        expect(converter.convert('hello world', '%#p')).to eq('"hello world"')
-      end
-
-      it 'quoted 5-byte unicode chars' do
-        expect(converter.convert("smile \u{1f603}.", string_formats)).to eq("'smile \u{1F603}.'")
-      end
-
-      it 'quoted 2-byte unicode chars' do
-        expect(converter.convert("esc \u{1b}.", string_formats)).to eq('"esc \\u{1B}."')
-      end
-
-      it 'escape for $ in double quoted string' do
-        # Use \n in string to force double quotes
-        expect(converter.convert("escape the $ sign\n", string_formats)).to eq('"escape the \$ sign\n"')
-      end
-
-      it 'no escape for $ in single quoted string' do
-        expect(converter.convert('don\'t escape the $ sign', string_formats)).to eq("'don\\'t escape the $ sign'")
-      end
-
-      it 'escape for double quote but not for single quote in double quoted string' do
-        # Use \n in string to force double quotes
-        expect(converter.convert("the ' single and \" double quote\n", string_formats)).to eq('"the \' single and \\" double quote\n"')
-      end
-
-      it 'escape for single quote but not for double quote in single quoted string' do
-        expect(converter.convert('the \' single and " double quote', string_formats)).to eq("'the \\' single and \" double quote'")
-      end
-
-      it 'no escape for #' do
-        expect(converter.convert('do not escape #{x}', string_formats)).to eq('\'do not escape #{x}\'')
-      end
-
-      it 'escape for last \\' do
-        expect(converter.convert('escape the last \\', string_formats)).to eq("'escape the last \\'")
-      end
-    end
-
-    {
-      '%s'   => 'hello::world',
-      '%p'   => "'hello::world'",
-      '%c'   => 'Hello::world',
-      '%#c'   => "'Hello::world'",
-      '%u'   => 'HELLO::WORLD',
-      '%#u'   => "'HELLO::WORLD'",
-    }.each do |fmt, result |
-      it "the format #{fmt} produces #{result}" do
-        string_formats = { Puppet::Pops::Types::PStringType::DEFAULT => fmt}
-        expect(converter.convert('hello::world', string_formats)).to eq(result)
-      end
-    end
-
-    {
-      '%c'   => 'Hello::world',
-      '%#c'  => "'Hello::world'",
-      '%d'   => 'hello::world',
-      '%#d'  => "'hello::world'",
-    }.each do |fmt, result |
-      it "the format #{fmt} produces #{result}" do
-        string_formats = { Puppet::Pops::Types::PStringType::DEFAULT => fmt}
-        expect(converter.convert('HELLO::WORLD', string_formats)).to eq(result)
-      end
-    end
-
-    {
-      [nil, '%.1p']  => 'u',
-      [nil, '%#.2p'] => '"u',
-      [:default, '%.1p'] => 'd',
-      [true, '%.2s'] => 'tr',
-      [true, '%.2y'] => 'ye',
-    }.each do |args, result |
-      it "the format #{args[1]} produces #{result} for value #{args[0]}" do
-        expect(converter.convert(*args)).to eq(result)
-      end
-    end
-
-    {
-      '   a b  ' => 'a b',
-      'a b  '    => 'a b',
-      '   a b'   => 'a b',
-    }.each do |input, result |
-      it "the input #{input} is trimmed to #{result} by using format '%t'" do
-        string_formats = { Puppet::Pops::Types::PStringType::DEFAULT => '%t'}
-        expect(converter.convert(input, string_formats)).to eq(result)
-      end
-    end
-
-    {
-      '   a b  ' => "'a b'",
-      'a b  '    => "'a b'",
-      '   a b'   => "'a b'",
-    }.each do |input, result |
-      it "the input #{input} is trimmed to #{result} by using format '%#t'" do
-        string_formats = { Puppet::Pops::Types::PStringType::DEFAULT => '%#t'}
-        expect(converter.convert(input, string_formats)).to eq(result)
-      end
-    end
-
-    it 'errors when format is not recognized' do
-      expect do
-      string_formats = { Puppet::Pops::Types::PStringType::DEFAULT => "%k"}
-      converter.convert('wat', string_formats)
-      end.to raise_error(/Illegal format 'k' specified for value of String type - expected one of the characters 'cCudspt'/)
-    end
-
-    it 'Width pads a string left with spaces to given width' do
-      string_formats = { Puppet::Pops::Types::PStringType::DEFAULT => '%6s'}
-      expect(converter.convert("abcd", string_formats)).to eq('  abcd')
-    end
-
-    it 'Width pads a string right with spaces to given width and - flag' do
-      string_formats = { Puppet::Pops::Types::PStringType::DEFAULT => '%-6s'}
-      expect(converter.convert("abcd", string_formats)).to eq('abcd  ')
-    end
-
-    it 'Precision truncates the string if precision < length' do
-      string_formats = { Puppet::Pops::Types::PStringType::DEFAULT => '%-6.2s'}
-      expect(converter.convert("abcd", string_formats)).to eq('ab    ')
-    end
-
-    {
-      '%4.2s'   => '  he',
-      '%4.2p'   => "  'h",
-      '%4.2c'   => '  He',
-      '%#4.2c'  => "  'H",
-      '%4.2u'   => '  HE',
-      '%#4.2u'  => "  'H",
-      '%4.2d'   => '  he',
-      '%#4.2d'  => "  'h"
-    }.each do |fmt, result |
-      it "width and precision can be combined with #{fmt}" do
-        string_formats = { Puppet::Pops::Types::PStringType::DEFAULT => fmt}
-        expect(converter.convert('hello::world', string_formats)).to eq(result)
-      end
-    end
-
-  end
-
-  context 'when converting integer' do
-    it 'the default string representation is decimal' do
-      expect(converter.convert(42, :default)).to eq('42')
-    end
-
-    {
-      '%s'      => '18',
-      '%4.1s'   => '   1',
-      '%p'      => '18',
-      '%4.2p'   => '  18',
-      '%4.1p'   => '   1',
-      '%#s'     => '"18"',
-      '%#6.4s'  => '  "18"',
-      '%#p'     => '18',
-      '%#6.4p'  => '    18',
-      '%d'      => '18',
-      '%4.1d'   => '  18',
-      '%4.3d'   => ' 018',
-      '%x'      => '12',
-      '%4.3x'   => ' 012',
-      '%#x'     => '0x12',
-      '%#6.4x'  => '0x0012',
-      '%X'      => '12',
-      '%4.3X'   => ' 012',
-      '%#X'     => '0X12',
-      '%#6.4X'  => '0X0012',
-      '%o'      => '22',
-      '%4.2o'   => '  22',
-      '%#o'     => '022',
-      '%b'      => '10010',
-      '%7.6b'   => ' 010010',
-      '%#b'     => '0b10010',
-      '%#9.6b'  => ' 0b010010',
-      '%#B'     => '0B10010',
-      '%#9.6B'  => ' 0B010010',
-      # Integer to float then a float format - fully tested for float
-      '%e'      => '1.800000e+01',
-      '%E'      => '1.800000E+01',
-      '%f'      => '18.000000',
-      '%g'      => '18',
-      '%a'      => '0x1.2p+4',
-      '%A'      => '0X1.2P+4',
-      '%.1f'    => '18.0',
-    }.each do |fmt, result |
-      it "the format #{fmt} produces #{result}" do
-        pending("PUP-8612 %a and %A not support on JRuby") if RUBY_PLATFORM == 'java' && fmt =~ /^%[aA]$/
-        string_formats = { Puppet::Pops::Types::PIntegerType::DEFAULT => fmt}
-        expect(converter.convert(18, string_formats)).to eq(result)
-      end
-    end
-
-    it 'the format %#6.4o produces 0022' do
-      string_formats = { Puppet::Pops::Types::PIntegerType::DEFAULT => '%#6.4o' }
-      result = RUBY_PLATFORM == 'java' ? ' 00022' : '  0022'
-      expect(converter.convert(18, string_formats)).to eq(result)
-    end
-
-    it 'produces a unicode char string by using format %c' do
-      string_formats = { Puppet::Pops::Types::PIntegerType::DEFAULT => '%c'}
-      expect(converter.convert(0x1F603, string_formats)).to eq("\u{1F603}")
-    end
-
-    it 'produces a quoted unicode char string by using format %#c' do
-      string_formats = { Puppet::Pops::Types::PIntegerType::DEFAULT => '%#c'}
-      expect(converter.convert(0x1F603, string_formats)).to eq("\"\u{1F603}\"")
-    end
-
-    it 'errors when format is not recognized' do
-      expect do
-      string_formats = { Puppet::Pops::Types::PIntegerType::DEFAULT => "%k"}
-      converter.convert(18, string_formats)
-      end.to raise_error(/Illegal format 'k' specified for value of Integer type - expected one of the characters 'dxXobBeEfgGaAspc'/)
-    end
-  end
-
-  context 'when converting float' do
-    it 'the default string representation is decimal' do
-      expect(converter.convert(42.0, :default)).to eq('42.000000')
-    end
-
-    {
-      '%s'      => '18.0',
-      '%#s'     => '"18.0"',
-      '%5s'     => ' 18.0',
-      '%#8s'    => '  "18.0"',
-      '%05.1s'  => '    1',
-      '%p'      => '18.0',
-      '%7.2p'   => '     18',
-
-      '%e'      => '1.800000e+01',
-      '%+e'     => '+1.800000e+01',
-      '% e'     => ' 1.800000e+01',
-      '%.2e'    => '1.80e+01',
-      '%10.2e'  => '  1.80e+01',
-      '%-10.2e' => '1.80e+01  ',
-      '%010.2e' => '001.80e+01',
-
-      '%E'      => '1.800000E+01',
-      '%+E'     => '+1.800000E+01',
-      '% E'     => ' 1.800000E+01',
-      '%.2E'    => '1.80E+01',
-      '%10.2E'  => '  1.80E+01',
-      '%-10.2E' => '1.80E+01  ',
-      '%010.2E' => '001.80E+01',
-
-      '%f'      => '18.000000',
-      '%+f'     => '+18.000000',
-      '% f'     => ' 18.000000',
-      '%.2f'    => '18.00',
-      '%10.2f'  => '     18.00',
-      '%-10.2f' => '18.00     ',
-      '%010.2f' => '0000018.00',
-
-      '%g'      => '18',
-      '%5g'     => '   18',
-      '%05g'    => '00018',
-      '%-5g'    => '18   ',
-      '%5.4g'   => '   18',  # precision has no effect
-
-      '%a'      => '0x1.2p+4',
-      '%.4a'    => '0x1.2000p+4',
-      '%10a'    => '  0x1.2p+4',
-      '%010a'    => '0x001.2p+4',
-      '%-10a'   => '0x1.2p+4  ',
-      '%A'      => '0X1.2P+4',
-      '%.4A'      => '0X1.2000P+4',
-      '%10A'    => '  0X1.2P+4',
-      '%-10A'   => '0X1.2P+4  ',
-      '%010A'   => '0X001.2P+4',
-
-      # integer formats fully tested for integer
-      '%d'      => '18',
-      '%x'      => '12',
-      '%X'      => '12',
-      '%o'      => '22',
-      '%b'      => '10010',
-      '%#B'     => '0B10010',
-    }.each do |fmt, result |
-      it "the format #{fmt} produces #{result}" do
-        pending("PUP-8612 %a and %A not support on JRuby") if RUBY_PLATFORM == 'java' && fmt =~ /^%[-.014]*[aA]$/
-        string_formats = { Puppet::Pops::Types::PFloatType::DEFAULT => fmt}
-        expect(converter.convert(18.0, string_formats)).to eq(result)
-      end
-    end
-
-    it 'errors when format is not recognized' do
-      expect do
-      string_formats = { Puppet::Pops::Types::PFloatType::DEFAULT => "%k"}
-      converter.convert(18.0, string_formats)
-      end.to raise_error(/Illegal format 'k' specified for value of Float type - expected one of the characters 'dxXobBeEfgGaAsp'/)
-    end
-  end
-
-  context 'when converting undef' do
-    it 'the default string representation is empty string' do
-      expect(converter.convert(nil, :default)).to eq('')
-    end
-
-    { "%u"  => "undef",
-      "%#u" => "undefined",
-      "%s"  => "",
-      "%#s"  => '""',
-      "%p"  => 'undef',
-      "%#p"  => '"undef"',
-      "%n"  => 'nil',
-      "%#n" => 'null',
-      "%v"  => 'n/a',
-      "%V"  => 'N/A',
-      "%d"  => 'NaN',
-      "%x"  => 'NaN',
-      "%o"  => 'NaN',
-      "%b"  => 'NaN',
-      "%B"  => 'NaN',
-      "%e"  => 'NaN',
-      "%E"  => 'NaN',
-      "%f"  => 'NaN',
-      "%g"  => 'NaN',
-      "%G"  => 'NaN',
-      "%a"  => 'NaN',
-      "%A"  => 'NaN',
-    }.each do |fmt, result |
-      it "the format #{fmt} produces #{result}" do
-        string_formats = { Puppet::Pops::Types::PUndefType::DEFAULT => fmt}
-        expect(converter.convert(nil, string_formats)).to eq(result)
-      end
-    end
-
-    { "%7u"    => "  undef",
-      "%-7u"   => "undef  ",
-      "%#10u"  => " undefined",
-      "%#-10u" => "undefined ",
-      "%7.2u"  => "     un",
-      "%4s"    => "    ",
-      "%#4s"   => '  ""',
-      "%7p"    => '  undef',
-      "%7.1p"  => '      u',
-      "%#8p"   => ' "undef"',
-      "%5n"    => '  nil',
-      "%.1n"   => 'n',
-      "%-5n"   => 'nil  ',
-      "%#5n"   => ' null',
-      "%#-5n"  => 'null ',
-      "%5v"    => '  n/a',
-      "%5.2v"  => '   n/',
-      "%-5v"   => 'n/a  ',
-      "%5V"    => '  N/A',
-      "%5.1V"  => '    N',
-      "%-5V"   => 'N/A  ',
-      "%5d"    => '  NaN',
-      "%5.2d"  => '   Na',
-      "%-5d"   => 'NaN  ',
-      "%5x"    => '  NaN',
-      "%5.2x"  => '   Na',
-      "%-5x"   => 'NaN  ',
-      "%5o"    => '  NaN',
-      "%5.2o"  => '   Na',
-      "%-5o"   => 'NaN  ',
-      "%5b"    => '  NaN',
-      "%5.2b"  => '   Na',
-      "%-5b"   => 'NaN  ',
-      "%5B"    => '  NaN',
-      "%5.2B"  => '   Na',
-      "%-5B"   => 'NaN  ',
-      "%5e"    => '  NaN',
-      "%5.2e"  => '   Na',
-      "%-5e"   => 'NaN  ',
-      "%5E"    => '  NaN',
-      "%5.2E"  => '   Na',
-      "%-5E"   => 'NaN  ',
-      "%5f"    => '  NaN',
-      "%5.2f"  => '   Na',
-      "%-5f"   => 'NaN  ',
-      "%5g"    => '  NaN',
-      "%5.2g"  => '   Na',
-      "%-5g"   => 'NaN  ',
-      "%5G"    => '  NaN',
-      "%5.2G"  => '   Na',
-      "%-5G"   => 'NaN  ',
-      "%5a"    => '  NaN',
-      "%5.2a"  => '   Na',
-      "%-5a"   => 'NaN  ',
-      "%5A"    => '  NaN',
-      "%5.2A"  => '   Na',
-      "%-5A"   => 'NaN  ',
-    }.each do |fmt, result |
-      it "the format #{fmt} produces #{result}" do
-        string_formats = { Puppet::Pops::Types::PUndefType::DEFAULT => fmt}
-        expect(converter.convert(nil, string_formats)).to eq(result)
-      end
-    end
-
-    it 'errors when format is not recognized' do
-      expect do
-      string_formats = { Puppet::Pops::Types::PUndefType::DEFAULT => "%k"}
-      converter.convert(nil, string_formats)
-      end.to raise_error(/Illegal format 'k' specified for value of Undef type - expected one of the characters 'nudxXobBeEfgGaAvVsp'/)
-    end
-  end
-
-  context 'when converting default' do
-    it 'the default string representation is unquoted "default"' do
-      expect(converter.convert(:default, :default)).to eq('default')
-    end
-
-    { "%d"  => 'default',
-      "%D"  => 'Default',
-      "%#d" => '"default"',
-      "%#D" => '"Default"',
-      "%s"  => 'default',
-      "%p"  => 'default',
-    }.each do |fmt, result |
-      it "the format #{fmt} produces #{result}" do
-        string_formats = { Puppet::Pops::Types::PDefaultType::DEFAULT => fmt}
-        expect(converter.convert(:default, string_formats)).to eq(result)
-      end
-    end
-
-    it 'errors when format is not recognized' do
-      expect do
-      string_formats = { Puppet::Pops::Types::PDefaultType::DEFAULT => "%k"}
-      converter.convert(:default, string_formats)
-      end.to raise_error(/Illegal format 'k' specified for value of Default type - expected one of the characters 'dDsp'/)
-    end
-  end
-
-  context 'when converting boolean true' do
-    it 'the default string representation is unquoted "true"' do
-      expect(converter.convert(true, :default)).to eq('true')
-    end
-
-    { "%t"   => 'true',
-      "%#t"  => 't',
-      "%T"   => 'True',
-      "%#T"  => 'T',
-      "%s"   => 'true',
-      "%p"   => 'true',
-      "%d"   => '1',
-      "%x"   => '1',
-      "%#x"  => '0x1',
-      "%o"   => '1',
-      "%#o"  => '01',
-      "%b"   => '1',
-      "%#b"  => '0b1',
-      "%#B"  => '0B1',
-      "%e"   => '1.000000e+00',
-      "%f"   => '1.000000',
-      "%g"   => '1',
-      "%a"   => '0x1p+0',
-      "%A"   => '0X1P+0',
-      "%.1f" => '1.0',
-      "%y"   => 'yes',
-      "%Y"   => 'Yes',
-      "%#y"  => 'y',
-      "%#Y"  => 'Y',
-    }.each do |fmt, result |
-      it "the format #{fmt} produces #{result}" do
-        pending("PUP-8612 %a and %A not support on JRuby") if RUBY_PLATFORM == 'java' && fmt =~ /^%[aA]$/
-        string_formats = { Puppet::Pops::Types::PBooleanType::DEFAULT => fmt}
-        expect(converter.convert(true, string_formats)).to eq(result)
-      end
-    end
-
-    it 'errors when format is not recognized' do
-      expect do
-      string_formats = { Puppet::Pops::Types::PBooleanType::DEFAULT => "%k"}
-      converter.convert(true, string_formats)
-      end.to raise_error(/Illegal format 'k' specified for value of Boolean type - expected one of the characters 'tTyYdxXobBeEfgGaAsp'/)
-    end
-
-  end
-
-  context 'when converting boolean false' do
-    it 'the default string representation is unquoted "false"' do
-      expect(converter.convert(false, :default)).to eq('false')
-    end
-
-    { "%t"   => 'false',
-      "%#t"  => 'f',
-      "%T"   => 'False',
-      "%#T"  => 'F',
-      "%s"   => 'false',
-      "%p"   => 'false',
-      "%d"   => '0',
-      "%x"   => '0',
-      "%#x"  => '0',
-      "%o"   => '0',
-      "%#o"  => '0',
-      "%b"   => '0',
-      "%#b"  => '0',
-      "%#B"  => '0',
-      "%e"   => '0.000000e+00',
-      "%E"   => '0.000000E+00',
-      "%f"   => '0.000000',
-      "%g"   => '0',
-      "%a"   => '0x0p+0',
-      "%A"   => '0X0P+0',
-      "%.1f" => '0.0',
-      "%y"   => 'no',
-      "%Y"   => 'No',
-      "%#y"  => 'n',
-      "%#Y"  => 'N',
-    }.each do |fmt, result |
-      it "the format #{fmt} produces #{result}" do
-        pending("PUP-8612 %a and %A not support on JRuby") if RUBY_PLATFORM == 'java' && fmt =~ /^%[aA]$/
-        string_formats = { Puppet::Pops::Types::PBooleanType::DEFAULT => fmt}
-        expect(converter.convert(false, string_formats)).to eq(result)
-      end
-    end
-
-    it 'errors when format is not recognized' do
-      expect do
-      string_formats = { Puppet::Pops::Types::PBooleanType::DEFAULT => "%k"}
-      converter.convert(false, string_formats)
-      end.to raise_error(/Illegal format 'k' specified for value of Boolean type - expected one of the characters 'tTyYdxXobBeEfgGaAsp'/)
-    end
-  end
-
-  context 'when converting array' do
-    it 'the default string representation is using [] delimiters, joins with ',' and uses %p for values' do
-      expect(converter.convert(["hello", "world"], :default)).to eq("['hello', 'world']")
-    end
-
-    { "%s"  => "[1, 'hello']",
-      "%p"  => "[1, 'hello']",
-      "%a"  => "[1, 'hello']",
-      "%<a"  => "<1, 'hello'>",
-      "%[a"  => "[1, 'hello']",
-      "%(a"  => "(1, 'hello')",
-      "%{a"  => "{1, 'hello'}",
-      "% a"  => "1, 'hello'",
-
-      {'format' => '%(a',
-        'separator' => ' '
-      } => "(1 'hello')",
-
-      {'format' => '%(a',
-        'separator' => ''
-      } => "(1'hello')",
-
-      {'format' => '%|a',
-        'separator' => ' '
-      } => "|1 'hello'|",
-
-      {'format' => '%(a',
-        'separator' => ' ',
-        'string_formats' => {Puppet::Pops::Types::PIntegerType::DEFAULT => '%#x'}
-      } => "(0x1 'hello')",
-    }.each do |fmt, result |
-      it "the format #{fmt} produces #{result}" do
-        string_formats = { Puppet::Pops::Types::PArrayType::DEFAULT => fmt}
-        expect(converter.convert([1, "hello"], string_formats)).to eq(result)
-      end
-    end
-
-    it "multiple rules selects most specific" do
-      short_array_t = factory.array_of(factory.integer, factory.range(1,2))
-      long_array_t = factory.array_of(factory.integer, factory.range(3,100))
-      string_formats = {
-        short_array_t => "%(a",
-        long_array_t  => "%[a",
-      }
-      expect(converter.convert([1, 2], string_formats)).to eq('(1, 2)') unless RUBY_PLATFORM == 'java' # PUP-8615
-      expect(converter.convert([1, 2, 3], string_formats)).to eq('[1, 2, 3]')
-    end
-
-    it 'indents elements in alternate mode' do
-      string_formats = { Puppet::Pops::Types::PArrayType::DEFAULT => { 'format' => '%#a', 'separator' =>", " } }
-      # formatting matters here
-      result = [
-       "[1, 2, 9, 9,",
-       "  [3, 4],",
-       "  [5,",
-       "    [6, 7]],",
-       "  8, 9]"
-       ].join("\n")
-
-     formatted = converter.convert([1, 2, 9, 9, [3, 4], [5, [6, 7]], 8, 9], string_formats)
-     expect(formatted).to eq(result)
-    end
-
-    it 'applies a short form format' do
-      result = [
-        "[1,",
-        "  [2, 3],",
-        "  4]"
-        ].join("\n")
-      expect(converter.convert([1, [2,3], 4], '%#a')).to eq(result)
-    end
-
-    it 'treats hashes as nested arrays wrt indentation' do
-      string_formats = { Puppet::Pops::Types::PArrayType::DEFAULT => { 'format' => '%#a', 'separator' =>", " } }
-      # formatting matters here
-      result = [
-       "[1, 2, 9, 9,",
-       "  {3 => 4, 5 => 6},",
-       "  [5,",
-       "    [6, 7]],",
-       "  8, 9]"
-       ].join("\n")
-
-     formatted = converter.convert([1, 2, 9, 9, {3  => 4, 5 => 6}, [5, [6, 7]], 8, 9], string_formats)
-     expect(formatted).to eq(result)
-    end
-
-    it 'indents and breaks when a sequence > given width, in alternate mode' do
-      string_formats = { Puppet::Pops::Types::PArrayType::DEFAULT => { 'format' => '%#3a', 'separator' =>", " } }
-      # formatting matters here
-      result = [
-       "[ 1,",
-       "  2,",
-       "  90,", # this sequence has length 4 (1,2,90) which is > 3
-       "  [3, 4],",
-       "  [5,",
-       "    [6, 7]],",
-       "  8,",
-       "  9]",
-       ].join("\n")
-
-     formatted = converter.convert([1, 2, 90, [3, 4], [5, [6, 7]], 8, 9], string_formats)
-     expect(formatted).to eq(result)
-    end
-
-    it 'indents and breaks when a sequence (placed last) > given width, in alternate mode' do
-      string_formats = { Puppet::Pops::Types::PArrayType::DEFAULT => { 'format' => '%#3a', 'separator' =>", " } }
-      # formatting matters here
-      result = [
-       "[ 1,",
-       "  2,",
-       "  9,", # this sequence has length 3 (1,2,9) which does not cause breaking on each
-       "  [3, 4],",
-       "  [5,",
-       "    [6, 7]],",
-       "  8,",
-       "  900]", # this sequence has length 4 (8, 900) which causes breaking on each
-       ].join("\n")
-
-     formatted = converter.convert([1, 2, 9, [3, 4], [5, [6, 7]], 8, 900], string_formats)
-     expect(formatted).to eq(result)
-    end
-
-    it 'indents and breaks nested sequences when one is placed first' do
-      string_formats = { Puppet::Pops::Types::PArrayType::DEFAULT => { 'format' => '%#a', 'separator' =>", " } }
-      # formatting matters here
-      result = [
-       "[",
-       "  [",
-       "    [1, 2,",
-       "      [3, 4]]],",
-       "  [5,",
-       "    [6, 7]],",
-       "  8, 900]",
-       ].join("\n")
-
-     formatted = converter.convert([[[1, 2, [3, 4]]], [5, [6, 7]], 8, 900], string_formats)
-     expect(formatted).to eq(result)
-    end
-
-    it 'errors when format is not recognized' do
-      expect do
-      string_formats = { Puppet::Pops::Types::PArrayType::DEFAULT => "%k"}
-      converter.convert([1,2], string_formats)
-      end.to raise_error(/Illegal format 'k' specified for value of Array type - expected one of the characters 'asp'/)
-    end
-  end
-
-  context 'when converting hash' do
-    it 'the default string representation is using {} delimiters, joins with '=>' and uses %p for values' do
-      expect(converter.convert({"hello" => "world"}, :default)).to eq("{'hello' => 'world'}")
-    end
-
-    { "%s"  => "{1 => 'world'}",
-      "%p"  => "{1 => 'world'}",
-      "%h"  => "{1 => 'world'}",
-      "%a"  => "[[1, 'world']]",
-      "%<h"  => "<1 => 'world'>",
-      "%[h"  => "[1 => 'world']",
-      "%(h"  => "(1 => 'world')",
-      "%{h"  => "{1 => 'world'}",
-      "% h"  => "1 => 'world'",
-
-      {'format' => '%(h',
-        'separator2' => ' '
-      } => "(1 'world')",
-
-      {'format' => '%(h',
-        'separator2' => ' ',
-        'string_formats' => {Puppet::Pops::Types::PIntegerType::DEFAULT => '%#x'}
-      } => "(0x1 'world')",
-    }.each do |fmt, result |
-      it "the format #{fmt} produces #{result}" do
-        string_formats = { Puppet::Pops::Types::PHashType::DEFAULT => fmt}
-        expect(converter.convert({1 => "world"}, string_formats)).to eq(result)
-      end
-    end
-
-    {  "%s"  => "{1 => 'hello', 2 => 'world'}",
-
-       {'format' => '%(h',
-         'separator2' => ' '
-       } => "(1 'hello', 2 'world')",
-
-       {'format' => '%(h',
-         'separator' => '',
-         'separator2' => ''
-       } => "(1'hello'2'world')",
-
-       {'format' => '%(h',
-         'separator' => ' >> ',
-         'separator2' => ' <=> ',
-         'string_formats' => {Puppet::Pops::Types::PIntegerType::DEFAULT => '%#x'}
-       } => "(0x1 <=> 'hello' >> 0x2 <=> 'world')",
-     }.each do |fmt, result |
-       it "the format #{fmt} produces #{result}" do
-         string_formats = { Puppet::Pops::Types::PHashType::DEFAULT => fmt}
-         expect(converter.convert({1 => "hello", 2 => "world"}, string_formats)).to eq(result)
-       end
-     end
-
-    it 'indents elements in alternative mode #' do
-      string_formats = {
-        Puppet::Pops::Types::PHashType::DEFAULT => {
-          'format' => '%#h',
-        }
-      }
-      # formatting matters here
-      result = [
-       "{",
-       "  1 => 'hello',",
-       "  2 => {",
-       "    3 => 'world'",
-       "  }",
-       "}"
-       ].join("\n")
-
-      expect(converter.convert({1 => "hello", 2 => {3=> "world"}}, string_formats)).to eq(result)
-    end
-
-    it 'applies a short form format' do
-      result = [
-        "{",
-        "  1 => {",
-        "    2 => 3",
-        "  },",
-        "  4 => 5",
-        "}"].join("\n")
-      expect(converter.convert({1 => {2 => 3}, 4 => 5}, '%#h')).to eq(result)
-    end
-
-    context "containing an array" do
-      it 'the hash and array renders without breaks and indentation by default' do
-        result = "{1 => [1, 2, 3]}"
-        formatted = converter.convert({ 1 => [1, 2, 3] }, :default)
-        expect(formatted).to eq(result)
-      end
-
-      it 'the array renders with breaks if so specified' do
-        string_formats = { Puppet::Pops::Types::PArrayType::DEFAULT => { 'format' => '%#1a', 'separator' =>"," } }
-        result = [
-        "{1 => [ 1,",
-        "    2,",
-        "    3]}"
-        ].join("\n")
-        formatted = converter.convert({ 1 => [1, 2, 3] }, string_formats)
-        expect(formatted).to eq(result)
-      end
-
-      it 'both hash and array renders with breaks and indentation if so specified for both' do
-        string_formats = {
-          Puppet::Pops::Types::PArrayType::DEFAULT => { 'format' => '%#1a', 'separator' =>", " },
-          Puppet::Pops::Types::PHashType::DEFAULT => { 'format' => '%#h', 'separator' =>"," }
-        }
-        result = [
-        "{",
-        "  1 => [ 1,",
-        "    2,",
-        "    3]",
-        "}"
-        ].join("\n")
-        formatted = converter.convert({ 1 => [1, 2, 3] }, string_formats)
-        expect(formatted).to eq(result)
-      end
-
-      it 'hash, but not array is rendered with breaks and indentation if so specified only for the hash' do
-        string_formats = {
-          Puppet::Pops::Types::PArrayType::DEFAULT => { 'format' => '%a', 'separator' =>", " },
-          Puppet::Pops::Types::PHashType::DEFAULT => { 'format' => '%#h', 'separator' =>"," }
-        }
-        result = [
-        "{",
-        "  1 => [1, 2, 3]",
-        "}"
-        ].join("\n")
-        formatted = converter.convert({ 1 => [1, 2, 3] }, string_formats)
-        expect(formatted).to eq(result)
-      end
-    end
-
-    context 'that is subclassed' do
-      let(:array) { ['a', 2] }
-      let(:derived_array) do
-        Class.new(Array) do
-          def to_a
-            self # Dead wrong! Should return a plain Array copy
-          end
-        end.new(array)
-      end
-      let(:derived_with_to_a) do
-        Class.new(Array) do
-          def to_a
-            super
-          end
-        end.new(array)
-      end
-
-      let(:hash) { {'first' => 1, 'second' => 2} }
-      let(:derived_hash) do
-        Class.new(Hash)[hash]
-      end
-      let(:derived_with_to_hash) do
-        Class.new(Hash) do
-          def to_hash
-            {}.merge(self)
-          end
-        end[hash]
-      end
-
-      it 'formats a derived array as a Runtime' do
-        expect(converter.convert(array)).to eq('[\'a\', 2]')
-        expect(converter.convert(derived_array)).to eq('["a", 2]')
-      end
-
-      it 'formats a derived array with #to_a retuning plain Array as an Array' do
-        expect(converter.convert(derived_with_to_a)).to eq('[\'a\', 2]')
-      end
-
-      it 'formats a derived hash as a Runtime' do
-        expect(converter.convert(hash)).to eq('{\'first\' => 1, \'second\' => 2}')
-        expect(converter.convert(derived_hash)).to eq('{"first"=>1, "second"=>2}')
-      end
-
-      it 'formats a derived hash with #to_hash retuning plain Hash as a Hash' do
-        expect(converter.convert(derived_with_to_hash, '%p')).to eq('{\'first\' => 1, \'second\' => 2}')
-      end
-    end
-
-    it 'errors when format is not recognized' do
-      expect do
-      string_formats = { Puppet::Pops::Types::PHashType::DEFAULT => "%k"}
-      converter.convert({1 => 2}, string_formats)
-      end.to raise_error(/Illegal format 'k' specified for value of Hash type - expected one of the characters 'hasp'/)
-    end
-  end
-
-  context 'when converting a runtime type' do
-    [ :sym, (1..3), Time.now ].each do |value|
-      it "the default string representation for #{value} is #to_s" do
-        expect(converter.convert(value, :default)).to eq(value.to_s)
-      end
-
-      it "the '%q' string representation for #{value} is #inspect" do
-        expect(converter.convert(value, '%q')).to eq(value.inspect)
-      end
-
-      it "the '%p' string representation for #{value} is quoted #to_s" do
-        expect(converter.convert(value, '%p')).to eq("'#{value}'")
-      end
-    end
-
-    it 'an unknown format raises an error' do
-      expect { converter.convert(:sym, '%b') }.to raise_error("Illegal format 'b' specified for value of Runtime type - expected one of the characters 'spq'")
-    end
-  end
-
-  context 'when converting regexp' do
-    it 'the default string representation is "regexp"' do
-      expect(converter.convert(/.*/, :default)).to eq('.*')
-    end
-
-    { "%s"   => '.*',
-      "%6s"  => '    .*',
-      "%.1s" => '.',
-      "%-6s" => '.*    ',
-      "%p"   => '/.*/',
-      "%6p"  => '  /.*/',
-      "%-6p" => '/.*/  ',
-      "%.2p" => '/.',
-      "%#s"  => "'.*'",
-      "%#p"  => '/.*/'
-    }.each do |fmt, result |
-      it "the format #{fmt} produces #{result}" do
-        string_formats = { Puppet::Pops::Types::PRegexpType::DEFAULT => fmt}
-        expect(converter.convert(/.*/, string_formats)).to eq(result)
-      end
-    end
-
-    context 'that contains flags' do
-      it 'the format %s produces \'(?m-ix:[a-z]\s*)\' for expression /[a-z]\s*/m' do
-        string_formats = { Puppet::Pops::Types::PRegexpType::DEFAULT => '%s'}
-        expect(converter.convert(/[a-z]\s*/m, string_formats)).to eq('(?m-ix:[a-z]\s*)')
-      end
-
-      it 'the format %p produces \'/(?m-ix:[a-z]\s*)/\' for expression /[a-z]\s*/m' do
-        string_formats = { Puppet::Pops::Types::PRegexpType::DEFAULT => '%p'}
-        expect(converter.convert(/[a-z]\s*/m, string_formats)).to eq('/(?m-ix:[a-z]\s*)/')
-      end
-
-      it 'the format %p produces \'/foo\/bar/\' for expression /foo\/bar/' do
-        string_formats = { Puppet::Pops::Types::PRegexpType::DEFAULT => '%p'}
-        expect(converter.convert(/foo\/bar/, string_formats)).to eq('/foo\/bar/')
-      end
-
-      context 'and slashes' do
-        it 'the format %s produces \'(?m-ix:foo/bar)\' for expression /foo\/bar/m' do
-          string_formats = { Puppet::Pops::Types::PRegexpType::DEFAULT => '%s'}
-          expect(converter.convert(/foo\/bar/m, string_formats)).to eq('(?m-ix:foo/bar)')
-        end
-
-        it 'the format %s produces \'(?m-ix:foo\/bar)\' for expression /foo\\\/bar/m' do
-          string_formats = { Puppet::Pops::Types::PRegexpType::DEFAULT => '%s'}
-          expect(converter.convert(/foo\\\/bar/m, string_formats)).to eq('(?m-ix:foo\\\\/bar)')
-        end
-
-        it 'the format %p produces \'(?m-ix:foo\/bar)\' for expression /foo\/bar/m' do
-          string_formats = { Puppet::Pops::Types::PRegexpType::DEFAULT => '%p'}
-          expect(converter.convert(/foo\/bar/m, string_formats)).to eq('/(?m-ix:foo\/bar)/')
-        end
-
-        it 'the format %p produces \'(?m-ix:foo\/bar)\' for expression /(?m-ix:foo\/bar)/' do
-          string_formats = { Puppet::Pops::Types::PRegexpType::DEFAULT => '%p'}
-          expect(converter.convert(/(?m-ix:foo\/bar)/, string_formats)).to eq('/(?m-ix:foo\/bar)/')
-        end
-      end
-    end
-
-    it 'errors when format is not recognized' do
-      expect do
-      string_formats = { Puppet::Pops::Types::PRegexpType::DEFAULT => "%k"}
-      converter.convert(/.*/, string_formats)
-      end.to raise_error(/Illegal format 'k' specified for value of Regexp type - expected one of the characters 'sp'/)
-    end
-  end
-
-  context 'when converting binary' do
-    let(:sample) { binary.from_binary_string('binary') }
-
-    it 'the binary is converted to strict base64 string unquoted by default (same as %B)' do
-      expect(converter.convert(sample, :default)).to eq("YmluYXJ5")
-    end
-
-    it 'the binary is converted using %p by default when contained in an array' do
-      expect(converter.convert([sample], :default)).to eq("[Binary(\"YmluYXJ5\")]")
-    end
-
-    it '%B formats in base64 strict mode (same as default)' do
-      string_formats = { Puppet::Pops::Types::PBinaryType::DEFAULT => '%B'}
-      expect(converter.convert(sample, string_formats)).to eq("YmluYXJ5")
-    end
-
-    it '%b formats in base64 relaxed mode, and adds newline' do
-      string_formats = { Puppet::Pops::Types::PBinaryType::DEFAULT => '%b'}
-      expect(converter.convert(sample, string_formats)).to eq("YmluYXJ5\n")
-    end
-
-    it '%u formats in base64 urlsafe mode' do
-      string_formats = { Puppet::Pops::Types::PBinaryType::DEFAULT => '%u'}
-      expect(converter.convert(binary.from_base64("++//"), string_formats)).to eq("--__")
-    end
-
-    it '%p formats with type name' do
-      string_formats = { Puppet::Pops::Types::PBinaryType::DEFAULT => '%p'}
-      expect(converter.convert(sample, string_formats)).to eq("Binary(\"YmluYXJ5\")")
-    end
-
-    it '%#s formats as quoted string with escaped non printable bytes' do
-      string_formats = { Puppet::Pops::Types::PBinaryType::DEFAULT => '%#s'}
-      expect(converter.convert(binary.from_base64("apa="), string_formats)).to eq("\"j\\x96\"")
-    end
-
-    it '%s formats as unquoted string with valid UTF-8 chars' do
-      string_formats = { Puppet::Pops::Types::PBinaryType::DEFAULT => '%s'}
-      # womans hat emoji is E318, a three byte UTF-8 char EE 8C 98
-      expect(converter.convert(binary.from_binary_string("\xEE\x8C\x98"), string_formats)).to eq("\uE318")
-    end
-
-    it '%s errors if given non UTF-8 bytes' do
-      string_formats = { Puppet::Pops::Types::PBinaryType::DEFAULT => '%s'}
-      expect {
-        converter.convert(binary.from_base64("apa="), string_formats)
-      }.to raise_error(Encoding::UndefinedConversionError)
-    end
-
-    { "%s"    => 'binary',
-      "%#s"   => '"binary"',
-      "%8s"   => '  binary',
-      "%.2s"  => 'bi',
-      "%-8s"  => 'binary  ',
-      "%p"    => 'Binary("YmluYXJ5")',
-      "%10p"  => 'Binary("  YmluYXJ5")',
-      "%-10p" => 'Binary("YmluYXJ5  ")',
-      "%.2p"  => 'Binary("Ym")',
-      "%b"    => "YmluYXJ5\n",
-      "%11b"  => "  YmluYXJ5\n",
-      "%-11b" => "YmluYXJ5\n  ",
-      "%.2b"  => "Ym",
-      "%B"    => "YmluYXJ5",
-      "%11B"  => "   YmluYXJ5",
-      "%-11B" => "YmluYXJ5   ",
-      "%.2B"  => "Ym",
-      "%u"    => "YmluYXJ5",
-      "%11u"  => "   YmluYXJ5",
-      "%-11u" => "YmluYXJ5   ",
-      "%.2u"  => "Ym",
-      "%t"    => 'Binary',
-      "%#t"   => '"Binary"',
-      "%8t"   => '  Binary',
-      "%-8t"  => 'Binary  ',
-      "%.3t"  => 'Bin',
-      "%T"    => 'BINARY',
-      "%#T"   => '"BINARY"',
-      "%8T"   => '  BINARY',
-      "%-8T"  => 'BINARY  ',
-      "%.3T"  => 'BIN',
-    }.each do |fmt, result |
-      it "the format #{fmt} produces #{result}" do
-        string_formats = { Puppet::Pops::Types::PBinaryType::DEFAULT => fmt}
-        expect(converter.convert(sample, string_formats)).to eq(result)
-      end
-    end
-  end
-
-  context 'when converting iterator' do
-    it 'the iterator is transformed to an array and formatted using array rules' do
-      itor = Puppet::Pops::Types::Iterator.new(Puppet::Pops::Types::PIntegerType::DEFAULT, [1,2,3]).reverse_each
-      expect(converter.convert(itor, :default)).to eq('[3, 2, 1]')
-    end
-  end
-
-  context 'when converting type' do
-    it 'the default string representation of a type is its programmatic string form' do
-      expect(converter.convert(factory.integer, :default)).to eq('Integer')
-    end
-
-    { "%s"  => 'Integer',
-      "%p"  => 'Integer',
-      "%#s" => '"Integer"',
-      "%#p" => 'Integer',
-    }.each do |fmt, result |
-      it "the format #{fmt} produces #{result}" do
-        string_formats = { Puppet::Pops::Types::PTypeType::DEFAULT => fmt}
-        expect(converter.convert(factory.integer, string_formats)).to eq(result)
-      end
-    end
-
-    it 'errors when format is not recognized' do
-      expect do
-        string_formats = { Puppet::Pops::Types::PTypeType::DEFAULT => "%k"}
-        converter.convert(factory.integer, string_formats)
-      end.to raise_error(/Illegal format 'k' specified for value of Type type - expected one of the characters 'sp'/)
-    end
-  end
-
-  it "allows format to be directly given (instead of as a type=> format hash)" do
-    expect(converter.convert('hello', '%5.1s')).to eq('    h')
-  end
-
-  it 'an explicit format for a type will override more specific defaults' do
-    expect(converter.convert({ 'x' => 'X' }, { Puppet::Pops::Types::PCollectionType::DEFAULT => '%#p' })).to eq("{\n  'x' => 'X'\n}")
-  end
-end