puppet 4.0.0 → 4.5.0

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

@@ -0,0 +1,904 @@
+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 }
+
+  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
+        fmt = format.new("%[{d")
+      end.to raise_error(/Only one of the delimiters/)
+    end
+
+    it "Is an error to specify the same flag more than once" do
+      expect do
+        fmt = 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
+
+    it 'The %p format for string produces quoted string' do
+      string_formats = { Puppet::Pops::Types::PStringType::DEFAULT => '%p'}
+      expect(converter.convert("hello\tworld", string_formats)).to eq('"hello\\tworld"')
+    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
+
+    {
+      '   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.2c'   => '  He',
+      '%#4.2c'  => '  "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',
+      '%#6.4o'  => '  0022',
+      '%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
+        string_formats = { Puppet::Pops::Types::PIntegerType::DEFAULT => fmt}
+        expect(converter.convert(18, string_formats)).to eq(result)
+      end
+    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
+        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
+        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
+        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' => '', 
+        '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)')
+      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 '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' => ' <=> ', 
+         '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
+
+    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
+
+    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 regexp' do
+    it 'the default string representation is /regexp/' do
+      expect(converter.convert(/.*/, :default)).to eq('/.*/')
+    end
+
+    { "%s"   => '/.*/',
+      "%6s"  => '  /.*/',
+      "%.2s" => '/.',
+      "%-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
+
+    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 'rsp'/)
+    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::PType::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::PType::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
+end