puppet 3.8.7 → 4.0.0.rc1

data/spec/unit/pops/containment_spec.rb

@@ -6,12 +6,12 @@ describe Puppet::Pops::Containment do
   include FactoryRspecHelper
 
   it "Should return an Enumerable if eAllContents is called without arguments" do
-    (literal(1) + literal(2)).current.eAllContents.is_a?(Enumerable).should == true
+    expect((literal(1) + literal(2)).current.eAllContents.is_a?(Enumerable)).to eq(true)
   end
 
   it "Should return all content" do
     # Note the top object is not included (an ArithmeticOperation with + operator)
-    (literal(1) + literal(2) + literal(3)).current.eAllContents.collect {|x| x}.size.should == 4
+    expect((literal(1) + literal(2) + literal(3)).current.eAllContents.collect {|x| x}.size).to eq(4)
   end
 
   it "Should return containing feature" do
@@ -20,7 +20,7 @@ describe Puppet::Pops::Containment do
     op = left + right
 
     #pending "eContainingFeature does not work on _uni containments in RGen < 0.6.1"
-    left.current.eContainingFeature.should == :left_expr
-    right.current.eContainingFeature.should == :right_expr
+    expect(left.current.eContainingFeature).to eq(:left_expr)
+    expect(right.current.eContainingFeature).to eq(:right_expr)
   end
 end

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

@@ -123,9 +123,9 @@ describe 'Puppet::Pops::Evaluator::EvaluatorImpl/AccessOperator' do
       expect(evaluate(expr)).to eql(range(1,1))
     end
 
-    it 'gives an error for Integer[from, <from]' do
+    it 'produces an Integer[from, <from]' do
       expr = fqr('Integer')[1,0]
-      expect{evaluate(expr)}.to raise_error(/'from' must be less or equal to 'to'/)
+      expect(evaluate(expr)).to eql(range(1,0))
     end
 
     it 'produces an error for Integer[] if there are more than 2 keys' do
@@ -154,9 +154,9 @@ describe 'Puppet::Pops::Evaluator::EvaluatorImpl/AccessOperator' do
       expect(evaluate(expr)).to eql(float_range(1.0,1.0))
     end
 
-    it 'gives an error for Float[from, <from]' do
+    it 'produces a Float[from, <from]' do
       expr = fqr('Float')[1.0,0.0]
-      expect{evaluate(expr)}.to raise_error(/'from' must be less or equal to 'to'/)
+      expect(evaluate(expr)).to eql(float_range(1.0,0.0))
     end
 
     it 'produces an error for Float[] if there are more than 2 keys' do
@@ -400,25 +400,6 @@ describe 'Puppet::Pops::Evaluator::EvaluatorImpl/AccessOperator' do
       expect {evaluate(expr)}.to raise_error(/Resource not found: File\['x'\]/)
     end
 
-    # NotUndef Type
-    #
-    it 'produces a NotUndef instance' do
-      type_expr = fqr('NotUndef')
-      expect(evaluate(type_expr)).to eql(Puppet::Pops::Types::TypeFactory.not_undef())
-    end
-
-    it 'produces a NotUndef instance with contained type' do
-      type_expr = fqr('NotUndef')[fqr('Integer')]
-      tf = Puppet::Pops::Types::TypeFactory
-      expect(evaluate(type_expr)).to eql(tf.not_undef(tf.integer))
-    end
-
-    it 'produces a NotUndef instance with String type when given a literal String' do
-      type_expr = fqr('NotUndef')[literal('hey')]
-      tf = Puppet::Pops::Types::TypeFactory
-      expect(evaluate(type_expr)).to eql(tf.not_undef(tf.string('hey')))
-    end
-
     # Type Type
     #
     it 'creates a Type instance when applied to a Type' do
@@ -452,7 +433,7 @@ describe 'Puppet::Pops::Evaluator::EvaluatorImpl/AccessOperator' do
       calc.assignable?(actual, type) && calc.assignable?(type, actual)
     end
 
-    failure_message_for_should do |actual|
+    failure_message do |actual|
       "expected #{type.to_s}, but was #{actual.to_s}"
     end
   end

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

@@ -13,27 +13,27 @@ describe 'Puppet::Pops::Evaluator::EvaluatorImpl' do
 
   context "When the evaluator performs arithmetic" do
     context "on Integers" do
-      it "2 + 2  ==  4"   do; evaluate(literal(2) + literal(2)).should == 4 ; end
-      it "7 - 3  ==  4"   do; evaluate(literal(7) - literal(3)).should == 4 ; end
-      it "6 * 3  ==  18"  do; evaluate(literal(6) * literal(3)).should == 18; end
-      it "6 / 3  ==  2"   do; evaluate(literal(6) / literal(3)).should == 2 ; end
-      it "6 % 3  ==  0"   do; evaluate(literal(6) % literal(3)).should == 0 ; end
-      it "10 % 3 ==  1"   do; evaluate(literal(10) % literal(3)).should == 1; end
-      it "-(6/3) == -2"   do; evaluate(minus(literal(6) / literal(3))).should == -2 ; end
-      it "-6/3   == -2"   do; evaluate(minus(literal(6)) / literal(3)).should == -2 ; end
-      it "8 >> 1 == 4"    do; evaluate(literal(8) >> literal(1)).should == 4 ; end
-      it "8 << 1 == 16"   do; evaluate(literal(8) << literal(1)).should == 16; end
-      it "8 >> -1 == 16"    do; evaluate(literal(8) >> literal(-1)).should == 16 ; end
-      it "8 << -1 == 4"   do; evaluate(literal(8) << literal(-1)).should == 4; end
+      it "2 + 2  ==  4"   do; expect(evaluate(literal(2) + literal(2))).to eq(4) ; end
+      it "7 - 3  ==  4"   do; expect(evaluate(literal(7) - literal(3))).to eq(4) ; end
+      it "6 * 3  ==  18"  do; expect(evaluate(literal(6) * literal(3))).to eq(18); end
+      it "6 / 3  ==  2"   do; expect(evaluate(literal(6) / literal(3))).to eq(2) ; end
+      it "6 % 3  ==  0"   do; expect(evaluate(literal(6) % literal(3))).to eq(0) ; end
+      it "10 % 3 ==  1"   do; expect(evaluate(literal(10) % literal(3))).to eq(1); end
+      it "-(6/3) == -2"   do; expect(evaluate(minus(literal(6) / literal(3)))).to eq(-2) ; end
+      it "-6/3   == -2"   do; expect(evaluate(minus(literal(6)) / literal(3))).to eq(-2) ; end
+      it "8 >> 1 == 4"    do; expect(evaluate(literal(8) >> literal(1))).to eq(4) ; end
+      it "8 << 1 == 16"   do; expect(evaluate(literal(8) << literal(1))).to eq(16); end
+      it "8 >> -1 == 16"    do; expect(evaluate(literal(8) >> literal(-1))).to eq(16) ; end
+      it "8 << -1 == 4"   do; expect(evaluate(literal(8) << literal(-1))).to eq(4); end
     end
 
     context "on Floats" do
-      it "2.2 + 2.2  ==  4.4"   do; evaluate(literal(2.2) + literal(2.2)).should == 4.4  ; end
-      it "7.7 - 3.3  ==  4.4"   do; evaluate(literal(7.7) - literal(3.3)).should == 4.4  ; end
-      it "6.1 * 3.1  ==  18.91" do; evaluate(literal(6.1) * literal(3.1)).should == 18.91; end
-      it "6.6 / 3.3  ==  2.0"   do; evaluate(literal(6.6) / literal(3.3)).should == 2.0  ; end
-      it "-(6.0/3.0) == -2.0"   do; evaluate(minus(literal(6.0) / literal(3.0))).should == -2.0; end
-      it "-6.0/3.0   == -2.0"   do; evaluate(minus(literal(6.0)) / literal(3.0)).should == -2.0; end
+      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
+      it "6.1 * 3.1  ==  18.91" do; expect(evaluate(literal(6.1) * literal(3.1))).to eq(18.91); end
+      it "6.6 / 3.3  ==  2.0"   do; expect(evaluate(literal(6.6) / literal(3.3))).to eq(2.0)  ; end
+      it "-(6.0/3.0) == -2.0"   do; expect(evaluate(minus(literal(6.0) / literal(3.0)))).to eq(-2.0); end
+      it "-6.0/3.0   == -2.0"   do; expect(evaluate(minus(literal(6.0)) / literal(3.0))).to eq(-2.0); end
       it "6.6 % 3.3  ==  0.0"   do; expect { evaluate(literal(6.6) % literal(3.3))}.to raise_error(Puppet::ParseError); end
         it "10.0 % 3.0 ==  1.0"   do; expect { evaluate(literal(10.0) % literal(3.0))}.to raise_error(Puppet::ParseError); end
       it "3.14 << 2  == error"  do; expect { evaluate(literal(3.14) << literal(2))}.to raise_error(Puppet::ParseError); end
@@ -42,19 +42,19 @@ describe 'Puppet::Pops::Evaluator::EvaluatorImpl' do
 
     context "on strings requiring boxing to Numeric" do
       it "'2' + '2'        ==  4" do
-        evaluate(literal('2') + literal('2')).should == 4
+        expect(evaluate(literal('2') + literal('2'))).to eq(4)
       end
 
       it "'2.2' + '2.2'    ==  4.4" do
-        evaluate(literal('2.2') + literal('2.2')).should == 4.4
+        expect(evaluate(literal('2.2') + literal('2.2'))).to eq(4.4)
       end
 
       it "'0xF7' + '0x8'   ==  0xFF" do
-        evaluate(literal('0xF7') + literal('0x8')).should == 0xFF
+        expect(evaluate(literal('0xF7') + literal('0x8'))).to eq(0xFF)
       end
 
       it "'0367' + '010'   ==  0xFF" do
-        evaluate(literal('0367') + literal('010')).should == 0xFF
+        expect(evaluate(literal('0367') + literal('010'))).to eq(0xFF)
       end
 
       it "'0888' + '010'   ==  error" do
@@ -70,7 +70,7 @@ describe 'Puppet::Pops::Evaluator::EvaluatorImpl' do
       end
 
       it "'012.3' + '010'  ==  20.3 (not error, floats can start with 0)" do
-        evaluate(literal('012.3') + literal('010')).should == 20.3
+        expect(evaluate(literal('012.3') + literal('010'))).to eq(20.3)
       end
     end
   end

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

@@ -13,91 +13,91 @@ describe 'Puppet::Pops::Evaluator::EvaluatorImpl' do
 
   context "When the evaluator evaluates literals" do
     it 'should evaluator numbers to numbers' do
-      evaluate(literal(1)).should == 1
-      evaluate(literal(3.14)).should == 3.14
+      expect(evaluate(literal(1))).to eq(1)
+      expect(evaluate(literal(3.14))).to eq(3.14)
     end
 
     it 'should evaluate strings to string' do
-      evaluate(literal('banana')).should == 'banana'
+      expect(evaluate(literal('banana'))).to eq('banana')
     end
 
     it 'should evaluate booleans to booleans' do
-      evaluate(literal(false)).should == false
-      evaluate(literal(true)).should == true
+      expect(evaluate(literal(false))).to eq(false)
+      expect(evaluate(literal(true))).to eq(true)
     end
 
     it 'should evaluate names to strings' do
-      evaluate(fqn('banana')).should == 'banana'
+      expect(evaluate(fqn('banana'))).to eq('banana')
     end
 
     it 'should evaluator types to types' do
       array_type = Puppet::Pops::Types::PArrayType.new()
       array_type.element_type = Puppet::Pops::Types::PDataType.new()
-      evaluate(fqr('Array')).should == array_type
+      expect(evaluate(fqr('Array'))).to eq(array_type)
     end
   end
 
   context "When the evaluator evaluates Lists" do
     it "should create an Array when evaluating a LiteralList" do
-      evaluate(literal([1,2,3])).should == [1,2,3]
+      expect(evaluate(literal([1,2,3]))).to eq([1,2,3])
     end
 
     it "[...[...[]]] should create nested arrays without trouble" do
-      evaluate(literal([1,[2.0, 2.1, [2.2]],[3.0, 3.1]])).should == [1,[2.0, 2.1, [2.2]],[3.0, 3.1]]
+      expect(evaluate(literal([1,[2.0, 2.1, [2.2]],[3.0, 3.1]]))).to eq([1,[2.0, 2.1, [2.2]],[3.0, 3.1]])
     end
 
     it "[2 + 2] should evaluate expressions in entries" do
       x = literal([literal(2) + literal(2)]);
-      Puppet::Pops::Model::ModelTreeDumper.new.dump(x).should == "([] (+ 2 2))"
-      evaluate(x)[0].should == 4
+      expect(Puppet::Pops::Model::ModelTreeDumper.new.dump(x)).to eq("([] (+ 2 2))")
+      expect(evaluate(x)[0]).to eq(4)
     end
 
     it "[1,2,3] == [1,2,3] == true" do
-      evaluate(literal([1,2,3]) == literal([1,2,3])).should == true;
+      expect(evaluate(literal([1,2,3]) == literal([1,2,3]))).to eq(true);
     end
 
     it "[1,2,3] != [2,3,4] == true" do
-      evaluate(literal([1,2,3]).ne(literal([2,3,4]))).should == true;
+      expect(evaluate(literal([1,2,3]).ne(literal([2,3,4])))).to eq(true);
     end
 
     it "[1, 2, 3][2] == 3" do
-      evaluate(literal([1,2,3])[2]).should == 3
+      expect(evaluate(literal([1,2,3])[2])).to eq(3)
     end
   end
 
   context "When the evaluator evaluates Hashes" do
     it "should create a  Hash when evaluating a LiteralHash" do
-      evaluate(literal({'a'=>1,'b'=>2})).should == {'a'=>1,'b'=>2}
+      expect(evaluate(literal({'a'=>1,'b'=>2}))).to eq({'a'=>1,'b'=>2})
     end
 
     it "{...{...{}}} should create nested hashes without trouble" do
-      evaluate(literal({'a'=>1,'b'=>{'x'=>2.1,'y'=>2.2}})).should == {'a'=>1,'b'=>{'x'=>2.1,'y'=>2.2}}
+      expect(evaluate(literal({'a'=>1,'b'=>{'x'=>2.1,'y'=>2.2}}))).to eq({'a'=>1,'b'=>{'x'=>2.1,'y'=>2.2}})
     end
 
     it "{'a'=> 2 + 2} should evaluate values in entries" do
-      evaluate(literal({'a'=> literal(2) + literal(2)}))['a'].should == 4
+      expect(evaluate(literal({'a'=> literal(2) + literal(2)}))['a']).to eq(4)
     end
 
     it "{'a'=> 1, 'b'=>2} == {'a'=> 1, 'b'=>2} == true" do
-      evaluate(literal({'a'=> 1, 'b'=>2}) == literal({'a'=> 1, 'b'=>2})).should == true;
+      expect(evaluate(literal({'a'=> 1, 'b'=>2}) == literal({'a'=> 1, 'b'=>2}))).to eq(true);
     end
 
     it "{'a'=> 1, 'b'=>2} != {'x'=> 1, 'y'=>3} == true" do
-      evaluate(literal({'a'=> 1, 'b'=>2}).ne(literal({'x'=> 1, 'y'=>3}))).should == true;
+      expect(evaluate(literal({'a'=> 1, 'b'=>2}).ne(literal({'x'=> 1, 'y'=>3})))).to eq(true);
     end
 
     it "{'a' => 1, 'b' => 2}['b'] == 2" do
-      evaluate(literal({:a => 1, :b => 2})[:b]).should == 2
+      expect(evaluate(literal({:a => 1, :b => 2})[:b])).to eq(2)
     end
   end
 
   context 'When the evaluator evaluates a Block' do
     it 'an empty block evaluates to nil' do
-      evaluate(block()).should == nil
+      expect(evaluate(block())).to eq(nil)
     end
 
     it 'a block evaluates to its last expression' do
-      evaluate(block(literal(1), literal(2))).should == 2
+      expect(evaluate(block(literal(1), literal(2)))).to eq(2)
     end
   end
 end

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

@@ -22,9 +22,7 @@ describe 'Puppet::Pops::Evaluator::EvaluatorImpl/Concat/Delete' do
     end
 
     it 'concatenates a hash by converting it to array' do
-      # use match_array here since a hash does not have specified order and this
-      # hash has different order on Ruby 1.8.7, and 1.9.3.
-      expect(evaluate(literal([1,2,3]) + literal({'a' => 1, 'b'=>2}))).to match_array([1,2,3,['a',1],['b',2]])
+      expect(evaluate(literal([1,2,3]) + literal({'a' => 1, 'b'=>2}))).to eql([1,2,3,['a',1],['b',2]])
     end
 
     it 'concatenates a non array value with +' do

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

@@ -14,69 +14,69 @@ describe 'Puppet::Pops::Evaluator::EvaluatorImpl' do
   context "When the evaluator performs comparisons" do
 
     context "of string values" do
-      it "'a' == 'a' == true"  do; evaluate(literal('a') == literal('a')).should == true   ; end
-      it "'a' == 'b' == false" do; evaluate(literal('a') == literal('b')).should == false  ; end
-      it "'a' != 'a' == false" do; evaluate(literal('a').ne(literal('a'))).should == false ; end
-      it "'a' != 'b' == true"  do; evaluate(literal('a').ne(literal('b'))).should == true  ; end
+      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' == 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
 
-      it "'a' < 'b'  == true"  do; evaluate(literal('a')  < literal('b')).should == true   ; end
-      it "'a' < 'a'  == false" do; evaluate(literal('a')  < literal('a')).should == false  ; end
-      it "'b' < 'a'  == false" do; evaluate(literal('b')  < literal('a')).should == false  ; end
+      it "'a' < 'b'  == true"  do; expect(evaluate(literal('a')  < literal('b'))).to eq(true)   ; end
+      it "'a' < 'a'  == false" do; expect(evaluate(literal('a')  < literal('a'))).to eq(false)  ; end
+      it "'b' < 'a'  == false" do; expect(evaluate(literal('b')  < literal('a'))).to eq(false)  ; end
 
-      it "'a' <= 'b' == true"  do; evaluate(literal('a')  <= literal('b')).should == true  ; end
-      it "'a' <= 'a' == true"  do; evaluate(literal('a')  <= literal('a')).should == true  ; end
-      it "'b' <= 'a' == false" do; evaluate(literal('b')  <= literal('a')).should == false ; end
+      it "'a' <= 'b' == true"  do; expect(evaluate(literal('a')  <= literal('b'))).to eq(true)  ; end
+      it "'a' <= 'a' == true"  do; expect(evaluate(literal('a')  <= literal('a'))).to eq(true)  ; end
+      it "'b' <= 'a' == false" do; expect(evaluate(literal('b')  <= literal('a'))).to eq(false) ; end
 
-      it "'a' > 'b'  == false" do; evaluate(literal('a')  > literal('b')).should == false  ; end
-      it "'a' > 'a'  == false" do; evaluate(literal('a')  > literal('a')).should == false  ; end
-      it "'b' > 'a'  == true"  do; evaluate(literal('b')  > literal('a')).should == true   ; end
+      it "'a' > 'b'  == false" do; expect(evaluate(literal('a')  > literal('b'))).to eq(false)  ; end
+      it "'a' > 'a'  == false" do; expect(evaluate(literal('a')  > literal('a'))).to eq(false)  ; end
+      it "'b' > 'a'  == true"  do; expect(evaluate(literal('b')  > literal('a'))).to eq(true)   ; end
 
-      it "'a' >= 'b' == false" do; evaluate(literal('a')  >= literal('b')).should == false ; end
-      it "'a' >= 'a' == true"  do; evaluate(literal('a')  >= literal('a')).should == true  ; end
-      it "'b' >= 'a' == true"  do; evaluate(literal('b')  >= literal('a')).should == 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')  >= literal('a'))).to eq(true)  ; end
+      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; evaluate(literal('a') == literal('A')).should == true   ; end
-        it "'a' != 'A' == false"   do; evaluate(literal('a').ne(literal('A'))).should == false ; end
-        it "'a' >  'A' == false"   do; evaluate(literal('a') > literal('A')).should == false   ; end
-        it "'a' >= 'A' == true"    do; evaluate(literal('a') >= literal('A')).should == true   ; end
-        it "'A' <  'a' == false"   do; evaluate(literal('A') < literal('a')).should == false   ; end
-        it "'A' <= 'a' == true"    do; evaluate(literal('A') <= literal('a')).should == true  ; 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').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
       end
     end
 
     context "of integer values" do
-      it "1 == 1 == true"  do; evaluate(literal(1) == literal(1)).should == true   ; end
-      it "1 == 2 == false" do; evaluate(literal(1) == literal(2)).should == false  ; end
-      it "1 != 1 == false" do; evaluate(literal(1).ne(literal(1))).should == false ; end
-      it "1 != 2 == true"  do; evaluate(literal(1).ne(literal(2))).should == true  ; end
-
-      it "1 < 2  == true"  do; evaluate(literal(1)  < literal(2)).should == true   ; end
-      it "1 < 1  == false" do; evaluate(literal(1)  < literal(1)).should == false  ; end
-      it "2 < 1  == false" do; evaluate(literal(2)  < literal(1)).should == false  ; end
-
-      it "1 <= 2 == true"  do; evaluate(literal(1)  <= literal(2)).should == true  ; end
-      it "1 <= 1 == true"  do; evaluate(literal(1)  <= literal(1)).should == true  ; end
-      it "2 <= 1 == false" do; evaluate(literal(2)  <= literal(1)).should == false ; end
-
-      it "1 > 2  == false" do; evaluate(literal(1)  > literal(2)).should == false  ; end
-      it "1 > 1  == false" do; evaluate(literal(1)  > literal(1)).should == false  ; end
-      it "2 > 1  == true"  do; evaluate(literal(2)  > literal(1)).should == true   ; end
-
-      it "1 >= 2 == false" do; evaluate(literal(1)  >= literal(2)).should == false ; end
-      it "1 >= 1 == true"  do; evaluate(literal(1)  >= literal(1)).should == true  ; end
-      it "2 >= 1 == true"  do; evaluate(literal(2)  >= literal(1)).should == true  ; end
+      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 == 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
+
+      it "1 < 2  == true"  do; expect(evaluate(literal(1)  < literal(2))).to eq(true)   ; end
+      it "1 < 1  == false" do; expect(evaluate(literal(1)  < literal(1))).to eq(false)  ; end
+      it "2 < 1  == false" do; expect(evaluate(literal(2)  < literal(1))).to eq(false)  ; end
+
+      it "1 <= 2 == true"  do; expect(evaluate(literal(1)  <= literal(2))).to eq(true)  ; end
+      it "1 <= 1 == true"  do; expect(evaluate(literal(1)  <= literal(1))).to eq(true)  ; end
+      it "2 <= 1 == false" do; expect(evaluate(literal(2)  <= literal(1))).to eq(false) ; end
+
+      it "1 > 2  == false" do; expect(evaluate(literal(1)  > literal(2))).to eq(false)  ; end
+      it "1 > 1  == false" do; expect(evaluate(literal(1)  > literal(1))).to eq(false)  ; end
+      it "2 > 1  == true"  do; expect(evaluate(literal(2)  > 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)  >= literal(1))).to eq(true)  ; end
+      it "2 >= 1 == true"  do; expect(evaluate(literal(2)  >= literal(1))).to eq(true)  ; end
     end
 
     context "of mixed value types" do
-      it "1 == 1.0  == true"   do; evaluate(literal(1)     == literal(1.0)).should == true   ; end
-      it "1 < 1.1   == true"   do; evaluate(literal(1)     <  literal(1.1)).should == true   ; end
-      it "1.0 == 1  == true"   do; evaluate(literal(1.0)   == literal(1)).should == true     ; end
-      it "1.0 < 2   == true"   do; evaluate(literal(1.0)   <  literal(2)).should == true     ; end
-      it "'1.0' < 'a' == true" do; evaluate(literal('1.0') <  literal('a')).should == true   ; end
-      it "'1.0' < ''  == true" do; evaluate(literal('1.0') <  literal('')).should == false   ; end
-      it "'1.0' < ' ' == true" do; evaluate(literal('1.0') <  literal(' ')).should == false   ; end
-      it "'a' > '1.0' == true" do; evaluate(literal('a')   >  literal('1.0')).should == true ; end
+      it "1 == 1.0  == true"   do; expect(evaluate(literal(1)     == 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 < 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 "'a' > '1.0' == true" do; expect(evaluate(literal('a')   >  literal('1.0'))).to eq(true) ; end
     end
 
     context "of unsupported mixed value types" do
@@ -86,39 +86,36 @@ describe 'Puppet::Pops::Evaluator::EvaluatorImpl' do
       it "'1.0' < 1.1 == true" do
         expect{evaluate(literal('1.0') <  literal(1.1))}.to raise_error(/String < Float/)
       end
-      it "undef < 1.1 == true" do
-        expect{evaluate(literal(nil) <  literal(1.1))}.to raise_error(/Undef Value < Float/)
-      end
     end
 
     context "of regular expressions" do
-      it "/.*/ == /.*/  == true"   do; evaluate(literal(/.*/) == literal(/.*/)).should == true   ; end
-      it "/.*/ != /a.*/ == true"   do; evaluate(literal(/.*/).ne(literal(/a.*/))).should == true ; end
+      it "/.*/ == /.*/  == true"   do; expect(evaluate(literal(/.*/) == 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; evaluate(literal(true) == literal(true)).should == true  ; end;
-      it "false == false == true"    do; evaluate(literal(false) == literal(false)).should == true ; end;
-      it "true == false  != true"    do; evaluate(literal(true) == literal(false)).should == false ; end;
-      it "false  == ''  == false"    do; evaluate(literal(false) == literal('')).should == false  ; end;
-      it "undef  == ''  == false"    do; evaluate(literal(:undef) == literal('')).should == false  ; end;
-      it "undef  == undef  == true"  do; evaluate(literal(:undef) == literal(:undef)).should == true  ; end;
-      it "nil    == undef  == true"  do; evaluate(literal(nil) == literal(:undef)).should == true  ; end;
+      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;
     end
 
     context "of collections" do
       it "[1,2,3] == [1,2,3] == true" do
-        evaluate(literal([1,2,3]) == literal([1,2,3])).should == true
-        evaluate(literal([1,2,3]).ne(literal([1,2,3]))).should == false
-        evaluate(literal([1,2,4]) == literal([1,2,3])).should == false
-        evaluate(literal([1,2,4]).ne(literal([1,2,3]))).should == true
+        expect(evaluate(literal([1,2,3]) == 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]).ne(literal([1,2,3])))).to eq(true)
       end
 
       it "{'a'=>1, 'b'=>2} == {'a'=>1, 'b'=>2} == true" do
-        evaluate(literal({'a'=>1, 'b'=>2}) == literal({'a'=>1, 'b'=>2})).should == true
-        evaluate(literal({'a'=>1, 'b'=>2}).ne(literal({'a'=>1, 'b'=>2}))).should == false
-        evaluate(literal({'a'=>1, 'b'=>2}) == literal({'x'=>1, 'b'=>2})).should == false
-        evaluate(literal({'a'=>1, 'b'=>2}).ne(literal({'x'=>1, 'b'=>2}))).should == true
+        expect(evaluate(literal({'a'=>1, 'b'=>2}) == 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}).ne(literal({'x'=>1, 'b'=>2})))).to eq(true)
       end
     end
 
@@ -169,18 +166,18 @@ describe 'Puppet::Pops::Evaluator::EvaluatorImpl' do
   end
 
   context "When the evaluator performs Regular Expression matching" do
-    it "'a' =~ /.*/   == true"    do; evaluate(literal('a') =~ literal(/.*/)).should == true     ; end
-    it "'a' =~ '.*'   == true"    do; evaluate(literal('a') =~ literal(".*")).should == true     ; end
-    it "'a' !~ /b.*/  == true"    do; evaluate(literal('a').mne(literal(/b.*/))).should == true  ; end
-    it "'a' !~ 'b.*'  == true"    do; evaluate(literal('a').mne(literal("b.*"))).should == true  ; end
+    it "'a' =~ /.*/   == true"    do; expect(evaluate(literal('a') =~ literal(/.*/))).to eq(true)     ; end
+    it "'a' =~ '.*'   == true"    do; expect(evaluate(literal('a') =~ literal(".*"))).to eq(true)     ; end
+    it "'a' !~ /b.*/  == true"    do; expect(evaluate(literal('a').mne(literal(/b.*/)))).to eq(true)  ; end
+    it "'a' !~ 'b.*'  == true"    do; expect(evaluate(literal('a').mne(literal("b.*")))).to eq(true)  ; end
 
     it "'a' =~ Pattern['.*'] == true"    do
-      evaluate(literal('a') =~ fqr('Pattern')[literal(".*")]).should == true
+      expect(evaluate(literal('a') =~ fqr('Pattern')[literal(".*")])).to eq(true)
     end
 
     it "$a = Pattern['.*']; 'a' =~ $a  == true"    do
       expr = block(var('a').set(fqr('Pattern')['foo']), literal('foo') =~ var('a'))
-      evaluate(expr).should == true
+      expect(evaluate(expr)).to eq(true)
     end
 
     it 'should fail if LHS is not a string' do
@@ -190,79 +187,79 @@ describe 'Puppet::Pops::Evaluator::EvaluatorImpl' do
 
   context "When evaluator evaluates the 'in' operator" do
     it "should find elements in an array" do
-      evaluate(literal(1).in(literal([1,2,3]))).should == true
-      evaluate(literal(4).in(literal([1,2,3]))).should == false
+      expect(evaluate(literal(1).in(literal([1,2,3])))).to eq(true)
+      expect(evaluate(literal(4).in(literal([1,2,3])))).to eq(false)
     end
 
     it "should find keys in a hash" do
-      evaluate(literal('a').in(literal({'x'=>1, 'a'=>2, 'y'=> 3}))).should == true
-      evaluate(literal('z').in(literal({'x'=>1, 'a'=>2, 'y'=> 3}))).should == false
+      expect(evaluate(literal('a').in(literal({'x'=>1, 'a'=>2, 'y'=> 3})))).to eq(true)
+      expect(evaluate(literal('z').in(literal({'x'=>1, 'a'=>2, 'y'=> 3})))).to eq(false)
     end
 
     it "should find substrings in a string" do
-      evaluate(literal('ana').in(literal('bananas'))).should == true
-      evaluate(literal('xxx').in(literal('bananas'))).should == false
+      expect(evaluate(literal('ana').in(literal('bananas')))).to eq(true)
+      expect(evaluate(literal('xxx').in(literal('bananas')))).to eq(false)
     end
 
     it "should find substrings in a string (regexp)" do
-      evaluate(literal(/ana/).in(literal('bananas'))).should == true
-      evaluate(literal(/xxx/).in(literal('bananas'))).should == false
+      expect(evaluate(literal(/ana/).in(literal('bananas')))).to eq(true)
+      expect(evaluate(literal(/xxx/).in(literal('bananas')))).to eq(false)
     end
 
     it "should find substrings in a string (ignoring case)" do
-      evaluate(literal('ANA').in(literal('bananas'))).should == true
-      evaluate(literal('ana').in(literal('BANANAS'))).should == true
-      evaluate(literal('xxx').in(literal('BANANAS'))).should == false
+      expect(evaluate(literal('ANA').in(literal('bananas')))).to eq(true)
+      expect(evaluate(literal('ana').in(literal('BANANAS')))).to eq(true)
+      expect(evaluate(literal('xxx').in(literal('BANANAS')))).to eq(false)
     end
 
     it "should find sublists in a list" do
-      evaluate(literal([2,3]).in(literal([1,[2,3],4]))).should == true
-      evaluate(literal([2,4]).in(literal([1,[2,3],4]))).should == false
+      expect(evaluate(literal([2,3]).in(literal([1,[2,3],4])))).to eq(true)
+      expect(evaluate(literal([2,4]).in(literal([1,[2,3],4])))).to eq(false)
     end
 
     it "should find sublists in a list (case insensitive)" do
-      evaluate(literal(['a','b']).in(literal(['A',['A','B'],'C']))).should == true
-      evaluate(literal(['x','y']).in(literal(['A',['A','B'],'C']))).should == false
+      expect(evaluate(literal(['a','b']).in(literal(['A',['A','B'],'C'])))).to eq(true)
+      expect(evaluate(literal(['x','y']).in(literal(['A',['A','B'],'C'])))).to eq(false)
     end
 
     it "should find keys in a hash" do
-      evaluate(literal('a').in(literal({'a' => 10, 'b' => 20}))).should == true
-      evaluate(literal('x').in(literal({'a' => 10, 'b' => 20}))).should == false
+      expect(evaluate(literal('a').in(literal({'a' => 10, 'b' => 20})))).to eq(true)
+      expect(evaluate(literal('x').in(literal({'a' => 10, 'b' => 20})))).to eq(false)
     end
 
     it "should find keys in a hash (case insensitive)" do
-      evaluate(literal('A').in(literal({'a' => 10, 'b' => 20}))).should == true
-      evaluate(literal('X').in(literal({'a' => 10, 'b' => 20}))).should == false
+      expect(evaluate(literal('A').in(literal({'a' => 10, 'b' => 20})))).to eq(true)
+      expect(evaluate(literal('X').in(literal({'a' => 10, 'b' => 20})))).to eq(false)
     end
 
     it "should find keys in a hash (regexp)" do
-      evaluate(literal(/xxx/).in(literal({'abcxxxabc' => 10, 'xyz' => 20}))).should == true
-      evaluate(literal(/yyy/).in(literal({'abcxxxabc' => 10, 'xyz' => 20}))).should == false
+      expect(evaluate(literal(/xxx/).in(literal({'abcxxxabc' => 10, 'xyz' => 20})))).to eq(true)
+      expect(evaluate(literal(/yyy/).in(literal({'abcxxxabc' => 10, 'xyz' => 20})))).to eq(false)
     end
 
     it "should find numbers as numbers" do
-      evaluate(literal(15).in(literal([1,0xf,2]))).should == true
+      expect(evaluate(literal(15).in(literal([1,0xf,2])))).to eq(true)
     end
 
     it "should not find numbers as strings" do
-      evaluate(literal(15).in(literal([1, '0xf',2]))).should == false
-      evaluate(literal('15').in(literal([1, 0xf,2]))).should == false
+      expect(evaluate(literal(15).in(literal([1, '0xf',2])))).to eq(false)
+      expect(evaluate(literal('15').in(literal([1, 0xf,2])))).to eq(false)
     end
 
     it "should not find numbers embedded in strings, nor digits in numbers" do
-      evaluate(literal(15).in(literal([1, '115', 2]))).should == false
-      evaluate(literal(1).in(literal([11, 111, 2]))).should == false
-      evaluate(literal('1').in(literal([11, 111, 2]))).should == false
+      expect(evaluate(literal(15).in(literal([1, '115', 2])))).to eq(false)
+      expect(evaluate(literal(1).in(literal([11, 111, 2])))).to eq(false)
+      expect(evaluate(literal('1').in(literal([11, 111, 2])))).to eq(false)
     end
 
     it 'should find an entry with compatible type in an Array' do
-      evaluate(fqr('Array')[fqr('Integer')].in(literal(['a', [1,2,3], 'b']))).should == true
-      evaluate(fqr('Array')[fqr('Integer')].in(literal(['a', [1,2,'not integer'], 'b']))).should == false
+      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)
     end
 
     it 'should find an entry with compatible type in a Hash' do
-      evaluate(fqr('Integer').in(literal({1 => 'a', 'a' => 'b'}))).should == true
-      evaluate(fqr('Integer').in(literal({'a' => 'a', 'a' => 'b'}))).should == false
+      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)
     end
   end
 end