puppet 5.0.0 → 6.0.0

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

@@ -15,54 +15,265 @@ describe 'Puppet Ruby Generator' do
   let!(:parser) { TypeParser.singleton }
   let(:generator) { RubyGenerator.new }
 
+  context 'when generating classes for Objects having attribute names that are Ruby reserved words' do
+    let (:source) { <<-PUPPET }
+      type MyObject = Object[{
+        attributes => {
+          alias => String,
+          begin => String,
+          break => String,
+          def => String,
+          do => String,
+          end => String,
+          ensure => String,
+          for => String,
+          module => String,
+          next => String,
+          nil => String,
+          not => String,
+          redo => String,
+          rescue => String,
+          retry => String,
+          return => String,
+          self => String,
+          super => String,
+          then => String,
+          until => String,
+          when => String,
+          while => String,
+          yield => String,
+        },
+      }]
+      $x = MyObject({
+        alias => 'value of alias',
+        begin => 'value of begin',
+        break => 'value of break',
+        def => 'value of def',
+        do => 'value of do',
+        end => 'value of end',
+        ensure => 'value of ensure',
+        for => 'value of for',
+        module => 'value of module',
+        next => 'value of next',
+        nil => 'value of nil',
+        not => 'value of not',
+        redo => 'value of redo',
+        rescue => 'value of rescue',
+        retry => 'value of retry',
+        return => 'value of return',
+        self => 'value of self',
+        super => 'value of super',
+        then => 'value of then',
+        until => 'value of until',
+        when => 'value of when',
+        while => 'value of while',
+        yield => 'value of yield',
+      })
+      notice($x.alias)
+      notice($x.begin)
+      notice($x.break)
+      notice($x.def)
+      notice($x.do)
+      notice($x.end)
+      notice($x.ensure)
+      notice($x.for)
+      notice($x.module)
+      notice($x.next)
+      notice($x.nil)
+      notice($x.not)
+      notice($x.redo)
+      notice($x.rescue)
+      notice($x.retry)
+      notice($x.return)
+      notice($x.self)
+      notice($x.super)
+      notice($x.then)
+      notice($x.until)
+      notice($x.when)
+      notice($x.while)
+      notice($x.yield)
+    PUPPET
+
+    it 'can create an instance and access all attributes' do
+      expect(eval_and_collect_notices(source)).to eql([
+        'value of alias',
+        'value of begin',
+        'value of break',
+        'value of def',
+        'value of do',
+        'value of end',
+        'value of ensure',
+        'value of for',
+        'value of module',
+        'value of next',
+        'value of nil',
+        'value of not',
+        'value of redo',
+        'value of rescue',
+        'value of retry',
+        'value of return',
+        'value of self',
+        'value of super',
+        'value of then',
+        'value of until',
+        'value of when',
+        'value of while',
+        'value of yield',
+      ])
+    end
+  end
+
+  context 'when generating classes for Objects having function names that are Ruby reserved words' do
+    let (:source) { <<-PUPPET }
+      type MyObject = Object[{
+        functions => {
+          alias  => { type => Callable[[0,0],String], annotations => {RubyMethod => { 'body' => "'value of alias'" }}},
+          begin  => { type => Callable[[0,0],String], annotations => {RubyMethod => { 'body' => "'value of begin'" }}},
+          break  => { type => Callable[[0,0],String], annotations => {RubyMethod => { 'body' => "'value of break'" }}},
+          def    => { type => Callable[[0,0],String], annotations => {RubyMethod => { 'body' => "'value of def'" }}},
+          do     => { type => Callable[[0,0],String], annotations => {RubyMethod => { 'body' => "'value of do'" }}},
+          end    => { type => Callable[[0,0],String], annotations => {RubyMethod => { 'body' => "'value of end'" }}},
+          ensure => { type => Callable[[0,0],String], annotations => {RubyMethod => { 'body' => "'value of ensure'" }}},
+          for    => { type => Callable[[0,0],String], annotations => {RubyMethod => { 'body' => "'value of for'" }}},
+          module => { type => Callable[[0,0],String], annotations => {RubyMethod => { 'body' => "'value of module'" }}},
+          next   => { type => Callable[[0,0],String], annotations => {RubyMethod => { 'body' => "'value of next'" }}},
+          nil    => { type => Callable[[0,0],String], annotations => {RubyMethod => { 'body' => "'value of nil'" }}},
+          not    => { type => Callable[[0,0],String], annotations => {RubyMethod => { 'body' => "'value of not'" }}},
+          redo   => { type => Callable[[0,0],String], annotations => {RubyMethod => { 'body' => "'value of redo'" }}},
+          rescue => { type => Callable[[0,0],String], annotations => {RubyMethod => { 'body' => "'value of rescue'" }}},
+          retry  => { type => Callable[[0,0],String], annotations => {RubyMethod => { 'body' => "'value of retry'" }}},
+          return => { type => Callable[[0,0],String], annotations => {RubyMethod => { 'body' => "'value of return'" }}},
+          self   => { type => Callable[[0,0],String], annotations => {RubyMethod => { 'body' => "'value of self'" }}},
+          super  => { type => Callable[[0,0],String], annotations => {RubyMethod => { 'body' => "'value of super'" }}},
+          then   => { type => Callable[[0,0],String], annotations => {RubyMethod => { 'body' => "'value of then'" }}},
+          until  => { type => Callable[[0,0],String], annotations => {RubyMethod => { 'body' => "'value of until'" }}},
+          when   => { type => Callable[[0,0],String], annotations => {RubyMethod => { 'body' => "'value of when'" }}},
+          while  => { type => Callable[[0,0],String], annotations => {RubyMethod => { 'body' => "'value of while'" }}},
+          yield  => { type => Callable[[0,0],String], annotations => {RubyMethod => { 'body' => "'value of yield'" }}},
+        },
+      }]
+      $x = MyObject()
+      notice($x.alias)
+      notice($x.begin)
+      notice($x.break)
+      notice($x.def)
+      notice($x.do)
+      notice($x.end)
+      notice($x.ensure)
+      notice($x.for)
+      notice($x.module)
+      notice($x.next)
+      notice($x.nil)
+      notice($x.not)
+      notice($x.redo)
+      notice($x.rescue)
+      notice($x.retry)
+      notice($x.return)
+      notice($x.self)
+      notice($x.super)
+      notice($x.then)
+      notice($x.until)
+      notice($x.when)
+      notice($x.while)
+      notice($x.yield)
+    PUPPET
+
+    it 'can create an instance and call all functions' do
+      expect(eval_and_collect_notices(source)).to eql([
+        'value of alias',
+        'value of begin',
+        'value of break',
+        'value of def',
+        'value of do',
+        'value of end',
+        'value of ensure',
+        'value of for',
+        'value of module',
+        'value of next',
+        'value of nil',
+        'value of not',
+        'value of redo',
+        'value of rescue',
+        'value of retry',
+        'value of return',
+        'value of self',
+        'value of super',
+        'value of then',
+        'value of until',
+        'value of when',
+        'value of while',
+        'value of yield',
+      ])
+    end
+  end
+
   context 'when generating from Object types' do
-    def source
-      <<-CODE
-        type MyModule::FirstGenerated = Object[{
-          attributes => {
-            name => String,
-            age  => { type => Integer, value => 30 },
-            what => { type => String, value => 'what is this', kind => constant },
-            uc_name => {
-              type => String,
-              kind => derived,
-              annotations => {
-                RubyMethod => { body => '@name.upcase' }
+    let (:type_decls) { <<-CODE.unindent }
+      type MyModule::FirstGenerated = Object[{
+        attributes => {
+          name => String,
+          age  => { type => Integer, value => 30 },
+          what => { type => String, value => 'what is this', kind => constant },
+          uc_name => {
+            type => String,
+            kind => derived,
+            annotations => {
+              RubyMethod => { body => '@name.upcase' }
+            }
+          },
+          other_name => {
+            type => String,
+            kind => derived
+          },
+        },
+        functions => {
+          some_other => {
+            type => Callable[1,1]
+          },
+          name_and_age => {
+            type => Callable[1,1],
+            annotations => {
+              RubyMethod => {
+                parameters => 'joiner',
+                body => '"\#{@name}\#{joiner}\#{@age}"'
               }
-            },
-            other_name => {
-              type => String,
-              kind => derived
             }
           },
-          functions => {
-            some_other => {
-              type => Callable[1,1]
-            },
-            name_and_age => {
-              type => Callable[1,1],
-              annotations => {
-                RubyMethod => {
-                  parameters => 'joiner',
-                  body => '"\#{@name}\#{joiner}\#{@age}"'
-                }
+          '[]' => {
+            type => Callable[1,1],
+            annotations => {
+              RubyMethod => {
+                parameters => 'key',
+                body => @(EOF)
+                  case key
+                  when 'name'
+                    name
+                  when 'age'
+                    age
+                  else
+                    nil
+                  end
+                |-EOF
               }
-            },
-          }
-        }]
-        type MyModule::SecondGenerated = Object[{
-          parent => MyModule::FirstGenerated,
-          attributes => {
-            address => String,
-            zipcode => String,
-            email => String,
-            another => { type => Optional[MyModule::FirstGenerated], value => undef },
-            number => Integer,
-            aref => { type => Optional[MyModule::FirstGenerated], value => undef, kind => reference }
+            }
           }
-        }]
+        }
+      }]
+      type MyModule::SecondGenerated = Object[{
+        parent => MyModule::FirstGenerated,
+        attributes => {
+          address => String,
+          zipcode => String,
+          email => String,
+          another => { type => Optional[MyModule::FirstGenerated], value => undef },
+          number => Integer,
+          aref => { type => Optional[MyModule::FirstGenerated], value => undef, kind => reference }
+        }
+      }]
       CODE
-    end
+
+    let(:type_usage) { '' }
+    let(:source) { type_decls + type_usage }
 
     context 'when generating anonymous classes' do
 
@@ -72,15 +283,14 @@ describe 'Puppet Ruby Generator' do
       let(:second_type) { parser.parse('MyModule::SecondGenerated', loader) }
       let(:first) { generator.create_class(first_type) }
       let(:second) { generator.create_class(second_type) }
+      let(:notices) { [] }
 
       before(:each) do
-        eval_and_collect_notices(source) do |topscope|
+        notices.concat(eval_and_collect_notices(source) do |topscope|
           loader = topscope.compiler.loaders.find_loader(nil)
-        end
+        end)
       end
 
-      after(:each) { typeset = nil }
-
       context 'the generated class' do
         it 'inherits the PuppetObject module' do
           expect(first < PuppetObject).to be_truthy
@@ -104,6 +314,12 @@ describe 'Puppet Ruby Generator' do
           expect(inst.age).to eq(52)
         end
 
+        it 'created instance has a [] method' do
+          inst = first.create('Bob Builder', 52)
+          expect(inst['name']).to eq('Bob Builder')
+          expect(inst['age']).to eq(52)
+        end
+
         it 'will perform type assertion of the arguments' do
           expect { first.create('Bob Builder', '52') }.to(
             raise_error(TypeAssertionError,
@@ -187,6 +403,18 @@ describe 'Puppet Ruby Generator' do
           expect(results).to eq([inst])
         end
       end
+
+      context 'when used from Puppet' do
+        let(:type_usage) { <<-PUPPET.unindent }
+          $i = MyModule::FirstGenerated('Bob Builder', 52)
+          notice($i['name'])
+          notice($i['age'])
+        PUPPET
+
+        it 'The [] method is present on a created instance' do
+          expect(notices).to eql(['Bob Builder', '52'])
+        end
+      end
     end
 
     context 'when generating static code' do
@@ -202,10 +430,9 @@ describe 'Puppet Ruby Generator' do
             first_type = parser.parse('MyModule::FirstGenerated')
             second_type = parser.parse('MyModule::SecondGenerated')
 
-            loader = Loaders.find_loader(nil)
             Loaders.implementation_registry.register_type_mapping(
               PRuntimeType.new(:ruby, [/^PuppetSpec::RubyGenerator::(\w+)$/, 'MyModule::\1']),
-              [/^MyModule::(\w+)$/, 'PuppetSpec::RubyGenerator::\1'], loader)
+              [/^MyModule::(\w+)$/, 'PuppetSpec::RubyGenerator::\1'])
 
             module_def = generator.module_definition([first_type, second_type], 'Generated stuff')
           end
@@ -379,28 +606,15 @@ describe 'Puppet Ruby Generator' do
 
       context 'the typeset' do
         it 'produces expected string representation' do
-          typeset.to_s == "TypeSet[{"+
-            "pcore_version => '1.0.0', "+
-            "name_authority => 'http://puppet.com/2016.1/runtime', "+
-            "name => 'OtherModule', "+
-            "version => '1.0.0', "+
-            "types => {"+
-            "MyFloat => Float, "+
-            "ThirdGenerated => Object[{"+
-            "attributes => {"+
-            "'first' => MyModule::FirstGenerated}}], "+
-            "FourthGenerated => Object[{"+
-            "parent => MyModule::SecondGenerated, "+
-            "attributes => {"+
-            "'complex' => {"+
-            "type => Optional[ThirdGenerated], "+
-            "value => ?}, "+
-            "'n1' => MyModule::MyInteger, "+
-            "'n2' => MyFloat}}]}, "+
-            "references => [{"+
-            "'name' => 'MyModule', "+
-            "'alias' => 'My', "+
-            "'version_range' => '1.x'}]}]"
+          expect(typeset.to_s).to eq(
+            "TypeSet[{pcore_version => '1.0.0', name_authority => 'http://puppet.com/2016.1/runtime', name => 'OtherModule', version => '1.0.0', types => {"+
+              "MyFloat => Float, "+
+              "ThirdGenerated => Object[{attributes => {'first' => My::FirstGenerated}}], "+
+              "FourthGenerated => Object[{parent => My::SecondGenerated, attributes => {"+
+                "'complex' => {type => Optional[ThirdGenerated], value => undef}, "+
+                "'n1' => My::MyInteger, "+
+                "'n2' => MyFloat"+
+              "}}]}, references => {My => {'name' => 'MyModule', 'version_range' => '1.x'}}}]")
         end
       end
 
@@ -523,19 +737,17 @@ describe 'Puppet Ruby Generator' do
         # Ideally, this would be in a before(:all) but that is impossible since lots of Puppet
         # environment specific settings are configured by the spec_helper in before(:each)
         if module_def.nil?
-          typeset = nil
           eval_and_collect_notices(source) do
             typeset1 = parser.parse('MyModule')
             typeset2 = parser.parse('OtherModule')
 
-            loader = Loaders.find_loader(nil)
             Loaders.implementation_registry.register_type_mapping(
               PRuntimeType.new(:ruby, [/^PuppetSpec::RubyGenerator::My::(\w+)$/, 'MyModule::\1']),
-              [/^MyModule::(\w+)$/, 'PuppetSpec::RubyGenerator::My::\1'], loader)
+              [/^MyModule::(\w+)$/, 'PuppetSpec::RubyGenerator::My::\1'])
 
             Loaders.implementation_registry.register_type_mapping(
               PRuntimeType.new(:ruby, [/^PuppetSpec::RubyGenerator::Other::(\w+)$/, 'OtherModule::\1']),
-              [/^OtherModule::(\w+)$/, 'PuppetSpec::RubyGenerator::Other::\1'], loader)
+              [/^OtherModule::(\w+)$/, 'PuppetSpec::RubyGenerator::Other::\1'])
 
             module_def = generator.module_definition_from_typeset(typeset1)
             module_def2 = generator.module_definition_from_typeset(typeset2)

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

@@ -83,13 +83,19 @@ describe 'The string converter' do
 
     it "Is an error to specify different delimiters at the same time" do
       expect do
-        fmt = format.new("%[{d")
+        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
-        fmt = format.new("%[[d")
+        format.new("%[[d")
       end.to raise_error(/The same flag can only be used once/)
     end
   end
@@ -290,7 +296,6 @@ describe 'The string converter' do
       '%o'      => '22',
       '%4.2o'   => '  22',
       '%#o'     => '022',
-      '%#6.4o'  => '  0022',
       '%b'      => '10010',
       '%7.6b'   => ' 010010',
       '%#b'     => '0b10010',
@@ -307,11 +312,18 @@ describe 'The string converter' do
       '%.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}")
@@ -394,6 +406,7 @@ describe 'The string converter' do
       '%#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
@@ -570,6 +583,7 @@ describe 'The string converter' do
       "%#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
@@ -616,6 +630,7 @@ describe 'The string converter' do
       "%#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
@@ -644,15 +659,19 @@ describe 'The string converter' do
       "% a"  => "1, 'hello'",
 
       {'format' => '%(a',
-        'separator' => ''
+        'separator' => ' '
       } => "(1 'hello')",
 
-      {'format' => '%|a',
+      {'format' => '%(a',
         'separator' => ''
+      } => "(1'hello')",
+
+      {'format' => '%|a',
+        'separator' => ' '
       } => "|1 'hello'|",
 
       {'format' => '%(a',
-        'separator' => '',
+        'separator' => ' ',
         'string_formats' => {Puppet::Pops::Types::PIntegerType::DEFAULT => '%#x'}
       } => "(0x1 'hello')",
     }.each do |fmt, result |
@@ -669,12 +688,12 @@ describe 'The string converter' do
         short_array_t => "%(a",
         long_array_t  => "%[a",
       }
-      expect(converter.convert([1, 2], string_formats)).to eq('(1, 2)')
+      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' =>"," } }
+      string_formats = { Puppet::Pops::Types::PArrayType::DEFAULT => { 'format' => '%#a', 'separator' =>", " } }
       # formatting matters here
       result = [
        "[1, 2, 9, 9,",
@@ -689,7 +708,7 @@ describe 'The string converter' do
     end
 
     it 'treats hashes as nested arrays wrt indentation' do
-      string_formats = { Puppet::Pops::Types::PArrayType::DEFAULT => { 'format' => '%#a', 'separator' =>"," } }
+      string_formats = { Puppet::Pops::Types::PArrayType::DEFAULT => { 'format' => '%#a', 'separator' =>", " } }
       # formatting matters here
       result = [
        "[1, 2, 9, 9,",
@@ -704,7 +723,7 @@ describe 'The string converter' do
     end
 
     it 'indents and breaks when a sequence > given width, in alternate mode' do
-      string_formats = { Puppet::Pops::Types::PArrayType::DEFAULT => { 'format' => '%#3a', 'separator' =>"," } }
+      string_formats = { Puppet::Pops::Types::PArrayType::DEFAULT => { 'format' => '%#3a', 'separator' =>", " } }
       # formatting matters here
       result = [
        "[ 1,",
@@ -722,7 +741,7 @@ describe 'The string converter' do
     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' =>"," } }
+      string_formats = { Puppet::Pops::Types::PArrayType::DEFAULT => { 'format' => '%#3a', 'separator' =>", " } }
       # formatting matters here
       result = [
        "[ 1,",
@@ -740,7 +759,7 @@ describe 'The string converter' do
     end
 
     it 'indents and breaks nested sequences when one is placed first' do
-      string_formats = { Puppet::Pops::Types::PArrayType::DEFAULT => { 'format' => '%#a', 'separator' =>"," } }
+      string_formats = { Puppet::Pops::Types::PArrayType::DEFAULT => { 'format' => '%#a', 'separator' =>", " } }
       # formatting matters here
       result = [
        "[",
@@ -801,7 +820,12 @@ describe 'The string converter' do
        } => "(1 'hello', 2 'world')",
 
        {'format' => '%(h',
-         'separator' => ' >>',
+         'separator' => '',
+         'separator2' => ''
+       } => "(1'hello'2'world')",
+
+       {'format' => '%(h',
+         'separator' => ' >> ',
          'separator2' => ' <=> ',
          'string_formats' => {Puppet::Pops::Types::PIntegerType::DEFAULT => '%#x'}
        } => "(0x1 <=> 'hello' >> 0x2 <=> 'world')",
@@ -851,7 +875,7 @@ describe 'The string converter' do
 
       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::PArrayType::DEFAULT => { 'format' => '%#1a', 'separator' =>", " },
           Puppet::Pops::Types::PHashType::DEFAULT => { 'format' => '%#h', 'separator' =>"," }
         }
         result = [
@@ -867,7 +891,7 @@ describe 'The string converter' do
 
       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::PArrayType::DEFAULT => { 'format' => '%a', 'separator' =>", " },
           Puppet::Pops::Types::PHashType::DEFAULT => { 'format' => '%#h', 'separator' =>"," }
         }
         result = [
@@ -993,6 +1017,28 @@ describe 'The string converter' 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
@@ -1109,14 +1155,14 @@ describe 'The string converter' do
       "%#p" => 'Integer',
     }.each do |fmt, result |
       it "the format #{fmt} produces #{result}" do
-        string_formats = { Puppet::Pops::Types::PType::DEFAULT => fmt}
+        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::PType::DEFAULT => "%k"}
+        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