puppet 4.10.0 → 5.0.0

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

@@ -28,6 +28,59 @@ describe 'Puppet::Pops::Evaluator::EvaluatorImpl' do
       it "8 << -1 == 4"   do; expect(evaluate(literal(8) << literal(-1))).to eq(4); end
     end
 
+    # 64 bit signed integer max and min
+    MAX_INTEGER =  0x7fffffffffffffff
+    MIN_INTEGER = -0x8000000000000000
+
+    context "on integer values that cause 64 bit overflow" do
+      it "MAX + 1 => error" do
+        expect{
+          evaluate(literal(MAX_INTEGER) + literal(1))
+        }.to raise_error(/resulted in a value outside of Puppet Integer max range/)
+      end
+
+      it "MAX - -1 => error" do
+        expect{
+          evaluate(literal(MAX_INTEGER) - literal(-1))
+        }.to raise_error(/resulted in a value outside of Puppet Integer max range/)
+      end
+
+      it "MAX * 2 => error" do
+        expect{
+          evaluate(literal(MAX_INTEGER) * literal(2))
+        }.to raise_error(/resulted in a value outside of Puppet Integer max range/)
+      end
+
+      it "(MAX+1)*2 / 2 => error" do
+        expect{
+          evaluate(literal((MAX_INTEGER+1)*2) / literal(2))
+        }.to raise_error(/resulted in a value outside of Puppet Integer max range/)
+      end
+
+      it "MAX << 1 => error" do
+        expect{
+          evaluate(literal(MAX_INTEGER) << literal(1))
+        }.to raise_error(/resulted in a value outside of Puppet Integer max range/)
+      end
+
+      it "((MAX+1)*2)  << 1 => error" do
+        expect{
+          evaluate(literal((MAX_INTEGER+1)*2) >> literal(1))
+        }.to raise_error(/resulted in a value outside of Puppet Integer max range/)
+      end
+
+      it "MIN - 1 => error" do
+        expect{
+          evaluate(literal(MIN_INTEGER) - literal(1))
+        }.to raise_error(/resulted in a value outside of Puppet Integer min range/)
+      end
+
+      it "does not error on the border values" do
+          expect(evaluate(literal(MAX_INTEGER) + literal(MIN_INTEGER))).to eq(MAX_INTEGER+MIN_INTEGER)
+      end
+
+    end
+
     context "on Floats" do
       it "2.2 + 2.2  ==  4.4"   do; expect(evaluate(literal(2.2) + literal(2.2))).to eq(4.4)  ; end
       it "7.7 - 3.3  ==  4.4"   do; expect(evaluate(literal(7.7) - literal(3.3))).to eq(4.4)  ; end
@@ -140,7 +193,7 @@ describe 'Puppet::Pops::Evaluator::EvaluatorImpl' do
 
       it 'Timespan + Timestamp = Timestamp' do
         code = "notice(assert_type(Timestamp, Timespan({days => 3}) + Timestamp('2016-08-27T16:44:49.999 UTC')))"
-        expect(eval_and_collect_notices(code)).to eql(['2016-08-30T16:44:49.999 UTC'])
+        expect(eval_and_collect_notices(code)).to eql(['2016-08-30T16:44:49.999000000 UTC'])
       end
 
       it 'Timespan - Timestamp is an error' do
@@ -170,17 +223,17 @@ describe 'Puppet::Pops::Evaluator::EvaluatorImpl' do
 
       it 'Timestamp + Timespan = Timestamp' do
         code = "notice(assert_type(Timestamp, Timestamp('2016-10-10') + Timespan('0-12:00:00')))"
-        expect(eval_and_collect_notices(code)).to eql(['2016-10-10T12:00:00.000 UTC'])
+        expect(eval_and_collect_notices(code)).to eql(['2016-10-10T12:00:00.000000000 UTC'])
       end
 
       it 'Timestamp + Numeric = Timestamp' do
         code = "notice(assert_type(Timestamp, Timestamp('2016-10-10T12:00:00.000') + 3600.123))"
-        expect(eval_and_collect_notices(code)).to eql(['2016-10-10T13:00:00.123 UTC'])
+        expect(eval_and_collect_notices(code)).to eql(['2016-10-10T13:00:00.123000000 UTC'])
       end
 
       it 'Numeric + Timestamp = Timestamp' do
         code = "notice(assert_type(Timestamp, 3600.123 + Timestamp('2016-10-10T12:00:00.000')))"
-        expect(eval_and_collect_notices(code)).to eql(['2016-10-10T13:00:00.123 UTC'])
+        expect(eval_and_collect_notices(code)).to eql(['2016-10-10T13:00:00.123000000 UTC'])
       end
 
       it 'Timestamp - Timestamp = Timespan' do
@@ -190,12 +243,12 @@ describe 'Puppet::Pops::Evaluator::EvaluatorImpl' do
 
       it 'Timestamp - Timespan = Timestamp' do
         code = "notice(assert_type(Timestamp, Timestamp('2016-10-10') - Timespan('0-12:00:00')))"
-        expect(eval_and_collect_notices(code)).to eql(['2016-10-09T12:00:00.000 UTC'])
+        expect(eval_and_collect_notices(code)).to eql(['2016-10-09T12:00:00.000000000 UTC'])
       end
 
       it 'Timestamp - Numeric = Timestamp' do
         code = "notice(assert_type(Timestamp, Timestamp('2016-10-10') - 3600.123))"
-        expect(eval_and_collect_notices(code)).to eql(['2016-10-09T22:59:59.877 UTC'])
+        expect(eval_and_collect_notices(code)).to eql(['2016-10-09T22:59:59.877000000 UTC'])
       end
 
       it 'Numeric - Timestamp = Timestamp' do

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

@@ -31,7 +31,7 @@ describe 'Puppet::Pops::Evaluator::EvaluatorImpl' do
     end
 
     it 'should evaluator types to types' do
-      array_type = Puppet::Pops::Types::PArrayType::DATA
+      array_type = Puppet::Pops::Types::PArrayType::DEFAULT
       expect(evaluate(fqr('Array'))).to eq(array_type)
     end
   end
@@ -52,7 +52,7 @@ describe 'Puppet::Pops::Evaluator::EvaluatorImpl' do
     end
 
     it "[1,2,3] == [1,2,3] == true" do
-      expect(evaluate(literal([1,2,3]) == literal([1,2,3]))).to eq(true);
+      expect(evaluate(literal([1,2,3]).eq(literal([1,2,3])))).to eq(true);
     end
 
     it "[1,2,3] != [2,3,4] == true" do
@@ -60,7 +60,7 @@ describe 'Puppet::Pops::Evaluator::EvaluatorImpl' do
     end
 
     it "[1, 2, 3][2] == 3" do
-      expect(evaluate(literal([1,2,3])[2])).to eq(3)
+      expect(evaluate(literal([1,2,3]))[2]).to eq(3)
     end
   end
 
@@ -78,7 +78,7 @@ describe 'Puppet::Pops::Evaluator::EvaluatorImpl' do
     end
 
     it "{'a'=> 1, 'b'=>2} == {'a'=> 1, 'b'=>2} == true" do
-      expect(evaluate(literal({'a'=> 1, 'b'=>2}) == literal({'a'=> 1, 'b'=>2}))).to eq(true);
+      expect(evaluate(literal({'a'=> 1, 'b'=>2}).eq(literal({'a'=> 1, 'b'=>2})))).to eq(true);
     end
 
     it "{'a'=> 1, 'b'=>2} != {'x'=> 1, 'y'=>3} == true" do
@@ -86,7 +86,7 @@ describe 'Puppet::Pops::Evaluator::EvaluatorImpl' do
     end
 
     it "{'a' => 1, 'b' => 2}['b'] == 2" do
-      expect(evaluate(literal({:a => 1, :b => 2})[:b])).to eq(2)
+      expect(evaluate(literal({:a => 1, :b => 2}).access_at(:b))).to eq(2)
     end
   end
 

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

@@ -14,8 +14,8 @@ describe 'Puppet::Pops::Evaluator::EvaluatorImpl' do
   context "When the evaluator performs comparisons" do
 
     context "of string values" do
-      it "'a' == 'a' == true"  do; expect(evaluate(literal('a') == literal('a'))).to eq(true)   ; end
-      it "'a' == 'b' == false" do; expect(evaluate(literal('a') == literal('b'))).to eq(false)  ; end
+      it "'a' == 'a' == true"  do; expect(evaluate(literal('a').eq(literal('a')))).to eq(true)  ; end
+      it "'a' == 'b' == false" do; expect(evaluate(literal('a').eq(literal('b')))).to eq(false) ; end
       it "'a' != 'a' == false" do; expect(evaluate(literal('a').ne(literal('a')))).to eq(false) ; end
       it "'a' != 'b' == true"  do; expect(evaluate(literal('a').ne(literal('b')))).to eq(true)  ; end
 
@@ -36,18 +36,18 @@ describe 'Puppet::Pops::Evaluator::EvaluatorImpl' do
       it "'b' >= 'a' == true"  do; expect(evaluate(literal('b')  >= literal('a'))).to eq(true)  ; end
 
       context "with mixed case" do
-        it "'a' == 'A' == true"    do; expect(evaluate(literal('a') == literal('A'))).to eq(true)   ; end
+        it "'a' == 'A' == true"    do; expect(evaluate(literal('a').eq(literal('A')))).to eq(true)  ; end
         it "'a' != 'A' == false"   do; expect(evaluate(literal('a').ne(literal('A')))).to eq(false) ; end
         it "'a' >  'A' == false"   do; expect(evaluate(literal('a') > literal('A'))).to eq(false)   ; end
         it "'a' >= 'A' == true"    do; expect(evaluate(literal('a') >= literal('A'))).to eq(true)   ; end
         it "'A' <  'a' == false"   do; expect(evaluate(literal('A') < literal('a'))).to eq(false)   ; end
-        it "'A' <= 'a' == true"    do; expect(evaluate(literal('A') <= literal('a'))).to eq(true)  ; end
+        it "'A' <= 'a' == true"    do; expect(evaluate(literal('A') <= literal('a'))).to eq(true)   ; end
       end
     end
 
     context "of integer values" do
-      it "1 == 1 == true"  do; expect(evaluate(literal(1) == literal(1))).to eq(true)   ; end
-      it "1 == 2 == false" do; expect(evaluate(literal(1) == literal(2))).to eq(false)  ; end
+      it "1 == 1 == true"  do; expect(evaluate(literal(1).eq(literal(1)))).to eq(true)  ; end
+      it "1 == 2 == false" do; expect(evaluate(literal(1).eq(literal(2)))).to eq(false) ; end
       it "1 != 1 == false" do; expect(evaluate(literal(1).ne(literal(1)))).to eq(false) ; end
       it "1 != 2 == true"  do; expect(evaluate(literal(1).ne(literal(2)))).to eq(true)  ; end
 
@@ -69,13 +69,13 @@ describe 'Puppet::Pops::Evaluator::EvaluatorImpl' do
     end
 
     context "of mixed value types" do
-      it "1 == 1.0  == true"   do; expect(evaluate(literal(1)     == literal(1.0))).to eq(true)   ; end
+      it "1 == 1.0  == true"   do; expect(evaluate(literal(1).eq(    literal(1.0)))).to eq(true)  ; end
       it "1 < 1.1   == true"   do; expect(evaluate(literal(1)     <  literal(1.1))).to eq(true)   ; end
-      it "1.0 == 1  == true"   do; expect(evaluate(literal(1.0)   == literal(1))).to eq(true)     ; end
+      it "1.0 == 1  == true"   do; expect(evaluate(literal(1.0).eq(  literal(1)))).to eq(true)    ; end
       it "1.0 < 2   == true"   do; expect(evaluate(literal(1.0)   <  literal(2))).to eq(true)     ; end
       it "'1.0' < 'a' == true" do; expect(evaluate(literal('1.0') <  literal('a'))).to eq(true)   ; end
       it "'1.0' < ''  == true" do; expect(evaluate(literal('1.0') <  literal(''))).to eq(false)   ; end
-      it "'1.0' < ' ' == true" do; expect(evaluate(literal('1.0') <  literal(' '))).to eq(false)   ; end
+      it "'1.0' < ' ' == true" do; expect(evaluate(literal('1.0') <  literal(' '))).to eq(false)  ; end
       it "'a' > '1.0' == true" do; expect(evaluate(literal('a')   >  literal('1.0'))).to eq(true) ; end
     end
 
@@ -92,32 +92,32 @@ describe 'Puppet::Pops::Evaluator::EvaluatorImpl' do
     end
 
     context "of regular expressions" do
-      it "/.*/ == /.*/  == true"   do; expect(evaluate(literal(/.*/) == literal(/.*/))).to eq(true)   ; end
+      it "/.*/ == /.*/  == true"   do; expect(evaluate(literal(/.*/).eq(literal(/.*/)))).to eq(true)   ; end
       it "/.*/ != /a.*/ == true"   do; expect(evaluate(literal(/.*/).ne(literal(/a.*/)))).to eq(true) ; end
     end
 
     context "of booleans" do
-      it "true  == true  == true"    do; expect(evaluate(literal(true) == literal(true))).to eq(true)  ; end;
-      it "false == false == true"    do; expect(evaluate(literal(false) == literal(false))).to eq(true) ; end;
-      it "true == false  != true"    do; expect(evaluate(literal(true) == literal(false))).to eq(false) ; end;
-      it "false  == ''  == false"    do; expect(evaluate(literal(false) == literal(''))).to eq(false)  ; end;
-      it "undef  == ''  == false"    do; expect(evaluate(literal(:undef) == literal(''))).to eq(false)  ; end;
-      it "undef  == undef  == true"  do; expect(evaluate(literal(:undef) == literal(:undef))).to eq(true)  ; end;
-      it "nil    == undef  == true"  do; expect(evaluate(literal(nil) == literal(:undef))).to eq(true)  ; end;
+      it "true  == true  == true"    do; expect(evaluate(literal(true).eq(literal(true)))).to eq(true)  ; end;
+      it "false == false == true"    do; expect(evaluate(literal(false).eq(literal(false)))).to eq(true) ; end;
+      it "true == false  != true"    do; expect(evaluate(literal(true).eq(literal(false)))).to eq(false) ; end;
+      it "false  == ''  == false"    do; expect(evaluate(literal(false).eq(literal('')))).to eq(false)  ; end;
+      it "undef  == ''  == false"    do; expect(evaluate(literal(:undef).eq(literal('')))).to eq(false)  ; end;
+      it "undef  == undef  == true"  do; expect(evaluate(literal(:undef).eq(literal(:undef)))).to eq(true)  ; end;
+      it "nil    == undef  == true"  do; expect(evaluate(literal(nil).eq(literal(:undef)))).to eq(true)  ; end;
     end
 
     context "of collections" do
       it "[1,2,3] == [1,2,3] == true" do
-        expect(evaluate(literal([1,2,3]) == literal([1,2,3]))).to eq(true)
+        expect(evaluate(literal([1,2,3]).eq(literal([1,2,3])))).to eq(true)
         expect(evaluate(literal([1,2,3]).ne(literal([1,2,3])))).to eq(false)
-        expect(evaluate(literal([1,2,4]) == literal([1,2,3]))).to eq(false)
+        expect(evaluate(literal([1,2,4]).eq(literal([1,2,3])))).to eq(false)
         expect(evaluate(literal([1,2,4]).ne(literal([1,2,3])))).to eq(true)
       end
 
       it "{'a'=>1, 'b'=>2} == {'a'=>1, 'b'=>2} == true" do
-        expect(evaluate(literal({'a'=>1, 'b'=>2}) == literal({'a'=>1, 'b'=>2}))).to eq(true)
+        expect(evaluate(literal({'a'=>1, 'b'=>2}).eq(literal({'a'=>1, 'b'=>2})))).to eq(true)
         expect(evaluate(literal({'a'=>1, 'b'=>2}).ne(literal({'a'=>1, 'b'=>2})))).to eq(false)
-        expect(evaluate(literal({'a'=>1, 'b'=>2}) == literal({'x'=>1, 'b'=>2}))).to eq(false)
+        expect(evaluate(literal({'a'=>1, 'b'=>2}).eq(literal({'x'=>1, 'b'=>2})))).to eq(false)
         expect(evaluate(literal({'a'=>1, 'b'=>2}).ne(literal({'x'=>1, 'b'=>2})))).to eq(true)
       end
     end
@@ -175,11 +175,11 @@ describe 'Puppet::Pops::Evaluator::EvaluatorImpl' do
     it "'a' !~ 'b.*'  == true"    do; expect(evaluate(literal('a').mne(literal("b.*")))).to eq(true)  ; end
 
     it "'a' =~ Pattern['.*'] == true"    do
-      expect(evaluate(literal('a') =~ fqr('Pattern')[literal(".*")])).to eq(true)
+      expect(evaluate(literal('a') =~ fqr('Pattern').access_at(literal(".*")))).to eq(true)
     end
 
     it "$a = Pattern['.*']; 'a' =~ $a  == true"    do
-      expr = block(var('a').set(fqr('Pattern')['foo']), literal('foo') =~ var('a'))
+      expr = block(var('a').set(fqr('Pattern').access_at('.*')), literal('foo') =~ var('a'))
       expect(evaluate(expr)).to eq(true)
     end
 
@@ -256,13 +256,13 @@ describe 'Puppet::Pops::Evaluator::EvaluatorImpl' do
     end
 
     it 'should find an entry with compatible type in an Array' do
-      expect(evaluate(fqr('Array')[fqr('Integer')].in(literal(['a', [1,2,3], 'b'])))).to eq(true)
-      expect(evaluate(fqr('Array')[fqr('Integer')].in(literal(['a', [1,2,'not integer'], 'b'])))).to eq(false)
+      expect(evaluate(fqr('Array').access_at(fqr('Integer')).in(literal(['a', [1,2,3], 'b'])))).to eq(true)
+      expect(evaluate(fqr('Array').access_at(fqr('Integer')).in(literal(['a', [1,2,'not integer'], 'b'])))).to eq(false)
     end
 
     it 'should find an entry with compatible type in a Hash' do
       expect(evaluate(fqr('Integer').in(literal({1 => 'a', 'a' => 'b'})))).to eq(true)
-      expect(evaluate(fqr('Integer').in(literal({'a' => 'a', 'a' => 'b'})))).to eq(false)
+      expect(evaluate(fqr('Integer').in(literal({'a' => 'a', 'b' => 'b'})))).to eq(false)
     end
   end
 end

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

@@ -56,7 +56,7 @@ describe 'Puppet::Pops::Evaluator::EvaluatorImpl' do
       "banana::split" => 'banana::split',
       "false"         => false,
       "true"          => true,
-      "Array"         => types.array_of_data(),
+      "Array"         => types.array_of_any,
       "/.*/"          => /.*/
     }.each do |source, result|
         it "should parse and evaluate the expression '#{source}' to #{result}" do
@@ -323,7 +323,7 @@ describe 'Puppet::Pops::Evaluator::EvaluatorImpl' do
                     'Array', 'Hash', 'CatalogEntry', 'Resource', 'Class', 'Undef', 'File' ],
 
       # Note, Data > Collection is false (so not included)
-      'Data'    => ['Scalar', 'Numeric', 'Integer', 'Float', 'Boolean', 'String', 'Pattern', 'Array', 'Hash',],
+      'Data'    => ['ScalarData', 'Numeric', 'Integer', 'Float', 'Boolean', 'String', 'Pattern', 'Array[Data]', 'Hash[String,Data]',],
       'Scalar' => ['Numeric', 'Integer', 'Float', 'Boolean', 'String', 'Pattern'],
       'Numeric' => ['Integer', 'Float'],
       'CatalogEntry' => ['Class', 'Resource', 'File'],
@@ -403,6 +403,11 @@ describe 'Puppet::Pops::Evaluator::EvaluatorImpl' do
     end
 
     context "on strings requiring boxing to Numeric" do
+      let(:logs) { [] }
+      let(:notices) { logs.select { |log| log.level == :notice }.map { |log| log.message } }
+      let(:warnings) { logs.select { |log| log.level == :warning }.map { |log| log.message } }
+      let(:debugs) { logs.select { |log| log.level == :debug }.map { |log| log.message } }
+
       {
         "'2' + '2'"       => 4,
         "'-2' + '2'"      => 0,
@@ -426,6 +431,35 @@ describe 'Puppet::Pops::Evaluator::EvaluatorImpl' do
           end
         end
 
+      {
+        "'2' + 2"       => 2,
+        "'4' - 2"       => 4,
+        "'2' * 2"       => 2,
+        "'2' / 1"       => 2,
+        "'8' >> 1"      => 8,
+        "'4' << 1"      => 4,
+        "'10' % 3"      => 10,
+      }.each do |source, coerced_val|
+          it "should warn about numeric coercion in '#{source}' when strict = warning" do
+            Puppet[:strict] = :warning
+            collect_notices(source)
+            expect(warnings).to include(/The string '#{coerced_val}' was automatically coerced to the numerical value #{coerced_val}/)
+          end
+
+          it "should not warn about numeric coercion in '#{source}' if strict = off" do
+            Puppet[:strict] = :off
+            collect_notices(source)
+            expect(warnings).to_not include(/The string '#{coerced_val}' was automatically coerced to the numerical value #{coerced_val}/)
+          end
+
+        it "should error when finding numeric coercion in '#{source}' if strict = error" do
+          Puppet[:strict] = :error
+          expect { parser.evaluate_string(scope, source, __FILE__) }.to raise_error(
+            /The string '#{coerced_val}' was automatically coerced to the numerical value #{coerced_val}/
+            )
+        end
+      end
+
       {
         "'0888' + '010'"   => :error,
         "'0xWTF' + '010'"  => :error,
@@ -743,11 +777,14 @@ describe 'Puppet::Pops::Evaluator::EvaluatorImpl' do
       end
     end
 
+    # Integer for >= 2.4.0, otherwise Fixnum
+    int_class_name = 0.class.name
+
     # Errors when wrong number/type of keys are used
     {
-      "Array[0]"                    => 'Array-Type[] arguments must be types. Got Fixnum',
-      "Hash[0]"                     => 'Hash-Type[] arguments must be types. Got Fixnum',
-      "Hash[Integer, 0]"            => 'Hash-Type[] arguments must be types. Got Fixnum',
+      "Array[0]"                    => "Array-Type[] arguments must be types. Got #{int_class_name}",
+      "Hash[0]"                     => "Hash-Type[] arguments must be types. Got #{int_class_name}",
+      "Hash[Integer, 0]"            => "Hash-Type[] arguments must be types. Got #{int_class_name}",
       "Array[Integer,1,2,3]"        => 'Array-Type[] accepts 1 to 3 arguments. Got 4',
       "Array[Integer,String]"       => "A Type's size constraint arguments must be a single Integer type, or 1-2 integers (or default). Got a String-Type",
       "Hash[Integer,String, 1,2,3]" => 'Hash-Type[] accepts 2 to 4 arguments. Got 5',
@@ -755,7 +792,7 @@ describe 'Puppet::Pops::Evaluator::EvaluatorImpl' do
       "'abc'[1.0]"                  => "A substring operation does not accept a Float as a character index. Expected an Integer",
       "'abc'[1, x]"                 => "A substring operation does not accept a String as a character index. Expected an Integer",
       "'abc'[1,2,3]"                => "String supports [] with one or two arguments. Got 3",
-      "NotUndef[0]"                 => 'NotUndef-Type[] argument must be a Type or a String. Got Fixnum',
+      "NotUndef[0]"                 => "NotUndef-Type[] argument must be a Type or a String. Got #{int_class_name}",
       "NotUndef[a,b]"               => 'NotUndef-Type[] accepts 0 to 1 arguments. Got 2',
       "Resource[0]"                 => 'First argument to Resource[] must be a resource type or a String. Got Integer',
       "Resource[a, 0]"              => 'Error creating type specialization of a Resource-Type, Cannot use Integer where a resource title String is expected',
@@ -789,7 +826,7 @@ describe 'Puppet::Pops::Evaluator::EvaluatorImpl' do
       it "[n] gets class parameter [n]" do
         source = "class wonka($produces='chocolate'){ }
            include wonka
-           Class[wonka][produces]"
+           Class[wonka]['produces']"
 
         # This is more complicated since it needs to run like 3.x and do an import_ast
         adapted_parser = Puppet::Parser::E4ParserAdapter.new
@@ -1247,6 +1284,15 @@ describe 'Puppet::Pops::Evaluator::EvaluatorImpl' do
       parser.evaluate_string(scope, source, __FILE__)
       expect(scope.compiler).to have_relationship(['File', 'b', '~>', 'File', 'a'])
     end
+
+    it 'should close the gap created by an intermediate empty set' do
+      source = "[File[a], File[aa]] -> [] ~> [File[b], File[bb]]"
+      parser.evaluate_string(scope, source, __FILE__)
+      expect(scope.compiler).to have_relationship(['File', 'a',  '~>', 'File', 'b'])
+      expect(scope.compiler).to have_relationship(['File', 'aa', '~>', 'File', 'b'])
+      expect(scope.compiler).to have_relationship(['File', 'a',  '~>', 'File', 'bb'])
+      expect(scope.compiler).to have_relationship(['File', 'aa', '~>', 'File', 'bb'])
+    end
   end
 
   context "When evaluating heredoc" do
@@ -1466,4 +1512,10 @@ describe 'Puppet::Pops::Evaluator::EvaluatorImpl' do
     end
   end
 
+  def collect_notices(code)
+    Puppet::Util::Log.with_destination(Puppet::Test::LogCollector.new(logs)) do
+      parser.evaluate_string(scope, code, __FILE__)
+    end
+  end
+
 end

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

@@ -24,13 +24,13 @@ module EvaluatorRspecHelper
 
     evaluator = Puppet::Pops::Evaluator::EvaluatorImpl.new
     Puppet.override(:loaders => compiler.loaders) do
-      result = evaluator.evaluate(in_top_scope.current, top_scope)
+      result = evaluator.evaluate(in_top_scope.model, top_scope)
       if in_named_scope
-        other_scope = Puppet::Parser::Scope.new(compiler, :namespace => scopename)
-        result = evaluator.evaluate(in_named_scope.current, other_scope)
+        other_scope = Puppet::Parser::Scope.new(compiler)
+        result = evaluator.evaluate(in_named_scope.model, other_scope)
       end
       if in_top_scope_again
-        result = evaluator.evaluate(in_top_scope_again.current, top_scope)
+        result = evaluator.evaluate(in_top_scope_again.model, top_scope)
       end
       if block_given?
         block.call(top_scope)
@@ -55,16 +55,16 @@ module EvaluatorRspecHelper
 
     evaluator = Puppet::Pops::Evaluator::EvaluatorImpl.new
     Puppet.override(:loaders => compiler.loaders) do
-      result = evaluator.evaluate(in_top_scope.current, top_scope)
+      result = evaluator.evaluate(in_top_scope.model, top_scope)
       if in_local_scope
         # This is really bad in 3.x scope
         top_scope.with_guarded_scope do
           top_scope.new_ephemeral(true)
-          result = evaluator.evaluate(in_local_scope.current, top_scope)
+          result = evaluator.evaluate(in_local_scope.model, top_scope)
         end
       end
       if in_top_scope_again
-        result = evaluator.evaluate(in_top_scope_again.current, top_scope)
+        result = evaluator.evaluate(in_top_scope_again.model, top_scope)
       end
       if block_given?
         block.call(top_scope)

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

@@ -115,7 +115,7 @@ describe 'when converting to 3.x' do
     it 'converts a Timestamp instance to string' do
       c = converter.convert(Puppet::Pops::Time::Timestamp.parse('2016-09-15T12:24:47.193 UTC'), {}, nil)
       expect(c).to be_a(String)
-      expect(c).to eql('2016-09-15T12:24:47.193 UTC')
+      expect(c).to eql('2016-09-15T12:24:47.193000000 UTC')
     end
 
     it 'converts a Binary instance to string' do
@@ -129,5 +129,40 @@ describe 'when converting to 3.x' do
       v = Puppet::Pops::Types::PSensitiveType::Sensitive.new("don't reveal this")
       expect(converter.convert(v, {}, nil)).to equal(v)
     end
+
+    it 'errors if an Integer is too big' do
+      too_big = 0x7fffffffffffffff + 1
+      expect do
+        converter.convert(too_big, {}, nil)
+        end.to raise_error(/Use of a Ruby Integer outside of Puppet Integer max range, got/)
+    end
+
+    it 'errors if an Integer is too small' do
+      too_small = -0x8000000000000000-1
+      expect do
+        converter.convert(too_small, {}, nil)
+      end.to raise_error(/Use of a Ruby Integer outside of Puppet Integer min range, got/)
+    end
+
+    it 'errors if a BigDecimal is out of range for Float' do
+      big_dec = BigDecimal("123456789123456789.1415")
+      expect do
+        converter.convert(big_dec, {}, nil)
+      end.to raise_error(/Use of a Ruby BigDecimal value outside Puppet Float range, got/)
+    end
+
+    it 'BigDecimal values in Float range are converted' do
+      big_dec = BigDecimal("3.1415")
+      f = converter.convert(big_dec, {}, nil)
+      expect(f.class).to be(Float)
+    end
+
+    it 'errors when Integer is out of range in a structure' do
+      structure = {'key' => [{ 'key' => [0x7fffffffffffffff + 1]}]}
+      expect do
+        converter.convert(structure, {}, nil)
+        end.to raise_error(/Use of a Ruby Integer outside of Puppet Integer max range, got/)
+    end
+
   end
 end

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

@@ -13,30 +13,30 @@ describe 'Puppet::Pops::Evaluator::EvaluatorImpl' do
 
   context "When evaluator performs string interpolation" do
     it "should interpolate a bare word as a variable name, \"${var}\"" do
-      a_block = block(var('a').set(10), string('value is ', text(fqn('a')), ' yo'))
-      expect(evaluate(a_block)).to eq("value is 10 yo")
+      a_block = block(var('a').set(literal(10)), string('value is ', text(fqn('a')), ' yo'))
+      expect(evaluate(a_block)).to eq('value is 10 yo')
     end
 
     it "should interpolate a variable in a text expression, \"${$var}\"" do
-      a_block = block(var('a').set(10), string('value is ', text(var(fqn('a'))), ' yo'))
-      expect(evaluate(a_block)).to eq("value is 10 yo")
+      a_block = block(var('a').set(literal(10)), string('value is ', text(var(fqn('a'))), ' yo'))
+      expect(evaluate(a_block)).to eq('value is 10 yo')
     end
 
     it "should interpolate a variable, \"$var\"" do
-      a_block = block(var('a').set(10), string('value is ', var(fqn('a')), ' yo'))
-      expect(evaluate(a_block)).to eq("value is 10 yo")
+      a_block = block(var('a').set(literal(10)), string('value is ', var(fqn('a')), ' yo'))
+      expect(evaluate(a_block)).to eq('value is 10 yo')
     end
 
     it "should interpolate any expression in a text expression, \"${$var*2}\"" do
-      a_block = block(var('a').set(5), string('value is ', text(var(fqn('a')) * 2) , ' yo'))
-      expect(evaluate(a_block)).to eq("value is 10 yo")
+      a_block = block(var('a').set(literal(5)), string('value is ', text(var(fqn('a')) * literal(2)) , ' yo'))
+      expect(evaluate(a_block)).to eq('value is 10 yo')
     end
 
     it "should interpolate any expression without a text expression, \"${$var*2}\"" do
       # there is no concrete syntax for this, but the parser can generate this simpler
       # equivalent form where the expression is not wrapped in a TextExpression
-      a_block = block(var('a').set(5), string('value is ', var(fqn('a')) * 2 , ' yo'))
-      expect(evaluate(a_block)).to eq("value is 10 yo")
+      a_block = block(var('a').set(literal(5)), string('value is ', var(fqn('a')) * literal(2) , ' yo'))
+      expect(evaluate(a_block)).to eq('value is 10 yo')
     end
 
     # TODO: Add function call tests - Pending implementation of calls in the evaluator

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

@@ -46,7 +46,7 @@ describe 'Puppet::Pops::Impl::EvaluatorImpl' do
       end
 
       it "can not change a variable value in same scope" do
-        expect { evaluate_l(block(var('a').set(10), var('a').set(20))) }.to raise_error(/Cannot reassign variable '\$a'/)
+        expect { evaluate_l(block(var('a').set(literal(10)), var('a').set(literal(20)))) }.to raise_error(/Cannot reassign variable '\$a'/)
       end
 
       context "access to numeric variables" do

data/spec/unit/pops/factory_rspec_helper.rb

@@ -21,10 +21,6 @@ module FactoryRspecHelper
     Puppet::Pops::Model::Factory.string(*args)
   end
 
-  def text(x)
-    Puppet::Pops::Model::Factory.text(x)
-  end
-
   def minus(x)
     Puppet::Pops::Model::Factory.minus(x)
   end