puppet 3.7.4-x64-mingw32 → 3.7.5-x64-mingw32

data/spec/unit/hiera/backend/puppet_backend_spec.rb

@@ -34,7 +34,7 @@ describe Hiera::Backend::Puppet_backend do
       with_config(:puppet => {:datasource => "rspec"},
                   :hierarchy => ["%{foo}", "common"])
 
-      @mockscope.expects(:lookupvar).with("foo").returns(nil)
+      @mockscope.expects(:lookupvar).at_least_once.with("foo").returns(nil)
 
       @backend.hierarchy(@scope, nil).should == ["rspec::common", "ntp::config::rspec", "ntp::rspec"]
     end

data/spec/unit/parser/functions/create_resources_spec.rb

@@ -63,7 +63,7 @@ describe 'function for dynamically creating resources' do
     it 'should fail to add non-existing type' do
       expect do
         @scope.function_create_resources(['create-resource-foo', { 'foo' => {} }])
-      end.to raise_error(ArgumentError, /Invalid resource type create-resource-foo/)
+      end.to raise_error(/Invalid resource type create-resource-foo/)
     end
 
     it 'should be able to add edges' do
@@ -169,7 +169,7 @@ describe 'function for dynamically creating resources' do
         compile_to_catalog(<<-MANIFEST)
           create_resources('class', {'blah'=>{'one'=>'two'}})
         MANIFEST
-      end.to raise_error(Puppet::Error, 'Could not find declared class blah at line 1 on node foonode')
+      end.to raise_error(/Could not find declared class blah at line 1 on node foonode/)
     end
 
     it 'should be able to add edges' do

data/spec/unit/parser/functions/defined_spec.rb

@@ -55,6 +55,11 @@ describe "the 'defined' function" do
       expect(@scope.function_defined(['$x'])).to be_true
     end
 
+    it "is true when ::variable exists in scope" do
+      @compiler.topscope['x'] = 'something'
+      expect(@scope.function_defined(['$::x'])).to be_true
+    end
+
     it "is true when at least one variable exists in scope" do
       @scope['x'] = 'something'
       expect(@scope.function_defined(['$y', '$x', '$z'])).to be_true

data/spec/unit/parser/functions/lookup_spec.rb

@@ -17,6 +17,10 @@ describe "lookup function" do
     expect do
       scope.function_lookup([])
     end.to raise_error(ArgumentError, /Wrong number of arguments/)
+
+    expect do
+      scope.function_lookup([1,2])
+    end.to raise_error(Puppet::ParseError, /given 'name' argument, has wrong type/)
   end
 
   it "looks up a value that exists" do
@@ -42,7 +46,7 @@ describe "lookup function" do
   end
 
   it "hiera is called to lookup if value is not bound" do
-    Puppet::Parser::Scope.any_instance.stubs(:function_hiera).returns('from_hiera')
+    Hiera.any_instance.stubs(:lookup).returns('from_hiera')
     scope = scope_with_injections_from(bound(bind_single("another_value", "something")))
     expect(scope.function_lookup(['a_value'])).to eq('from_hiera')
   end

data/spec/unit/parser/functions/scanf_spec.rb

@@ -0,0 +1,30 @@
+#! /usr/bin/env ruby
+require 'spec_helper'
+
+describe "the scanf function" do
+  before :all do
+    Puppet::Parser::Functions.autoloader.loadall
+  end
+
+  let(:node) { Puppet::Node.new('localhost') }
+  let(:compiler) { Puppet::Parser::Compiler.new(node) }
+  let(:scope) { Puppet::Parser::Scope.new(compiler) }
+
+  it 'scans a value and returns an array' do
+    expect(scope.function_scanf(['42', '%i'])[0] == 42)
+  end
+
+  it 'returns empty array if nothing was scanned' do
+    expect(scope.function_scanf(['no', '%i']) == [])
+  end
+
+  it 'produces result up to first unsuccessful scan' do
+    expect(scope.function_scanf(['42 no', '%i'])[0] == 42)
+  end
+
+  it 'errors when not given enough arguments' do
+    expect do
+      scope.function_scanf(['42'])
+    end.to raise_error(/.*scanf\(\): Wrong number of arguments given/m)
+  end
+end

data/spec/unit/parser/scope_spec.rb

@@ -281,6 +281,11 @@ describe Puppet::Parser::Scope do
       it "should raise an error when unknown qualified variable is looked up" do
         expect { @scope['nowhere::john_doe'] }.to raise_error(/Undefined variable/)
       end
+
+      it "should not raise an error when built in variable is looked up" do
+        expect { @scope['caller_module_name'] }.to_not raise_error
+        expect { @scope['module_name'] }.to_not raise_error
+      end
     end
   end
 

data/spec/unit/pops/binder/injector_spec.rb

@@ -752,7 +752,7 @@ describe 'Injector' do
       end
 
       it "should be possible to post process lookup with a ruby proc" do
-        transformer = lambda {|scope, value| value + 1 }
+        transformer = lambda {|value| value + 1 }
         bindings.bind.name('an_int').to(42).producer_options( :transformer => transformer)
         injector(lbinder).lookup(scope, 'an_int').should == 43
       end

data/spec/unit/pops/evaluator/evaluating_parser_spec.rb

@@ -508,8 +508,14 @@ describe 'Puppet::Pops::Evaluator::EvaluatorImpl' do
          Type[Integer] : { yes } }"                          => 'yes',
       # supports unfold
       "case ringo {
-         *[paul, john, ringo, george] : { 'beatle' } }"       => 'beatle',
+         *[paul, john, ringo, george] : { 'beatle' } }"      => 'beatle',
 
+      "case undef {
+         undef : { 'yes' } }"                                => 'yes',
+
+      "case undef {
+         *undef : { 'no' }
+         default :{ 'yes' }}"                                => 'yes',
     }.each do |source, result|
         it "should parse and evaluate the expression '#{source}' to #{result}" do
           parser.evaluate_string(scope, source, __FILE__).should == result
@@ -526,6 +532,8 @@ describe 'Puppet::Pops::Evaluator::EvaluatorImpl' do
       "'banana' ? { /.*(ana).*/  => $1 }"                 => 'ana',
       "[2] ? { Array[String] => yes, Array => yes}"       => 'yes',
       "ringo ? *[paul, john, ringo, george] => 'beatle'"  => 'beatle',
+      "undef ? undef => 'yes'"                            => 'yes',
+      "undef ? {*undef => 'no', default => 'yes'}"        => 'yes',
     }.each do |source, result|
         it "should parse and evaluate the expression '#{source}' to #{result}" do
           parser.evaluate_string(scope, source, __FILE__).should == result
@@ -920,8 +928,8 @@ describe 'Puppet::Pops::Evaluator::EvaluatorImpl' do
           param 'Integer', 'count'
           required_block_param
         end
-        def test(count, block)
-          block.call({}, *[].fill(10, 0, count))
+        def test(count)
+          yield(*[].fill(10, 0, count))
         end
       end
       the_func = fc.new({}, env_loader)
@@ -937,8 +945,8 @@ describe 'Puppet::Pops::Evaluator::EvaluatorImpl' do
           param 'Any', 'lambda_arg'
           required_block_param
         end
-        def test(lambda_arg, block)
-          block.call({}, lambda_arg)
+        def test(lambda_arg)
+          yield(lambda_arg)
         end
       end
       the_func = fc.new({}, env_loader)
@@ -1050,6 +1058,26 @@ describe 'Puppet::Pops::Evaluator::EvaluatorImpl' do
       expect(parser.evaluate_string(scope, source, __FILE__)).to eql('10')
     end
 
+    it 'should accept a numeric variable expressed as $n' do
+      source = '$x = "abc123def" =~ /(abc)(123)(def)/; "${$2}"'
+      expect(parser.evaluate_string(scope, source, __FILE__)).to eql('123')
+    end
+
+    it 'should accept a numeric variable expressed as just an integer' do
+      source = '$x = "abc123def" =~ /(abc)(123)(def)/; "${2}"'
+      expect(parser.evaluate_string(scope, source, __FILE__)).to eql('123')
+    end
+
+    it 'should accept a numeric variable expressed as $n in an access operation' do
+      source = '$x = "abc123def" =~ /(abc)(123)(def)/; "${$0[4,3]}"'
+      expect(parser.evaluate_string(scope, source, __FILE__)).to eql('23d')
+    end
+
+    it 'should accept a numeric variable expressed as just an integer in an access operation' do
+      source = '$x = "abc123def" =~ /(abc)(123)(def)/; "${0[4,3]}"'
+      expect(parser.evaluate_string(scope, source, __FILE__)).to eql('23d')
+    end
+
     {
       '"value is ${a*2} yo"'  => :error,
     }.each do |source, result|

data/spec/unit/pops/loaders/loaders_spec.rb

@@ -27,6 +27,7 @@ describe 'loaders' do
   include PuppetSpec::Files
 
   let(:module_without_metadata) { File.join(config_dir('wo_metadata_module'), 'modules') }
+  let(:mix_4x_and_3x_functions) { config_dir('mix_4x_and_3x_functions') }
   let(:module_with_metadata) { File.join(config_dir('single_module'), 'modules') }
   let(:dependent_modules_with_metadata) { config_dir('dependent_modules_with_metadata') }
   let(:empty_test_env) { environment_for() }
@@ -99,6 +100,26 @@ describe 'loaders' do
     expect(function.call({})).to eql("usee::callee() was told 'passed value' + I am user::caller()")
   end
 
+  context 'with scope' do
+    let(:env) { environment_for(mix_4x_and_3x_functions) }
+    let(:scope) { Puppet::Parser::Compiler.new(Puppet::Node.new("test", :environment => env)).newscope(nil) }
+    let(:loader) { Puppet::Pops::Loaders.new(env).private_loader_for_module('user') }
+
+    it 'can call 3x function in dependent module from a 4x function' do
+      Puppet.override({ :current_environment => scope.environment, :global_scope => scope }) do
+        function = loader.load_typed(typed_name(:function, 'user::caller')).value
+        expect(function.call(scope)).to eql("usee::callee() got 'first' - usee::callee() got 'second'")
+      end
+    end
+
+    it 'can call 3x function and propagate caller scope from a 4x function' do
+      Puppet.override({ :current_environment => scope.environment, :global_scope => scope }) do
+        function = loader.load_typed(typed_name(:function, 'user::caller_ws')).value
+        expect(function.call(scope, 'passed in scope')).to eql("usee::callee_ws() got 'passed in scope'")
+      end
+    end
+  end
+
   it 'can load a function more than once from modules' do
     env = environment_for(dependent_modules_with_metadata)
     loaders = Puppet::Pops::Loaders.new(env)
@@ -112,7 +133,7 @@ describe 'loaders' do
   end
 
   def environment_for(*module_paths)
-    Puppet::Node::Environment.create(:'*test*', module_paths, '')
+    Puppet::Node::Environment.create(:'*test*', module_paths)
   end
 
   def typed_name(type, name)

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

@@ -118,10 +118,8 @@ describe 'Lexer2' do
   end
 
   [ '_x::y', 'x::_y'].each do |string|
-    it "should consider the bare word '#{string}' to be a bad NAME" do
-      expect {
-        tokens_scanned_from(string)
-      }.to raise_error(/Illegal fully qualified name/)
+    it "should consider the bare word '#{string}' to be a WORD" do
+      tokens_scanned_from(string).should match_tokens2(:WORD)
     end
   end
 
@@ -209,21 +207,33 @@ describe 'Lexer2' do
     end
   end
 
-  { '"a$x b"'  => [[:DQPRE,    'a',   {:line => 1, :pos=>1, :length=>2 }],
-                   [:VARIABLE, 'x',   {:line => 1, :pos=>3, :length=>2 }],
-                   [:DQPOST,   ' b',  {:line => 1, :pos=>5, :length=>3 }]],
+  { '"a$x b"'     => [[:DQPRE,    'a',   {:line => 1, :pos=>1, :length=>2 }],
+                      [:VARIABLE, 'x',   {:line => 1, :pos=>3, :length=>2 }],
+                      [:DQPOST,   ' b',  {:line => 1, :pos=>5, :length=>3 }]],
 
-    '"a$x.b"'  => [[:DQPRE,    'a',   {:line => 1, :pos=>1, :length=>2 }],
-                   [:VARIABLE, 'x',   {:line => 1, :pos=>3, :length=>2 }],
-                   [:DQPOST,   '.b',  {:line => 1, :pos=>5, :length=>3 }]],
+    '"a$x.b"'     => [[:DQPRE,    'a',   {:line => 1, :pos=>1, :length=>2 }],
+                      [:VARIABLE, 'x',   {:line => 1, :pos=>3, :length=>2 }],
+                      [:DQPOST,   '.b',  {:line => 1, :pos=>5, :length=>3 }]],
 
-    '"$x.b"'   => [[:DQPRE,    '',    {:line => 1, :pos=>1, :length=>1 }],
-                   [:VARIABLE, 'x',   {:line => 1, :pos=>2, :length=>2 }],
-                   [:DQPOST,   '.b',  {:line => 1, :pos=>4, :length=>3 }]],
+    '"$x.b"'      => [[:DQPRE,    '',    {:line => 1, :pos=>1, :length=>1 }],
+                      [:VARIABLE, 'x',   {:line => 1, :pos=>2, :length=>2 }],
+                      [:DQPOST,   '.b',  {:line => 1, :pos=>4, :length=>3 }]],
 
-    '"a$x"'    => [[:DQPRE,    'a',   {:line => 1, :pos=>1, :length=>2 }],
-                   [:VARIABLE, 'x',   {:line => 1, :pos=>3, :length=>2 }],
-                   [:DQPOST,   '',    {:line => 1, :pos=>5, :length=>1 }]],
+    '"a$x"'       => [[:DQPRE,    'a',   {:line => 1, :pos=>1, :length=>2 }],
+                      [:VARIABLE, 'x',   {:line => 1, :pos=>3, :length=>2 }],
+                      [:DQPOST,   '',    {:line => 1, :pos=>5, :length=>1 }]],
+
+    '"a${x}"'     => [[:DQPRE,    'a',   {:line => 1, :pos=>1, :length=>4 }],
+                      [:VARIABLE, 'x',   {:line => 1, :pos=>5, :length=>1 }],
+                      [:DQPOST,   '',    {:line => 1, :pos=>7, :length=>1 }]],
+
+    '"a${_x}"'    => [[:DQPRE,    'a',   {:line => 1, :pos=>1, :length=>4 }],
+                      [:VARIABLE, '_x',  {:line => 1, :pos=>5, :length=>2 }],
+                      [:DQPOST,   '',    {:line => 1, :pos=>8, :length=>1 }]],
+
+    '"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 }]],
   }.each do |source, expected|
     it "should lex an interpolated variable 'x' from #{source}" do
       tokens_scanned_from(source).should match_tokens2(*expected)
@@ -301,6 +311,8 @@ describe 'Lexer2' do
     "]"     => ["] /./",       [:RBRACK, :DIV, :DOT, :DIV]],
     "|>"     => ["|> /./",     [:RCOLLECT, :DIV, :DOT, :DIV]],
     "|>>"    => ["|>> /./",    [:RRCOLLECT, :DIV, :DOT, :DIV]],
+    "$x"     => ["$x /1/",     [:VARIABLE, :DIV, :NUMBER, :DIV]],
+    "a-b"    => ["a-b /1/",    [:WORD, :DIV, :NUMBER, :DIV]],
     '"a$a"'  => ['"a$a" /./',  [:DQPRE, :VARIABLE, :DQPOST, :DIV, :DOT, :DIV]],
   }.each do |token, entry|
     it "should not lex regexp after '#{token}'" do

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

@@ -114,4 +114,25 @@ describe "egrammar parsing heredoc" do
     ].join("\n")
   end
 
+  it 'parses multiple heredocs on the same line' do
+    src = <<-CODE
+    notice({ @(foo) => @(bar) })
+    hello
+    -foo
+    world
+    -bar
+    notice '!'
+    CODE
+    expect(dump(parse(src))).to eq([
+      '(block',
+      '  (invoke notice ({} ((@()',
+      '    (sublocated \'    hello\')',
+      '  ) (@()',
+      '    (sublocated \'    world\')',
+      '  ))))',
+      '  (invoke notice \'!\')',
+      ')'
+    ].join("\n"))
+  end
+
 end

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

@@ -85,6 +85,14 @@ describe 'The type calculator' do
     Puppet::Pops::Types::TypeFactory.any()
   end
 
+  def optional_t(t)
+    Puppet::Pops::Types::TypeFactory.optional(t)
+  end
+
+  def undef_t
+    Puppet::Pops::Types::TypeFactory.undef
+  end
+
   def unit_t
     # Cannot be created via factory, the type is private to the type system
     Puppet::Pops::Types::PUnitType.new
@@ -99,7 +107,7 @@ describe 'The type calculator' do
     # Do not include the special type Unit in this list
     def all_types
       [ Puppet::Pops::Types::PAnyType,
-        Puppet::Pops::Types::PNilType,
+        Puppet::Pops::Types::PUndefType,
         Puppet::Pops::Types::PDataType,
         Puppet::Pops::Types::PScalarType,
         Puppet::Pops::Types::PStringType,
@@ -175,7 +183,7 @@ describe 'The type calculator' do
       result << Puppet::Pops::Types::PDataType
       result << array_t(types::PDataType.new)
       result << types::TypeFactory.hash_of_data
-      result << Puppet::Pops::Types::PNilType
+      result << Puppet::Pops::Types::PUndefType
       tmp = tuple_t(types::PDataType.new)
       result << (tmp)
       tmp.size_type = range_t(0, nil)
@@ -223,8 +231,8 @@ describe 'The type calculator' do
       calculator.infer(/^a regular expression$/).class.should == Puppet::Pops::Types::PRegexpType
     end
 
-    it 'nil translates to PNilType' do
-      calculator.infer(nil).class.should == Puppet::Pops::Types::PNilType
+    it 'nil translates to PUndefType' do
+      calculator.infer(nil).class.should == Puppet::Pops::Types::PUndefType
     end
 
     it ':undef translates to PRuntimeType' do
@@ -355,8 +363,48 @@ describe 'The type calculator' do
       it 'with fixnum values translates to PHashType[key, PIntegerType]' do
         calculator.infer({:first => 1, :second => 2}).element_type.class.should == Puppet::Pops::Types::PIntegerType
       end
-    end
 
+      it 'when empty infers a type that answers true to is_the_empty_hash?' do
+        expect(calculator.infer({}).is_the_empty_hash?).to be_true
+        expect(calculator.infer_set({}).is_the_empty_hash?).to be_true
+      end
+
+      it 'when empty is assignable to any PHashType' do
+        expect(calculator.assignable?(hash_t(string_t, string_t), calculator.infer({}))).to be_true
+      end
+
+      it 'when empty is not assignable to a PHashType with from size > 0' do
+        expect(calculator.assignable?(constrained_t(hash_t(string_t,string_t), 1, 1), calculator.infer({}))).to be_false
+      end
+
+      context 'using infer_set' do
+        it "with 'first' and 'second' keys translates to PStructType[{first=>value,second=>value}]" do
+          t = calculator.infer_set({'first' => 1, 'second' => 2})
+          expect(t.class).to eq(Puppet::Pops::Types::PStructType)
+          expect(t.elements.size).to eq(2)
+          expect(t.elements.map { |e| e.name }.sort).to eq(['first', 'second'])
+        end
+
+        it 'with string keys and string and array values translates to PStructType[{key1=>PStringType,key2=>PTupleType}]' 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[0].class.should == Puppet::Pops::Types::PStringType
+          els[1].class.should == Puppet::Pops::Types::PTupleType
+        end
+
+        it 'with mixed string and non-string keys translates to PHashType' do
+          t = calculator.infer_set({ 1 => 'first', 'second' => 'second' })
+          expect(t.class).to eq(Puppet::Pops::Types::PHashType)
+        end
+
+        it 'with empty string keys translates to PHashType' do
+          t = calculator.infer_set({ '' => 'first', 'second' => 'second' })
+          expect(t.class).to eq(Puppet::Pops::Types::PHashType)
+        end
+      end
+    end
   end
 
   context 'patterns' do
@@ -683,6 +731,22 @@ describe 'The type calculator' do
         t = Puppet::Pops::Types::PHashType.new()
         tested_types.each {|t2| t.should_not be_assignable_to(t2.new) }
       end
+
+      it 'Struct is assignable to Hash with Pattern that matches all keys' do
+        struct_t({'x' => integer_t, 'y' => integer_t}).should be_assignable_to(hash_t(pattern_t(/^\w+$/), factory.any))
+      end
+
+      it 'Struct is assignable to Hash with Enum that matches all keys' do
+        struct_t({'x' => integer_t, 'y' => integer_t}).should be_assignable_to(hash_t(enum_t('x', 'y', 'z'), factory.any))
+      end
+
+      it 'Struct is not assignable to Hash with Pattern unless all keys match' do
+        struct_t({'a' => integer_t, 'A' => integer_t}).should_not be_assignable_to(hash_t(pattern_t(/^[A-Z]+$/), factory.any))
+      end
+
+      it 'Struct is not assignable to Hash with Enum unless all keys match' do
+        struct_t({'a' => integer_t, 'y' => integer_t}).should_not be_assignable_to(hash_t(enum_t('x', 'y', 'z'), factory.any))
+      end
     end
 
     context "for Tuple, such that" do
@@ -739,7 +803,7 @@ describe 'The type calculator' do
         Bignum     => Puppet::Pops::Types::PIntegerType.new,
         Float      => Puppet::Pops::Types::PFloatType.new,
         Numeric    => Puppet::Pops::Types::PNumericType.new,
-        NilClass   => Puppet::Pops::Types::PNilType.new,
+        NilClass   => Puppet::Pops::Types::PUndefType.new,
         TrueClass  => Puppet::Pops::Types::PBooleanType.new,
         FalseClass => Puppet::Pops::Types::PBooleanType.new,
         String     => Puppet::Pops::Types::PStringType.new,
@@ -1025,6 +1089,30 @@ describe 'The type calculator' do
         calculator.assignable?(struct2, struct1).should == true
       end
 
+      it 'should accept matching structs with less elements when unmatched elements are optional' do
+        struct1 = struct_t({'a'=>Integer, 'b'=>Integer, 'c'=>optional_t(Integer)})
+        struct2 = struct_t({'a'=>Integer, 'b'=>Integer})
+        calculator.assignable?(struct1, struct2).should == true
+      end
+
+      it 'should reject matching structs with more elements even if excess elements are optional' do
+        struct1 = struct_t({'a'=>Integer, 'b'=>Integer})
+        struct2 = struct_t({'a'=>Integer, 'b'=>Integer, 'c'=>optional_t(Integer)})
+        calculator.assignable?(struct1, struct2).should == false
+      end
+
+      it 'should accept matching structs where one is more general than the other with respect to optional' do
+        struct1 = struct_t({'a'=>Integer, 'b'=>Integer, 'c'=>optional_t(Integer)})
+        struct2 = struct_t({'a'=>Integer, 'b'=>Integer, 'c'=>Integer})
+        calculator.assignable?(struct1, struct2).should == true
+      end
+
+      it 'should reject matching structs where one is more special than the other with respect to optional' do
+        struct1 = struct_t({'a'=>Integer, 'b'=>Integer, 'c'=>Integer})
+        struct2 = struct_t({'a'=>Integer, 'b'=>Integer, 'c'=>optional_t(Integer)})
+        calculator.assignable?(struct1, struct2).should == false
+      end
+
       it 'should accept matching structs where one is more general than the other' do
         struct1 = struct_t({'a'=>Integer, 'b'=>Integer})
         struct2 = struct_t({'a'=>Numeric, 'b'=>Numeric})
@@ -1041,6 +1129,13 @@ describe 'The type calculator' do
         calculator.assignable?(struct1, hsh).should == true
         calculator.assignable?(hsh, struct1).should == true
       end
+
+      it 'should accept empty hash with key_type undef' do
+        struct1 = struct_t({'a'=>optional_t(Integer)})
+        hsh = hash_t(undef_t, undef_t)
+        factory.constrain_size(hsh, 0, 0)
+        calculator.assignable?(struct1, hsh).should == true
+      end
     end
 
     it 'should recognize ruby type inheritance' do
@@ -1117,7 +1212,7 @@ describe 'The type calculator' do
     include_context "types_setup"
 
     it 'should consider undef to be instance of Any, NilType, and optional' do
-      calculator.instance?(Puppet::Pops::Types::PNilType.new(), nil).should    == true
+      calculator.instance?(Puppet::Pops::Types::PUndefType.new(), nil).should    == true
       calculator.instance?(Puppet::Pops::Types::PAnyType.new(), nil).should == true
       calculator.instance?(Puppet::Pops::Types::POptionalType.new(), nil).should == true
     end
@@ -1139,7 +1234,7 @@ describe 'The type calculator' do
     it 'should not consider undef to be an instance of any other type than Any, NilType and Data' do
       types_to_test = all_types - [
         Puppet::Pops::Types::PAnyType,
-        Puppet::Pops::Types::PNilType,
+        Puppet::Pops::Types::PUndefType,
         Puppet::Pops::Types::PDataType,
         Puppet::Pops::Types::POptionalType,
         ]
@@ -1252,12 +1347,39 @@ describe 'The type calculator' do
       calculator.instance?(tuple, [1, 'a', 1]).should          == false
     end
 
-    it 'should consider hash[cont] as instance of Struct[cont-t]' do
-      struct = struct_t({'a'=>Integer, 'b'=>String, 'c'=>Float})
-      calculator.instance?(struct, {'a'=>1, 'b'=>'a', 'c'=>3.14}).should       == true
-      calculator.instance?(struct, {'a'=>1.2, 'b'=>'a', 'c'=>3.14}).should     == false
-      calculator.instance?(struct, {'a'=>1, 'b'=>1, 'c'=>3.14}).should         == false
-      calculator.instance?(struct, {'a'=>1, 'b'=>'a', 'c'=>1}).should          == false
+    context 'and t is Struct' do
+      it 'should consider hash[cont] as instance of Struct[cont-t]' do
+        struct = struct_t({'a'=>Integer, 'b'=>String, 'c'=>Float})
+        calculator.instance?(struct, {'a'=>1, 'b'=>'a', 'c'=>3.14}).should       == true
+        calculator.instance?(struct, {'a'=>1.2, 'b'=>'a', 'c'=>3.14}).should     == false
+        calculator.instance?(struct, {'a'=>1, 'b'=>1, 'c'=>3.14}).should         == false
+        calculator.instance?(struct, {'a'=>1, 'b'=>'a', 'c'=>1}).should          == false
+      end
+
+      it 'should consider empty hash as instance of Struct[x=>Optional[String]]' do
+        struct = struct_t({'a'=>optional_t(String)})
+        calculator.instance?(struct, {}).should == true
+      end
+
+      it 'should consider hash[cont] as instance of Struct[cont-t,optionals]' do
+        struct = struct_t({'a'=>Integer, 'b'=>String, 'c'=>optional_t(Float)})
+        calculator.instance?(struct, {'a'=>1, 'b'=>'a'}).should == true
+      end
+
+      it 'should consider hash[cont] as instance of Struct[cont-t,variants with optionals]' do
+        struct = struct_t({'a'=>Integer, 'b'=>String, 'c'=>variant_t(String, optional_t(Float))})
+        calculator.instance?(struct, {'a'=>1, 'b'=>'a'}).should == true
+      end
+
+      it 'should not consider hash[cont,cont2] as instance of Struct[cont-t]' do
+        struct = struct_t({'a'=>Integer, 'b'=>String})
+        calculator.instance?(struct, {'a'=>1, 'b'=>'a', 'c'=>'x'}).should == false
+      end
+
+      it 'should not consider hash[cont,cont2] as instance of Struct[cont-t,optional[cont3-t]' do
+        struct = struct_t({'a'=>Integer, 'b'=>String, 'c'=>optional_t(Float)})
+        calculator.instance?(struct, {'a'=>1, 'b'=>'a', 'c'=>'x'}).should == false
+      end
     end
 
     context 'and t is Data' do
@@ -1343,8 +1465,8 @@ describe 'The type calculator' do
       end
     end
 
-    it 'should yield \'PNilType\' for NilClass' do
-      calculator.type(NilClass).class.should == Puppet::Pops::Types::PNilType
+    it 'should yield \'PUndefType\' for NilClass' do
+      calculator.type(NilClass).class.should == Puppet::Pops::Types::PUndefType
     end
 
     it 'should yield \'PStringType\' for String' do
@@ -1607,7 +1729,7 @@ describe 'The type calculator' do
   context 'when processing meta type' do
     it 'should infer PType as the type of all other types' do
       ptype = Puppet::Pops::Types::PType
-      calculator.infer(Puppet::Pops::Types::PNilType.new()       ).is_a?(ptype).should() == true
+      calculator.infer(Puppet::Pops::Types::PUndefType.new()       ).is_a?(ptype).should() == true
       calculator.infer(Puppet::Pops::Types::PDataType.new()      ).is_a?(ptype).should() == true
       calculator.infer(Puppet::Pops::Types::PScalarType.new()   ).is_a?(ptype).should() == true
       calculator.infer(Puppet::Pops::Types::PStringType.new()    ).is_a?(ptype).should() == true
@@ -1632,7 +1754,7 @@ describe 'The type calculator' do
 
     it 'should infer PType as the type of all other types' do
       ptype = Puppet::Pops::Types::PType
-      calculator.string(calculator.infer(Puppet::Pops::Types::PNilType.new()       )).should == "Type[Undef]"
+      calculator.string(calculator.infer(Puppet::Pops::Types::PUndefType.new()       )).should == "Type[Undef]"
       calculator.string(calculator.infer(Puppet::Pops::Types::PDataType.new()      )).should == "Type[Data]"
       calculator.string(calculator.infer(Puppet::Pops::Types::PScalarType.new()   )).should == "Type[Scalar]"
       calculator.string(calculator.infer(Puppet::Pops::Types::PStringType.new()    )).should == "Type[String]"
@@ -1775,7 +1897,7 @@ describe 'The type calculator' do
       inferred_type.class.should == Puppet::Pops::Types::PTupleType
       element_types = inferred_type.types
       element_types[0].class.should == Puppet::Pops::Types::PStringType
-      element_types[1].class.should == Puppet::Pops::Types::PNilType
+      element_types[1].class.should == Puppet::Pops::Types::PUndefType
     end
   end