puppet 3.7.5-x64-mingw32 → 3.8.1-x64-mingw32

data/spec/unit/pops/parser/lexer2_spec.rb

@@ -234,6 +234,19 @@ describe 'Lexer2' do
     '"a${y::_x}"' => [[:DQPRE,    'a',   {:line => 1, :pos=>1, :length=>4 }],
                       [:VARIABLE, 'y::_x',  {:line => 1, :pos=>5, :length=>5 }],
                       [:DQPOST,   '',    {:line => 1, :pos=>11, :length=>1 }]],
+
+    '"a${_x[1]}"' => [[:DQPRE,    'a',   {:line => 1, :pos=>1, :length=>4 }],
+                      [:VARIABLE, '_x',  {:line => 1, :pos=>5, :length=>2 }],
+                      [:LBRACK,   '[',   {:line => 1, :pos=>7, :length=>1 }],
+                      [:NUMBER,   '1',   {:line => 1, :pos=>8, :length=>1 }],
+                      [:RBRACK,   ']',   {:line => 1, :pos=>9, :length=>1 }],
+                      [:DQPOST,   '',    {:line => 1, :pos=>11, :length=>1 }]],
+
+    '"a${_x.foo}"'=> [[:DQPRE,    'a',   {:line => 1, :pos=>1, :length=>4 }],
+                      [:VARIABLE, '_x',  {:line => 1, :pos=>5, :length=>2 }],
+                      [:DOT,      '.',   {:line => 1, :pos=>7, :length=>1 }],
+                      [:NAME,     'foo', {:line => 1, :pos=>8, :length=>3 }],
+                      [:DQPOST,   '',    {:line => 1, :pos=>12, :length=>1 }]],
   }.each do |source, expected|
     it "should lex an interpolated variable 'x' from #{source}" do
       tokens_scanned_from(source).should match_tokens2(*expected)
@@ -361,6 +374,63 @@ describe 'Lexer2' do
         [:DQPOST, " After"]
         )
     end
+
+    context 'with bad syntax' do
+      def expect_issue(code, issue)
+        expect { tokens_scanned_from(code) }.to raise_error(Puppet::ParseErrorWithIssue) { |e|
+          expect(e.issue_code).to be(issue.issue_code)
+        }
+      end
+
+      it 'detects and reports HEREDOC_UNCLOSED_PARENTHESIS' do
+        code = <<-CODE
+        @(END:syntax/t
+        Text
+        |- END
+        CODE
+        expect_issue(code, Puppet::Pops::Issues::HEREDOC_UNCLOSED_PARENTHESIS)
+      end
+
+      it 'detects and reports HEREDOC_WITHOUT_END_TAGGED_LINE' do
+        code = <<-CODE
+        @(END:syntax/t)
+        Text
+        CODE
+        expect_issue(code, Puppet::Pops::Issues::HEREDOC_WITHOUT_END_TAGGED_LINE)
+      end
+
+      it 'detects and reports HEREDOC_INVALID_ESCAPE' do
+        code = <<-CODE
+        @(END:syntax/x)
+        Text
+        |- END
+        CODE
+        expect_issue(code, Puppet::Pops::Issues::HEREDOC_INVALID_ESCAPE)
+      end
+
+      it 'detects and reports HEREDOC_INVALID_SYNTAX' do
+        code = <<-CODE
+        @(END:syntax/t/p)
+        Text
+        |- END
+        CODE
+        expect_issue(code, Puppet::Pops::Issues::HEREDOC_INVALID_SYNTAX)
+      end
+
+      it 'detects and reports HEREDOC_WITHOUT_TEXT' do
+        code = '@(END:syntax/t)'
+        expect_issue(code, Puppet::Pops::Issues::HEREDOC_WITHOUT_TEXT)
+      end
+
+      it 'detects and reports HEREDOC_MULTIPLE_AT_ESCAPES' do
+        code = <<-CODE
+        @(END:syntax/tst)
+        Tex\\tt\\n
+        |- END
+        CODE
+        expect_issue(code, Puppet::Pops::Issues::HEREDOC_MULTIPLE_AT_ESCAPES)
+      end
+    end
   end
 
   context 'when dealing with multi byte characters' do
@@ -376,6 +446,18 @@ describe 'Lexer2' do
         tokens_scanned_from(code).should match_tokens2([:STRING, "x\u2713y"])
       end
     end
+    it 'should support unicode characters in long form' do
+      code = <<-CODE
+      "x\\u{1f452}y"
+      CODE
+      if Puppet::Pops::Parser::Locator::RUBYVER < Puppet::Pops::Parser::Locator::RUBY_1_9_3
+        # Ruby 1.8.7 reports the multibyte char as several octal characters
+        tokens_scanned_from(code).should match_tokens2([:STRING, "x\360\237\221\222y"])
+      else
+        # >= Ruby 1.9.3 reports \u
+        tokens_scanned_from(code).should match_tokens2([:STRING, "x\u{1f452}y"])
+      end
+    end
 
     it 'should not select LISTSTART token when preceded by multibyte chars' do
       # This test is sensitive to the number of multibyte characters and position of the expressions
@@ -487,6 +569,75 @@ describe 'Lexer2' do
       [:RENDER_STRING, "<% this is escaped epp %>\n"]
       )
     end
+
+    context 'with bad epp syntax' do
+      def expect_issue(code, issue)
+        expect { epp_tokens_scanned_from(code) }.to raise_error(Puppet::ParseErrorWithIssue) { |e|
+          expect(e.issue_code).to be(issue.issue_code)
+        }
+      end
+
+      it 'detects and reports EPP_UNBALANCED_TAG' do
+        expect_issue('<% asf', Puppet::Pops::Issues::EPP_UNBALANCED_TAG)
+      end
+
+      it 'detects and reports EPP_UNBALANCED_COMMENT' do
+        expect_issue('<%# asf', Puppet::Pops::Issues::EPP_UNBALANCED_COMMENT)
+      end
+
+      it 'detects and reports EPP_UNBALANCED_EXPRESSION' do
+        expect_issue('asf <%', Puppet::Pops::Issues::EPP_UNBALANCED_EXPRESSION)
+      end
+    end
   end
-end
 
+  context 'when parsing bad code' do
+    def expect_issue(code, issue)
+      expect { tokens_scanned_from(code) }.to raise_error(Puppet::ParseErrorWithIssue) do |e|
+        expect(e.issue_code).to be(issue.issue_code)
+      end
+    end
+
+    it 'detects and reports issue ILLEGAL_CLASS_REFERENCE' do
+      expect_issue('A::3', Puppet::Pops::Issues::ILLEGAL_CLASS_REFERENCE)
+    end
+
+    it 'detects and reports issue ILLEGAL_FULLY_QUALIFIED_CLASS_REFERENCE' do
+      expect_issue('::A::3', Puppet::Pops::Issues::ILLEGAL_FULLY_QUALIFIED_CLASS_REFERENCE)
+    end
+
+    it 'detects and reports issue ILLEGAL_FULLY_QUALIFIED_NAME' do
+      expect_issue('::a::3', Puppet::Pops::Issues::ILLEGAL_FULLY_QUALIFIED_NAME)
+    end
+
+    it 'detects and reports issue ILLEGAL_NAME_OR_BARE_WORD' do
+      expect_issue('a::3', Puppet::Pops::Issues::ILLEGAL_NAME_OR_BARE_WORD)
+    end
+
+    it 'detects and reports issue ILLEGAL_NUMBER' do
+     expect_issue('3g', Puppet::Pops::Issues::ILLEGAL_NUMBER)
+    end
+
+    it 'detects and reports issue INVALID_HEX_NUMBER' do
+      expect_issue('0x3g', Puppet::Pops::Issues::INVALID_HEX_NUMBER)
+    end
+
+    it 'detects and reports issue INVALID_OCTAL_NUMBER' do
+      expect_issue('038', Puppet::Pops::Issues::INVALID_OCTAL_NUMBER)
+    end
+
+    it 'detects and reports issue INVALID_DECIMAL_NUMBER' do
+      expect_issue('4.3g', Puppet::Pops::Issues::INVALID_DECIMAL_NUMBER)
+    end
+
+    it 'detects and reports issue NO_INPUT_TO_LEXER' do
+      expect { Puppet::Pops::Parser::Lexer2.new.fullscan }.to raise_error(Puppet::ParseErrorWithIssue) { |e|
+        expect(e.issue_code).to be(Puppet::Pops::Issues::NO_INPUT_TO_LEXER.issue_code)
+      }
+    end
+
+    it 'detects and reports issue UNCLOSED_QUOTE' do
+      expect_issue('"asd', Puppet::Pops::Issues::UNCLOSED_QUOTE)
+    end
+  end
+end

data/spec/unit/pops/parser/parse_heredoc_spec.rb

@@ -71,6 +71,32 @@ describe "egrammar parsing heredoc" do
     ].join("\n")
   end
 
+  it "parses interpolated heredoc expression containing escapes" do
+    src = <<-CODE
+    @("END")
+    Hello \\$name
+    |- END
+    CODE
+    dump(parse(src)).should == [
+      "(@()",
+      "  (sublocated (cat 'Hello \\' (str $name) ''))",
+      ")"
+    ].join("\n")
+  end
+
+  it "parses interpolated heredoc expression containing escapes when escaping other things than $" do
+    src = <<-CODE
+    @("END"/t)
+    Hello \\$name
+    |- END
+    CODE
+    dump(parse(src)).should == [
+      "(@()",
+      "  (sublocated (cat 'Hello \\' (str $name) ''))",
+      ")"
+    ].join("\n")
+  end
+
   it "parses with escaped newlines without preceding whitespace" do
     src = <<-CODE
     @(END/L)

data/spec/unit/pops/transformer/transform_calls_spec.rb

@@ -38,7 +38,7 @@ describe "transformation to Puppet AST for function calls" do
 
         "info bar"         => '(invoke info bar)',
         "notice bar"       => '(invoke notice bar)',
-        "error bar"        => '(invoke error bar)',
+        "err bar"          => '(invoke err bar)',
         "warning bar"      => '(invoke warning bar)',
         "debug bar"        => '(invoke debug bar)',
 

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

@@ -89,6 +89,10 @@ describe 'The type calculator' do
     Puppet::Pops::Types::TypeFactory.optional(t)
   end
 
+  def not_undef_t(t = nil)
+    Puppet::Pops::Types::TypeFactory.not_undef(t)
+  end
+
   def undef_t
     Puppet::Pops::Types::TypeFactory.undef
   end
@@ -108,6 +112,7 @@ describe 'The type calculator' do
     def all_types
       [ Puppet::Pops::Types::PAnyType,
         Puppet::Pops::Types::PUndefType,
+        Puppet::Pops::Types::PNotUndefType,
         Puppet::Pops::Types::PDataType,
         Puppet::Pops::Types::PScalarType,
         Puppet::Pops::Types::PStringType,
@@ -184,6 +189,7 @@ describe 'The type calculator' do
       result << array_t(types::PDataType.new)
       result << types::TypeFactory.hash_of_data
       result << Puppet::Pops::Types::PUndefType
+      result << not_undef_t(types::PDataType.new)
       tmp = tuple_t(types::PDataType.new)
       result << (tmp)
       tmp.size_type = range_t(0, nil)
@@ -389,7 +395,7 @@ describe 'The type calculator' do
           t = calculator.infer_set({ 'mode' => 'read', 'path' => ['foo', 'fee' ] })
           expect(t.class).to eq(Puppet::Pops::Types::PStructType)
           expect(t.elements.size).to eq(2)
-          els = t.elements.map { |e| e.type }.sort {|a,b| a.to_s <=> b.to_s }
+          els = t.elements.map { |e| e.value_type }.sort {|a,b| a.to_s <=> b.to_s }
           els[0].class.should == Puppet::Pops::Types::PStringType
           els[1].class.should == Puppet::Pops::Types::PTupleType
         end
@@ -471,6 +477,45 @@ describe 'The type calculator' do
       calculator.string(calculator.common_type(r1, r2)).should == "Class"
     end
 
+    context 'of strings' do
+      it 'computes commonality' do
+        t1 = string_t('abc')
+        t2 = string_t('xyz')
+        common_t = calculator.common_type(t1,t2)
+        expect(common_t.class).to eq(Puppet::Pops::Types::PStringType)
+        expect(common_t.values).to eq(['abc', 'xyz'])
+      end
+
+      it 'computes common size_type' do
+        t1 = string_t
+        t1.size_type = range_t(3,6)
+        t2 = string_t
+        t2.size_type = range_t(2,4)
+        common_t = calculator.common_type(t1,t2)
+        expect(common_t.class).to eq(Puppet::Pops::Types::PStringType)
+        expect(common_t.size_type).to eq(range_t(2,6))
+      end
+
+      it 'computes common size_type to be undef when one of the types has no size_type' do
+        t1 = string_t
+        t2 = string_t
+        t2.size_type = range_t(2,4)
+        common_t = calculator.common_type(t1,t2)
+        expect(common_t.class).to eq(Puppet::Pops::Types::PStringType)
+        expect(common_t.size_type).to be_nil
+      end
+
+      it 'computes values to be empty if the one has empty values' do
+        t1 = string_t('apa')
+        t1.size_type = range_t(3,6)
+        t2 = string_t
+        t2.size_type = range_t(2,4)
+        common_t = calculator.common_type(t1,t2)
+        expect(common_t.class).to eq(Puppet::Pops::Types::PStringType)
+        expect(common_t.values).to be_empty
+      end
+    end
+
     it 'computes pattern commonality' do
       t1 = pattern_t('abc')
       t2 = pattern_t('xyz')
@@ -553,6 +598,13 @@ describe 'The type calculator' do
   context 'computes assignability' do
     include_context "types_setup"
 
+    it 'such that all types are assignable to themselves' do
+      all_types.each do |tc|
+        t = tc.new
+        expect(t).to be_assignable_to(t)
+      end
+    end
+
     context 'for Unit, such that' do
       it 'all types are assignable to Unit' do
         t = Puppet::Pops::Types::PUnitType.new()
@@ -577,13 +629,55 @@ describe 'The type calculator' do
         all_types.each { |t2| t2.new.should be_assignable_to(t) }
       end
 
-      it 'Any is not assignable to anything but Any' do
-        tested_types = all_types() - [Puppet::Pops::Types::PAnyType]
+      it 'Any is not assignable to anything but Any and Optional (implied Optional[Any])' do
+        tested_types = all_types() - [Puppet::Pops::Types::PAnyType, Puppet::Pops::Types::POptionalType]
         t = Puppet::Pops::Types::PAnyType.new()
         tested_types.each { |t2| t.should_not be_assignable_to(t2.new) }
       end
     end
 
+    context "for NotUndef, such that" do
+      it 'all types except types assignable from Undef are assignable to NotUndef' do
+        t = not_undef_t
+        tc = Puppet::Pops::Types::TypeCalculator.singleton
+        undef_t = Puppet::Pops::Types::PUndefType.new()
+        all_types().each do |c|
+          t2 = c.new
+          if tc.assignable?(t2, undef_t)
+            expect(t2).not_to be_assignable_to(t)
+          else
+            expect(t2).to be_assignable_to(t)
+          end
+        end
+      end
+
+      it 'type NotUndef[T] is assignable from T unless T is assignable from Undef ' do
+        tc = Puppet::Pops::Types::TypeCalculator.singleton
+        undef_t = Puppet::Pops::Types::PUndefType.new()
+        all_types().select do |c|
+          t2 = c.new
+          not_undef_t = not_undef_t(t2)
+          if tc.assignable?(t2, undef_t)
+            expect(t2).not_to be_assignable_to(not_undef_t)
+          else
+            expect(t2).to be_assignable_to(not_undef_t)
+          end
+        end
+      end
+
+      it 'type T is assignable from NotUndef[T] unless T is assignable from Undef' do
+        tc = Puppet::Pops::Types::TypeCalculator.singleton
+        undef_t = Puppet::Pops::Types::PUndefType.new()
+        all_types().select do |c|
+          t2 = c.new
+          not_undef_t = not_undef_t(t2)
+          unless tc.assignable?(t2, undef_t)
+            expect(not_undef_t).to be_assignable_to(t2)
+          end
+        end
+      end
+    end
+
     context "for Data, such that" do
       it 'all scalars + array and hash are assignable to Data' do
         t = Puppet::Pops::Types::PDataType.new()
@@ -610,7 +704,7 @@ describe 'The type calculator' do
       end
 
       it 'Data is not assignable to any disjunct type' do
-        tested_types = all_types - [Puppet::Pops::Types::PAnyType, Puppet::Pops::Types::PDataType] - scalar_types
+        tested_types = all_types - [Puppet::Pops::Types::PAnyType, Puppet::Pops::Types::POptionalType, Puppet::Pops::Types::PDataType] - scalar_types
         t = Puppet::Pops::Types::PDataType.new()
         tested_types.each {|t2| t.should_not be_assignable_to(t2.new) }
       end
@@ -647,7 +741,7 @@ describe 'The type calculator' do
       end
 
       it 'Scalar is not assignable to any disjunct type' do
-        tested_types = all_types - [Puppet::Pops::Types::PAnyType, Puppet::Pops::Types::PDataType] - scalar_types
+        tested_types = all_types - [Puppet::Pops::Types::PAnyType, Puppet::Pops::Types::POptionalType, Puppet::Pops::Types::PNotUndefType, Puppet::Pops::Types::PDataType] - scalar_types
         t = Puppet::Pops::Types::PScalarType.new()
         tested_types.each {|t2| t.should_not be_assignable_to(t2.new) }
       end
@@ -668,6 +762,8 @@ describe 'The type calculator' do
       it 'Numeric is not assignable to any disjunct type' do
         tested_types = all_types - [
           Puppet::Pops::Types::PAnyType,
+          Puppet::Pops::Types::POptionalType,
+          Puppet::Pops::Types::PNotUndefType,
           Puppet::Pops::Types::PDataType,
           Puppet::Pops::Types::PScalarType,
           ] - numeric_types
@@ -689,7 +785,7 @@ describe 'The type calculator' do
       end
 
       it 'Collection is not assignable to any disjunct type' do
-        tested_types = all_types - [Puppet::Pops::Types::PAnyType] - collection_types
+        tested_types = all_types - [Puppet::Pops::Types::PAnyType, Puppet::Pops::Types::POptionalType, Puppet::Pops::Types::PNotUndefType] - collection_types
         t = Puppet::Pops::Types::PCollectionType.new()
         tested_types.each {|t2| t.should_not be_assignable_to(t2.new) }
       end
@@ -700,6 +796,7 @@ describe 'The type calculator' do
         t = Puppet::Pops::Types::PArrayType.new()
         tested_types = collection_types - [
           Puppet::Pops::Types::PCollectionType,
+          Puppet::Pops::Types::PNotUndefType,
           Puppet::Pops::Types::PArrayType,
           Puppet::Pops::Types::PTupleType]
         tested_types.each {|t2| t.should_not be_assignable_to(t2.new) }
@@ -708,6 +805,8 @@ describe 'The type calculator' do
       it 'Array is not assignable to any disjunct type' do
         tested_types = all_types - [
           Puppet::Pops::Types::PAnyType,
+          Puppet::Pops::Types::POptionalType,
+          Puppet::Pops::Types::PNotUndefType,
           Puppet::Pops::Types::PDataType] - collection_types
         t = Puppet::Pops::Types::PArrayType.new()
         tested_types.each {|t2| t.should_not be_assignable_to(t2.new) }
@@ -727,6 +826,8 @@ describe 'The type calculator' do
       it 'Hash is not assignable to any disjunct type' do
         tested_types = all_types - [
           Puppet::Pops::Types::PAnyType,
+          Puppet::Pops::Types::POptionalType,
+          Puppet::Pops::Types::PNotUndefType,
           Puppet::Pops::Types::PDataType] - collection_types
         t = Puppet::Pops::Types::PHashType.new()
         tested_types.each {|t2| t.should_not be_assignable_to(t2.new) }
@@ -762,6 +863,8 @@ describe 'The type calculator' do
       it 'Tuple is not assignable to any disjunct type' do
         tested_types = all_types - [
           Puppet::Pops::Types::PAnyType,
+          Puppet::Pops::Types::POptionalType,
+          Puppet::Pops::Types::PNotUndefType,
           Puppet::Pops::Types::PDataType] - collection_types
         t = Puppet::Pops::Types::PTupleType.new()
         tested_types.each {|t2| t.should_not be_assignable_to(t2.new) }
@@ -781,10 +884,41 @@ describe 'The type calculator' do
       it 'Struct is not assignable to any disjunct type' do
         tested_types = all_types - [
           Puppet::Pops::Types::PAnyType,
+          Puppet::Pops::Types::POptionalType,
+          Puppet::Pops::Types::PNotUndefType,
           Puppet::Pops::Types::PDataType] - collection_types
         t = Puppet::Pops::Types::PStructType.new()
         tested_types.each {|t2| t.should_not be_assignable_to(t2.new) }
       end
+
+      it 'Default key optionality is controlled by value assignability to undef' do
+        t1 = struct_t({'member' => string_t})
+        expect(t1.elements[0].key_type).to eq(string_t('member'))
+        t1 = struct_t({'member' => object_t})
+        expect(t1.elements[0].key_type).to eq(optional_t(string_t('member')))
+      end
+
+      it "NotUndef['key'] becomes String['key'] (since its implied that String is required)" do
+        t1 = struct_t({not_undef_t('member') => string_t})
+        expect(t1.elements[0].key_type).to eq(string_t('member'))
+      end
+
+      it "Optional['key'] becomes Optional[String['key']]" do
+        t1 = struct_t({optional_t('member') => string_t})
+        expect(t1.elements[0].key_type).to eq(optional_t(string_t('member')))
+      end
+
+      it 'Optional members are not required' do
+        t1 = struct_t({optional_t('optional_member') => string_t, not_undef_t('other_member') => string_t})
+        t2 = struct_t({not_undef_t('other_member') => string_t})
+        expect(t2).to be_assignable_to(t1)
+      end
+
+      it 'Required members not optional even when value is' do
+        t1 = struct_t({not_undef_t('required_member') => object_t, not_undef_t('other_member') => string_t})
+        t2 = struct_t({not_undef_t('other_member') => string_t})
+        expect(t2).not_to be_assignable_to(t1)
+      end
     end
 
     context "for Callable, such that" do
@@ -792,7 +926,9 @@ describe 'The type calculator' do
         t = Puppet::Pops::Types::PCallableType.new()
         tested_types = all_types - [
           Puppet::Pops::Types::PCallableType,
-          Puppet::Pops::Types::PAnyType]
+          Puppet::Pops::Types::PAnyType,
+          Puppet::Pops::Types::POptionalType,
+          Puppet::Pops::Types::PNotUndefType]
         tested_types.each {|t2| t.should_not be_assignable_to(t2.new) }
       end
     end
@@ -1231,7 +1367,7 @@ describe 'The type calculator' do
       calculator.instance?(Puppet::Pops::Types::POptionalType.new(), :undef).should == true
     end
 
-    it 'should not consider undef to be an instance of any other type than Any, NilType and Data' do
+    it 'should not consider undef to be an instance of any other type than Any, UndefType and Data' do
       types_to_test = all_types - [
         Puppet::Pops::Types::PAnyType,
         Puppet::Pops::Types::PUndefType,
@@ -1248,9 +1384,10 @@ describe 'The type calculator' do
       calculator.instance?(Puppet::Pops::Types::PAnyType.new(), :default).should == true
     end
 
-    it 'should not consider "default" to be an instance of anything but Default, and Any' do
+    it 'should not consider "default" to be an instance of anything but Default, NotUndef, and Any' do
       types_to_test = all_types - [
         Puppet::Pops::Types::PAnyType,
+        Puppet::Pops::Types::PNotUndefType,
         Puppet::Pops::Types::PDefaultType,
         ]
 
@@ -1281,6 +1418,13 @@ describe 'The type calculator' do
       calculator.instance?(range, 'abcd').should == false
     end
 
+    it 'should consider string values' do
+      string = string_t('a', 'b')
+      expect(calculator.instance?(string, 'a')).to eq(true)
+      expect(calculator.instance?(string, 'b')).to eq(true)
+      expect(calculator.instance?(string, 'c')).to eq(false)
+    end
+
     it 'should consider array in length range' do
       range = factory.constrain_size(array_t(integer_t), 1,3)
       calculator.instance?(range, [1]).should    == true
@@ -1380,6 +1524,26 @@ describe 'The type calculator' do
         struct = struct_t({'a'=>Integer, 'b'=>String, 'c'=>optional_t(Float)})
         calculator.instance?(struct, {'a'=>1, 'b'=>'a', 'c'=>'x'}).should == false
       end
+
+      it 'should consider nil to be a valid element value' do
+        struct = struct_t({not_undef_t('a') => object_t, 'b'=>String})
+        expect(calculator.instance?(struct, {'a'=>nil , 'b'=>'a'})).to eq(true)
+      end
+
+      it 'should consider nil to be a valid element value but subject to value type' do
+        struct = struct_t({not_undef_t('a') => String, 'b'=>String})
+        expect(calculator.instance?(struct, {'a'=>nil , 'b'=>'a'})).to eq(false)
+      end
+
+      it 'should consider nil to be a valid element value but subject to value type even when key is optional' do
+        struct = struct_t({optional_t('a') => String, 'b'=>String})
+        expect(calculator.instance?(struct, {'a'=>nil , 'b'=>'a'})).to eq(false)
+      end
+
+      it 'should consider a hash where optional key is missing as assignable even if value of optional key is required' do
+        struct = struct_t({optional_t('a') => String, 'b'=>String})
+        expect(calculator.instance?(struct, {'b'=>'a'})).to eq(true)
+      end
     end
 
     context 'and t is Data' do
@@ -1724,6 +1888,21 @@ describe 'The type calculator' do
     it "should yield Unit for a Unit type" do
       expect(calculator.string(unit_t)).to eql('Unit')
     end
+
+    it "should yield 'NotUndef' for a PNotUndefType" do
+      t = not_undef_t
+      expect(calculator.string(t)).to eq('NotUndef')
+    end
+
+    it "should yield 'NotUndef[T]' for a PNotUndefType[T]" do
+      t = not_undef_t(data_t)
+      expect(calculator.string(t)).to eq('NotUndef[Data]')
+    end
+
+    it "should yield 'NotUndef['string']' for a PNotUndefType['string']" do
+      t = not_undef_t('hey')
+      expect(calculator.string(t)).to eq("NotUndef['hey']")
+    end
   end
 
   context 'when processing meta type' do
@@ -1867,7 +2046,7 @@ describe 'The type calculator' do
       generic.element_type.values.should == []
     end
 
-    it "a generic result is created by generalize! given an instance specific result for a Hash" do
+    it 'a generic result is created by generalize! given an instance specific result for a Hash' do
       generic = calculator.infer({'a' =>1,'b' => 2})
       generic.key_type.values.sort.should == ['a', 'b']
       generic.element_type.from.should == 1
@@ -1878,6 +2057,20 @@ describe 'The type calculator' do
       generic.element_type.to.should == nil
     end
 
+    it 'ensures that Struct key types are not generalized' do
+      generic = calculator.generalize!(struct_t({'a' => object_t}))
+      expect(calculator.string(generic)).to eq("Struct[{'a'=>Any}]")
+      generic = calculator.generalize!(struct_t({not_undef_t('a') => object_t}))
+      expect(calculator.string(generic)).to eq("Struct[{NotUndef['a']=>Any}]")
+      generic = calculator.generalize!(struct_t({optional_t('a') => string_t}))
+      expect(calculator.string(generic)).to eq("Struct[{Optional['a']=>String}]")
+    end
+
+    it 'ensures that Struct value types are generalized' do
+      generic = calculator.generalize!(struct_t({'a' => range_t(1, 3)}))
+      expect(calculator.string(generic)).to eq("Struct[{'a'=>Integer}]")
+    end
+
     it "does not reduce by combining types when using infer_set" do
       element_type = calculator.infer(['a','b',1,2]).element_type
       element_type.class.should == Puppet::Pops::Types::PScalarType
@@ -1983,7 +2176,7 @@ describe 'The type calculator' do
   end
 
   matcher :be_assignable_to do |type|
-    calc = Puppet::Pops::Types::TypeCalculator.new
+    calc = Puppet::Pops::Types::TypeCalculator.singleton
 
     match do |actual|
       calc.assignable?(type, actual)