puppet 4.4.2-universal-darwin → 4.5.0-universal-darwin

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

@@ -1,307 +1,322 @@
 require 'spec_helper'
 require 'puppet/pops'
 
+module Puppet::Pops
+module Types
 describe 'The type factory' do
   context 'when creating' do
     it 'integer() returns PIntegerType' do
-      expect(Puppet::Pops::Types::TypeFactory.integer().class()).to eq(Puppet::Pops::Types::PIntegerType)
+      expect(TypeFactory.integer().class()).to eq(PIntegerType)
     end
 
     it 'float() returns PFloatType' do
-      expect(Puppet::Pops::Types::TypeFactory.float().class()).to eq(Puppet::Pops::Types::PFloatType)
+      expect(TypeFactory.float().class()).to eq(PFloatType)
     end
 
     it 'string() returns PStringType' do
-      expect(Puppet::Pops::Types::TypeFactory.string().class()).to eq(Puppet::Pops::Types::PStringType)
+      expect(TypeFactory.string().class()).to eq(PStringType)
     end
 
     it 'boolean() returns PBooleanType' do
-      expect(Puppet::Pops::Types::TypeFactory.boolean().class()).to eq(Puppet::Pops::Types::PBooleanType)
+      expect(TypeFactory.boolean().class()).to eq(PBooleanType)
     end
 
     it 'pattern() returns PPatternType' do
-      expect(Puppet::Pops::Types::TypeFactory.pattern().class()).to eq(Puppet::Pops::Types::PPatternType)
+      expect(TypeFactory.pattern().class()).to eq(PPatternType)
     end
 
     it 'regexp() returns PRegexpType' do
-      expect(Puppet::Pops::Types::TypeFactory.regexp().class()).to eq(Puppet::Pops::Types::PRegexpType)
+      expect(TypeFactory.regexp().class()).to eq(PRegexpType)
     end
 
     it 'enum() returns PEnumType' do
-      expect(Puppet::Pops::Types::TypeFactory.enum().class()).to eq(Puppet::Pops::Types::PEnumType)
+      expect(TypeFactory.enum().class()).to eq(PEnumType)
     end
 
     it 'variant() returns PVariantType' do
-      expect(Puppet::Pops::Types::TypeFactory.variant().class()).to eq(Puppet::Pops::Types::PVariantType)
+      expect(TypeFactory.variant().class()).to eq(PVariantType)
     end
 
     it 'scalar() returns PScalarType' do
-      expect(Puppet::Pops::Types::TypeFactory.scalar().class()).to eq(Puppet::Pops::Types::PScalarType)
+      expect(TypeFactory.scalar().class()).to eq(PScalarType)
     end
 
     it 'data() returns PDataType' do
-      expect(Puppet::Pops::Types::TypeFactory.data().class()).to eq(Puppet::Pops::Types::PDataType)
+      expect(TypeFactory.data().class()).to eq(PDataType)
     end
 
     it 'optional() returns POptionalType' do
-      expect(Puppet::Pops::Types::TypeFactory.optional().class()).to eq(Puppet::Pops::Types::POptionalType)
+      expect(TypeFactory.optional().class()).to eq(POptionalType)
     end
 
     it 'collection() returns PCollectionType' do
-      expect(Puppet::Pops::Types::TypeFactory.collection().class()).to eq(Puppet::Pops::Types::PCollectionType)
+      expect(TypeFactory.collection().class()).to eq(PCollectionType)
     end
 
     it 'catalog_entry() returns PCatalogEntryType' do
-      expect(Puppet::Pops::Types::TypeFactory.catalog_entry().class()).to eq(Puppet::Pops::Types::PCatalogEntryType)
+      expect(TypeFactory.catalog_entry().class()).to eq(PCatalogEntryType)
     end
 
     it 'struct() returns PStructType' do
-      expect(Puppet::Pops::Types::TypeFactory.struct().class()).to eq(Puppet::Pops::Types::PStructType)
+      expect(TypeFactory.struct().class()).to eq(PStructType)
+    end
+
+    it "object() returns PObjectType" do
+      expect(TypeFactory.object.class).to eq(PObjectType)
     end
 
     it 'tuple() returns PTupleType' do
-      expect(Puppet::Pops::Types::TypeFactory.tuple.class()).to eq(Puppet::Pops::Types::PTupleType)
+      expect(TypeFactory.tuple.class()).to eq(PTupleType)
     end
 
     it 'undef() returns PUndefType' do
-      expect(Puppet::Pops::Types::TypeFactory.undef().class()).to eq(Puppet::Pops::Types::PUndefType)
+      expect(TypeFactory.undef().class()).to eq(PUndefType)
+    end
+
+    it 'type_alias() returns PTypeAliasType' do
+      expect(TypeFactory.type_alias().class()).to eq(PTypeAliasType)
+    end
+
+    it 'sem_ver() returns PSemVerType' do
+      expect(TypeFactory.sem_ver.class).to eq(PSemVerType)
+    end
+
+    it 'sem_ver(r1, r2) returns constrained PSemVerType' do
+      expect(TypeFactory.sem_ver('1.x', '3.x').ranges).to include(Semantic::VersionRange.parse('1.x'), Semantic::VersionRange.parse('3.x'))
+    end
+
+    it 'sem_ver_range() returns PSemVerRangeType' do
+      expect(TypeFactory.sem_ver_range.class).to eq(PSemVerRangeType)
     end
 
     it 'default() returns PDefaultType' do
-      expect(Puppet::Pops::Types::TypeFactory.default().class()).to eq(Puppet::Pops::Types::PDefaultType)
+      expect(TypeFactory.default().class()).to eq(PDefaultType)
     end
 
     it 'range(to, from) returns PIntegerType' do
-      t = Puppet::Pops::Types::TypeFactory.range(1,2)
-      expect(t.class()).to eq(Puppet::Pops::Types::PIntegerType)
+      t = TypeFactory.range(1,2)
+      expect(t.class()).to eq(PIntegerType)
       expect(t.from).to eq(1)
       expect(t.to).to eq(2)
     end
 
     it 'range(default, default) returns PIntegerType' do
-      t = Puppet::Pops::Types::TypeFactory.range(:default,:default)
-      expect(t.class()).to eq(Puppet::Pops::Types::PIntegerType)
+      t = TypeFactory.range(:default,:default)
+      expect(t.class()).to eq(PIntegerType)
       expect(t.from).to eq(nil)
       expect(t.to).to eq(nil)
     end
 
     it 'float_range(to, from) returns PFloatType' do
-      t = Puppet::Pops::Types::TypeFactory.float_range(1.0, 2.0)
-      expect(t.class()).to eq(Puppet::Pops::Types::PFloatType)
+      t = TypeFactory.float_range(1.0, 2.0)
+      expect(t.class()).to eq(PFloatType)
       expect(t.from).to eq(1.0)
       expect(t.to).to eq(2.0)
     end
 
     it 'float_range(default, default) returns PFloatType' do
-      t = Puppet::Pops::Types::TypeFactory.float_range(:default, :default)
-      expect(t.class()).to eq(Puppet::Pops::Types::PFloatType)
+      t = TypeFactory.float_range(:default, :default)
+      expect(t.class()).to eq(PFloatType)
       expect(t.from).to eq(nil)
       expect(t.to).to eq(nil)
     end
 
     it 'resource() creates a generic PResourceType' do
-      pr = Puppet::Pops::Types::TypeFactory.resource()
-      expect(pr.class()).to eq(Puppet::Pops::Types::PResourceType)
+      pr = TypeFactory.resource()
+      expect(pr.class()).to eq(PResourceType)
       expect(pr.type_name).to eq(nil)
     end
 
     it 'resource(x) creates a PResourceType[x]' do
-      pr = Puppet::Pops::Types::TypeFactory.resource('x')
-      expect(pr.class()).to eq(Puppet::Pops::Types::PResourceType)
-      expect(pr.type_name).to eq('x')
+      pr = TypeFactory.resource('x')
+      expect(pr.class()).to eq(PResourceType)
+      expect(pr.type_name).to eq('X')
     end
 
     it 'host_class() creates a generic PHostClassType' do
-      hc = Puppet::Pops::Types::TypeFactory.host_class()
-      expect(hc.class()).to eq(Puppet::Pops::Types::PHostClassType)
+      hc = TypeFactory.host_class()
+      expect(hc.class()).to eq(PHostClassType)
       expect(hc.class_name).to eq(nil)
     end
 
     it 'host_class(x) creates a PHostClassType[x]' do
-      hc = Puppet::Pops::Types::TypeFactory.host_class('x')
-      expect(hc.class()).to eq(Puppet::Pops::Types::PHostClassType)
+      hc = TypeFactory.host_class('x')
+      expect(hc.class()).to eq(PHostClassType)
       expect(hc.class_name).to eq('x')
     end
 
     it 'host_class(::x) creates a PHostClassType[x]' do
-      hc = Puppet::Pops::Types::TypeFactory.host_class('::x')
-      expect(hc.class()).to eq(Puppet::Pops::Types::PHostClassType)
+      hc = TypeFactory.host_class('::x')
+      expect(hc.class()).to eq(PHostClassType)
       expect(hc.class_name).to eq('x')
     end
 
     it 'array_of(fixnum) returns PArrayType[PIntegerType]' do
-      at = Puppet::Pops::Types::TypeFactory.array_of(1)
-      expect(at.class()).to eq(Puppet::Pops::Types::PArrayType)
-      expect(at.element_type.class).to eq(Puppet::Pops::Types::PIntegerType)
+      at = TypeFactory.array_of(1)
+      expect(at.class()).to eq(PArrayType)
+      expect(at.element_type.class).to eq(PIntegerType)
     end
 
     it 'array_of(PIntegerType) returns PArrayType[PIntegerType]' do
-      at = Puppet::Pops::Types::TypeFactory.array_of(Puppet::Pops::Types::PIntegerType::DEFAULT)
-      expect(at.class()).to eq(Puppet::Pops::Types::PArrayType)
-      expect(at.element_type.class).to eq(Puppet::Pops::Types::PIntegerType)
+      at = TypeFactory.array_of(PIntegerType::DEFAULT)
+      expect(at.class()).to eq(PArrayType)
+      expect(at.element_type.class).to eq(PIntegerType)
     end
 
     it 'array_of_data returns PArrayType[PDataType]' do
-      at = Puppet::Pops::Types::TypeFactory.array_of_data
-      expect(at.class()).to eq(Puppet::Pops::Types::PArrayType)
-      expect(at.element_type.class).to eq(Puppet::Pops::Types::PDataType)
+      at = TypeFactory.array_of_data
+      expect(at.class()).to eq(PArrayType)
+      expect(at.element_type.class).to eq(PDataType)
     end
 
     it 'hash_of_data returns PHashType[PScalarType,PDataType]' do
-      ht = Puppet::Pops::Types::TypeFactory.hash_of_data
-      expect(ht.class()).to eq(Puppet::Pops::Types::PHashType)
-      expect(ht.key_type.class).to eq(Puppet::Pops::Types::PScalarType)
-      expect(ht.element_type.class).to eq(Puppet::Pops::Types::PDataType)
+      ht = TypeFactory.hash_of_data
+      expect(ht.class()).to eq(PHashType)
+      expect(ht.key_type.class).to eq(PScalarType)
+      expect(ht.element_type.class).to eq(PDataType)
     end
 
     it 'ruby(1) returns PRuntimeType[ruby, \'Fixnum\']' do
-      ht = Puppet::Pops::Types::TypeFactory.ruby(1)
-      expect(ht.class()).to eq(Puppet::Pops::Types::PRuntimeType)
+      ht = TypeFactory.ruby(1)
+      expect(ht.class()).to eq(PRuntimeType)
       expect(ht.runtime).to eq(:ruby)
       expect(ht.runtime_type_name).to eq('Fixnum')
     end
 
     it 'a size constrained collection can be created from array' do
-      t = Puppet::Pops::Types::TypeFactory.array_of(Puppet::Pops::Types::TypeFactory.data, Puppet::Pops::Types::TypeFactory.range(1,2))
-      expect(t.size_type.class).to eq(Puppet::Pops::Types::PIntegerType)
+      t = TypeFactory.array_of(TypeFactory.data, TypeFactory.range(1,2))
+      expect(t.size_type.class).to eq(PIntegerType)
       expect(t.size_type.from).to eq(1)
       expect(t.size_type.to).to eq(2)
     end
 
     it 'a size constrained collection can be created from hash' do
-      t = Puppet::Pops::Types::TypeFactory.hash_of(Puppet::Pops::Types::TypeFactory.scalar, Puppet::Pops::Types::TypeFactory.data, Puppet::Pops::Types::TypeFactory.range(1,2))
-      expect(t.size_type.class).to eq(Puppet::Pops::Types::PIntegerType)
+      t = TypeFactory.hash_of(TypeFactory.scalar, TypeFactory.data, TypeFactory.range(1,2))
+      expect(t.size_type.class).to eq(PIntegerType)
       expect(t.size_type.from).to eq(1)
       expect(t.size_type.to).to eq(2)
     end
 
-    it 'it is illegal to create a typed empty array' do
-      expect {
-        Puppet::Pops::Types::TypeFactory.array_of(Puppet::Pops::Types::TypeFactory.data, Puppet::Pops::Types::TypeFactory.range(0,0))
-      }.to raise_error(/An empty collection may not specify an element type/)
-    end
-
-    it 'it is legal to create an empty array of unit element type' do
-      t = Puppet::Pops::Types::TypeFactory.array_of(Puppet::Pops::Types::PUnitType::DEFAULT, Puppet::Pops::Types::TypeFactory.range(0,0))
+    it 'a typed empty array, the resulting array erases the type' do
+      t = Puppet::Pops::Types::TypeFactory.array_of(Puppet::Pops::Types::TypeFactory.data, Puppet::Pops::Types::TypeFactory.range(0,0))
       expect(t.size_type.class).to eq(Puppet::Pops::Types::PIntegerType)
       expect(t.size_type.from).to eq(0)
       expect(t.size_type.to).to eq(0)
+      expect(t.element_type).to eq(Puppet::Pops::Types::PUnitType::DEFAULT)
     end
 
-    it 'it is illegal to create a typed empty hash' do
-      expect {
-        Puppet::Pops::Types::TypeFactory.hash_of(Puppet::Pops::Types::TypeFactory.scalar, Puppet::Pops::Types::TypeFactory.data, Puppet::Pops::Types::TypeFactory.range(0,0))
-      }.to raise_error(/An empty collection may not specify an element type/)
-    end
-
-    it 'it is legal to create an empty hash where key and value types are of Unit type' do
-      t = Puppet::Pops::Types::TypeFactory.hash_of(Puppet::Pops::Types::PUnitType::DEFAULT, Puppet::Pops::Types::PUnitType::DEFAULT, Puppet::Pops::Types::TypeFactory.range(0,0))
+    it 'a typed empty hash, the resulting hash erases the key and value type' do
+      t = Puppet::Pops::Types::TypeFactory.hash_of(Puppet::Pops::Types::TypeFactory.scalar, Puppet::Pops::Types::TypeFactory.data, Puppet::Pops::Types::TypeFactory.range(0,0))
       expect(t.size_type.class).to eq(Puppet::Pops::Types::PIntegerType)
       expect(t.size_type.from).to eq(0)
       expect(t.size_type.to).to eq(0)
+      expect(t.key_type).to eq(Puppet::Pops::Types::PUnitType::DEFAULT)
+      expect(t.element_type).to eq(Puppet::Pops::Types::PUnitType::DEFAULT)
     end
 
     context 'callable types' do
       it 'the callable methods produces a Callable' do
-        t = Puppet::Pops::Types::TypeFactory.callable()
-        expect(t.class).to be(Puppet::Pops::Types::PCallableType)
-        expect(t.param_types.class).to be(Puppet::Pops::Types::PTupleType)
+        t = TypeFactory.callable()
+        expect(t.class).to be(PCallableType)
+        expect(t.param_types.class).to be(PTupleType)
         expect(t.param_types.types).to be_empty
         expect(t.block_type).to be_nil
       end
 
       it 'callable method with types produces the corresponding Tuple for parameters and generated names' do
-        tf = Puppet::Pops::Types::TypeFactory
+        tf = TypeFactory
         t = tf.callable(tf.integer, tf.string)
-        expect(t.class).to be(Puppet::Pops::Types::PCallableType)
-        expect(t.param_types.class).to be(Puppet::Pops::Types::PTupleType)
+        expect(t.class).to be(PCallableType)
+        expect(t.param_types.class).to be(PTupleType)
         expect(t.param_types.types).to eql([tf.integer, tf.string])
         expect(t.block_type).to be_nil
       end
 
       it 'callable accepts min range to be given' do
-        tf = Puppet::Pops::Types::TypeFactory
+        tf = TypeFactory
         t = tf.callable(tf.integer, tf.string, 1)
-        expect(t.class).to be(Puppet::Pops::Types::PCallableType)
-        expect(t.param_types.class).to be(Puppet::Pops::Types::PTupleType)
+        expect(t.class).to be(PCallableType)
+        expect(t.param_types.class).to be(PTupleType)
         expect(t.param_types.size_type.from).to eql(1)
         expect(t.param_types.size_type.to).to be_nil
       end
 
       it 'callable accepts max range to be given' do
-        tf = Puppet::Pops::Types::TypeFactory
+        tf = TypeFactory
         t = tf.callable(tf.integer, tf.string, 1, 3)
-        expect(t.class).to be(Puppet::Pops::Types::PCallableType)
-        expect(t.param_types.class).to be(Puppet::Pops::Types::PTupleType)
+        expect(t.class).to be(PCallableType)
+        expect(t.param_types.class).to be(PTupleType)
         expect(t.param_types.size_type.from).to eql(1)
         expect(t.param_types.size_type.to).to eql(3)
       end
 
       it 'callable accepts max range to be given as :default' do
-        tf = Puppet::Pops::Types::TypeFactory
+        tf = TypeFactory
         t = tf.callable(tf.integer, tf.string, 1, :default)
-        expect(t.class).to be(Puppet::Pops::Types::PCallableType)
-        expect(t.param_types.class).to be(Puppet::Pops::Types::PTupleType)
+        expect(t.class).to be(PCallableType)
+        expect(t.param_types.class).to be(PTupleType)
         expect(t.param_types.size_type.from).to eql(1)
         expect(t.param_types.size_type.to).to be_nil
       end
 
       it 'the all_callables method produces a Callable matching any Callable' do
-        t = Puppet::Pops::Types::TypeFactory.all_callables()
-        expect(t.class).to be(Puppet::Pops::Types::PCallableType)
+        t = TypeFactory.all_callables()
+        expect(t.class).to be(PCallableType)
         expect(t.param_types).to be_nil
         expect(t.block_type).to be_nil
       end
 
       it 'with block are created by placing a Callable last' do
-        block_t = Puppet::Pops::Types::TypeFactory.callable(String)
-        t = Puppet::Pops::Types::TypeFactory.callable(String, block_t)
+        block_t = TypeFactory.callable(String)
+        t = TypeFactory.callable(String, block_t)
         expect(t.block_type).to be(block_t)
       end
 
       it 'min size constraint can be used with a block last' do
-        block_t = Puppet::Pops::Types::TypeFactory.callable(String)
-        t = Puppet::Pops::Types::TypeFactory.callable(String, 1, block_t)
+        block_t = TypeFactory.callable(String)
+        t = TypeFactory.callable(String, 1, block_t)
         expect(t.block_type).to be(block_t)
         expect(t.param_types.size_type.from).to eql(1)
         expect(t.param_types.size_type.to).to be_nil
       end
 
       it 'min, max size constraint can be used with a block last' do
-        block_t = Puppet::Pops::Types::TypeFactory.callable(String)
-        t = Puppet::Pops::Types::TypeFactory.callable(String, 1, 3, block_t)
+        block_t = TypeFactory.callable(String)
+        t = TypeFactory.callable(String, 1, 3, block_t)
         expect(t.block_type).to be(block_t)
         expect(t.param_types.size_type.from).to eql(1)
         expect(t.param_types.size_type.to).to eql(3)
       end
 
       it 'the with_block methods decorates a Callable with a block_type' do
-        t = Puppet::Pops::Types::TypeFactory.callable
-        t2 = Puppet::Pops::Types::TypeFactory.callable(t)
+        t = TypeFactory.callable
+        t2 = TypeFactory.callable(t)
         block_t = t2.block_type
         # given t is returned after mutation
         expect(block_t).to be(t)
-        expect(block_t.class).to be(Puppet::Pops::Types::PCallableType)
-        expect(block_t.param_types.class).to be(Puppet::Pops::Types::PTupleType)
+        expect(block_t.class).to be(PCallableType)
+        expect(block_t.param_types.class).to be(PTupleType)
         expect(block_t.param_types.types).to be_empty
         expect(block_t.block_type).to be_nil
       end
 
       it 'the with_optional_block methods decorates a Callable with an optional block_type' do
-        b = Puppet::Pops::Types::TypeFactory.callable
-        t = Puppet::Pops::Types::TypeFactory.optional(b)
-        t2 = Puppet::Pops::Types::TypeFactory.callable(t)
+        b = TypeFactory.callable
+        t = TypeFactory.optional(b)
+        t2 = TypeFactory.callable(t)
         opt_t = t2.block_type
-        expect(opt_t.class).to be(Puppet::Pops::Types::POptionalType)
+        expect(opt_t.class).to be(POptionalType)
         block_t = opt_t.optional_type
         # given t is returned after mutation
         expect(opt_t).to be(t)
         expect(block_t).to be(b)
-        expect(block_t.class).to be(Puppet::Pops::Types::PCallableType)
-        expect(block_t.param_types.class).to be(Puppet::Pops::Types::PTupleType)
+        expect(block_t.class).to be(PCallableType)
+        expect(block_t.param_types.class).to be(PTupleType)
         expect(block_t.param_types.types).to be_empty
         expect(block_t.block_type).to be_nil
       end
     end
   end
 end
+end
+end

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

@@ -6,6 +6,68 @@ describe 'The type formatter' do
   let(:s) { TypeFormatter.new }
   let(:f) { TypeFactory }
 
+  def drop_indent(str)
+    ld = str.index("\n")
+    if ld.nil?
+      str
+    else
+      str.gsub(Regexp.compile("^ {#{ld - 1}}"), '')
+    end
+  end
+
+  context 'when representing a literal as a string' do
+    {
+      'true' => true,
+      'false' => false,
+      '?' => nil,
+      '23.4' => 23.4,
+      '145' => 145,
+      "'string'" => 'string',
+      '/expr/' => /expr/,
+      '[1, 2, 3]' => [1, 2, 3],
+      "{'a' => 32, 'b' => [1, 2, 3]}" => {'a' => 32,'b' => [1, 2, 3]}
+    }.each_pair do |str, value|
+      it "should yield '#{str}' for a value of #{str}" do
+        expect(s.string(value)).to eq(str)
+      end
+    end
+  end
+
+  context 'when using indent' do
+    it 'should put hash entries on new indented lines' do
+      expect(s.indented_string({'a' => 32,'b' => [1, 2, {'c' => 'd'}]})).to eq(<<-FORMATTED)
+{
+  'a' => 32,
+  'b' => [1, 2, {
+    'c' => 'd'
+  }]
+}
+FORMATTED
+    end
+
+    it 'should start on given indent level' do
+      expect(s.indented_string({'a' => 32,'b' => [1, 2, {'c' => 'd'}]}, 3)).to eq(<<-FORMATTED)
+      {
+        'a' => 32,
+        'b' => [1, 2, {
+          'c' => 'd'
+        }]
+      }
+FORMATTED
+    end
+
+    it 'should use given indent width' do
+      expect(s.indented_string({'a' => 32,'b' => [1, 2, {'c' => 'd'}]}, 2, 4)).to eq(<<-FORMATTED)
+        {
+            'a' => 32,
+            'b' => [1, 2, {
+                'c' => 'd'
+            }]
+        }
+    FORMATTED
+  end
+end
+
   context 'when representing the type as string' do
     include_context 'types_setup'
 
@@ -252,12 +314,12 @@ describe 'The type formatter' do
 
     it "should yield the name of an unparameterized type reference" do
       t = f.type_reference('What')
-      expect(s.string(t)).to eq('What')
+      expect(s.string(t)).to eq("TypeReference['What']")
     end
 
     it "should yield the name and arguments of an parameterized type reference" do
-      t = f.type_reference('What', [f.undef, f.string])
-      expect(s.string(t)).to eq('What[Undef, String]')
+      t = f.type_reference('What[Undef, String]')
+      expect(s.string(t)).to eq("TypeReference['What[Undef, String]']")
     end
 
     it "should yield the name of a type alias" do
@@ -266,19 +328,24 @@ describe 'The type formatter' do
     end
 
     it "should yield 'Type[Runtime[ruby, Puppet]]' for the Puppet module" do
-      expect(s.string(Puppet)).to eq('Runtime[ruby, "Puppet"]')
+      expect(s.string(Puppet)).to eq("Runtime[ruby, 'Puppet']")
     end
 
     it "should yield 'Type[Runtime[ruby, Puppet::Pops]]' for the Puppet::Resource class" do
-      expect(s.string(Puppet::Resource)).to eq('Runtime[ruby, "Puppet::Resource"]')
+      expect(s.string(Puppet::Resource)).to eq("Runtime[ruby, 'Puppet::Resource']")
+    end
+
+    it "should yield \"SemVer['1.x', '3.x']\" for the PSemVerType['1.x', '3.x']" do
+      expect(s.string(PSemVerType.new('1.x', '3.x'))).to eq("SemVer['1.x', '3.x']")
     end
 
     it 'should present a valid simple name' do
-      (all_types - [PType]).each do |t|
+      (all_types - [PType, PHostClassType]).each do |t|
         name = t::DEFAULT.simple_name
         expect(t.name).to match("^Puppet::Pops::Types::P#{name}Type$")
       end
       expect(PType::DEFAULT.simple_name).to eql('Type')
+      expect(PHostClassType::DEFAULT.simple_name).to eql('Class')
     end
   end
 end