diff --git a/lib/puppet/pops/validation/checker4_0.rb b/lib/puppet/pops/validation/checker4_0.rb
index 85bbb0016..a03e4b0f1 100644
--- a/lib/puppet/pops/validation/checker4_0.rb
+++ b/lib/puppet/pops/validation/checker4_0.rb
@@ -1,539 +1,503 @@
 # A Validator validates a model.
 #
 # Validation is performed on each model element in isolation. Each method should validate the model element's state
 # but not validate its referenced/contained elements except to check their validity in their respective role.
 # The intent is to drive the validation with a tree iterator that visits all elements in a model.
 #
 #
 # TODO: Add validation of multiplicities - this is a general validation that can be checked for all
 #       Model objects via their metamodel. (I.e an extra call to multiplicity check in polymorph check).
 #       This is however mostly valuable when validating model to model transformations, and is therefore T.B.D
 #
 class Puppet::Pops::Validation::Checker4_0
   Issues = Puppet::Pops::Issues
   Model = Puppet::Pops::Model
 
   attr_reader :acceptor
   # Initializes the validator with a diagnostics producer. This object must respond to
   # `:will_accept?` and `:accept`.
   #
   def initialize(diagnostics_producer)
     @@check_visitor       ||= Puppet::Pops::Visitor.new(nil, "check", 0, 0)
     @@rvalue_visitor      ||= Puppet::Pops::Visitor.new(nil, "rvalue", 0, 0)
     @@hostname_visitor    ||= Puppet::Pops::Visitor.new(nil, "hostname", 1, 2)
     @@assignment_visitor  ||= Puppet::Pops::Visitor.new(nil, "assign", 0, 1)
     @@query_visitor       ||= Puppet::Pops::Visitor.new(nil, "query", 0, 0)
     @@top_visitor         ||= Puppet::Pops::Visitor.new(nil, "top", 1, 1)
-    @@relation_visitor    ||= Puppet::Pops::Visitor.new(nil, "relation", 1, 1)
 
     @acceptor = diagnostics_producer
   end
 
   # Validates the entire model by visiting each model element and calling `check`.
   # The result is collected (or acted on immediately) by the configured diagnostic provider/acceptor
   # given when creating this Checker.
   #
   def validate(model)
     # tree iterate the model, and call check for each element
     check(model)
     model.eAllContents.each {|m| check(m) }
   end
 
   # Performs regular validity check
   def check(o)
     @@check_visitor.visit_this_0(self, o)
   end
 
   # Performs check if this is a vaid hostname expression
   # @param single_feature_name [String, nil] the name of a single valued hostname feature of the value's container. e.g. 'parent'
   def hostname(o, semantic, single_feature_name = nil)
     @@hostname_visitor.visit_this_2(self, o, semantic, single_feature_name)
   end
 
   # Performs check if this is valid as a query
   def query(o)
     @@query_visitor.visit_this_0(self, o)
   end
 
-  # Performs check if this is valid as a relationship side
-  def relation(o, container)
-    @@relation_visitor.visit_this_1(self, o, container)
-  end
-
   # Performs check if this is valid as a rvalue
   def rvalue(o)
     @@rvalue_visitor.visit_this_0(self, o)
   end
 
   # Performs check if this is valid as a container of a definition (class, define, node)
   def top(o, definition)
     @@top_visitor.visit_this_1(self, o, definition)
   end
 
   # Checks the LHS of an assignment (is it assignable?).
   # If args[0] is true, assignment via index is checked.
   #
   def assign(o, via_index = false)
     @@assignment_visitor.visit_this_1(self, o, via_index)
   end
 
   #---ASSIGNMENT CHECKS
 
   def assign_VariableExpression(o, via_index)
     varname_string = varname_to_s(o.expr)
     if varname_string =~ Puppet::Pops::Patterns::NUMERIC_VAR_NAME
       acceptor.accept(Issues::ILLEGAL_NUMERIC_ASSIGNMENT, o, :varname => varname_string)
     end
     # Can not assign to something in another namespace (i.e. a '::' in the name is not legal)
     if acceptor.will_accept? Issues::CROSS_SCOPE_ASSIGNMENT
       if varname_string =~ /::/
         acceptor.accept(Issues::CROSS_SCOPE_ASSIGNMENT, o, :name => varname_string)
       end
     end
     # TODO: Could scan for reassignment of the same variable if done earlier in the same container
     #       Or if assigning to a parameter (more work).
     # TODO: Investigate if there are invalid cases for += assignment
   end
 
   def assign_AccessExpression(o, via_index)
     # Are indexed assignments allowed at all ? $x[x] = '...'
     if acceptor.will_accept? Issues::ILLEGAL_INDEXED_ASSIGNMENT
       acceptor.accept(Issues::ILLEGAL_INDEXED_ASSIGNMENT, o)
     else
       # Then the left expression must be assignable-via-index
       assign(o.left_expr, true)
     end
   end
 
   def assign_Object(o, via_index)
     # Can not assign to anything else (differentiate if this is via index or not)
     # i.e. 10 = 'hello' vs. 10['x'] = 'hello' (the root is reported as being in error in both cases)
     #
     acceptor.accept(via_index ? Issues::ILLEGAL_ASSIGNMENT_VIA_INDEX : Issues::ILLEGAL_ASSIGNMENT, o)
   end
 
   #---CHECKS
 
   def check_Object(o)
   end
 
   def check_Factory(o)
     check(o.current)
   end
 
   def check_AccessExpression(o)
     # Only min range is checked, all other checks are RT checks as they depend on the resulting type
     # of the LHS.
     if o.keys.size < 1
       acceptor.accept(Issues::MISSING_INDEX, o)
     end
   end
 
   def check_AssignmentExpression(o)
     acceptor.accept(Issues::UNSUPPORTED_OPERATOR, o, {:operator => o.operator}) unless [:'=', :'+=', :'-='].include? o.operator
     assign(o.left_expr)
     rvalue(o.right_expr)
   end
 
   # Checks that operation with :+> is contained in a ResourceOverride or Collector.
   #
   # Parent of an AttributeOperation can be one of:
   # * CollectExpression
   # * ResourceOverride
   # * ResourceBody (ILLEGAL this is a regular resource expression)
   # * ResourceDefaults (ILLEGAL)
   #
   def check_AttributeOperation(o)
     if o.operator == :'+>'
       # Append operator use is constrained
       parent = o.eContainer
       unless parent.is_a?(Model::CollectExpression) || parent.is_a?(Model::ResourceOverrideExpression)
         acceptor.accept(Issues::ILLEGAL_ATTRIBUTE_APPEND, o, {:name=>o.attribute_name, :parent=>parent})
       end
     end
     rvalue(o.value_expr)
   end
 
   def check_BinaryExpression(o)
     rvalue(o.left_expr)
     rvalue(o.right_expr)
   end
 
   def check_CallNamedFunctionExpression(o)
     unless o.functor_expr.is_a? Model::QualifiedName
       acceptor.accept(Issues::ILLEGAL_EXPRESSION, o.functor_expr, :feature => 'function name', :container => o)
     end
   end
 
   def check_MethodCallExpression(o)
     unless o.functor_expr.is_a? Model::QualifiedName
       acceptor.accept(Issues::ILLEGAL_EXPRESSION, o.functor_expr, :feature => 'function name', :container => o)
     end
   end
 
   def check_CaseExpression(o)
     rvalue(o.test)
     # There should only be one LiteralDefault case option value
     # TODO: Implement this check
   end
 
   def check_CaseOption(o)
     o.values.each { |v| rvalue(v) }
   end
 
   def check_CollectExpression(o)
     unless o.type_expr.is_a? Model::QualifiedReference
       acceptor.accept(Issues::ILLEGAL_EXPRESSION, o.type_expr, :feature=> 'type name', :container => o)
     end
 
     # If a collect expression tries to collect exported resources and storeconfigs is not on
     # then it will not work... This was checked in the parser previously. This is a runtime checking
     # thing as opposed to a language thing.
     if acceptor.will_accept?(Issues::RT_NO_STORECONFIGS) && o.query.is_a?(Model::ExportedQuery)
       acceptor.accept(Issues::RT_NO_STORECONFIGS, o)
     end
   end
 
   # Only used for function names, grammar should not be able to produce something faulty, but
   # check anyway if model is created programatically (it will fail in transformation to AST for sure).
   def check_NamedAccessExpression(o)
     name = o.right_expr
     unless name.is_a? Model::QualifiedName
       acceptor.accept(Issues::ILLEGAL_EXPRESSION, name, :feature=> 'function name', :container => o.eContainer)
     end
   end
 
   # for 'class' and 'define'
   def check_NamedDefinition(o)
     top(o.eContainer, o)
     if o.name !~ Puppet::Pops::Patterns::CLASSREF
       acceptor.accept(Issues::ILLEGAL_DEFINITION_NAME, o, {:name=>o.name})
     end
   end
 
   def check_IfExpression(o)
     rvalue(o.test)
   end
 
   def check_ImportExpression(o)
     o.files.each do |f|
       unless f.is_a? Model::LiteralString
         acceptor.accept(Issues::ILLEGAL_EXPRESSION, f, :feature => 'file name', :container => o)
       end
     end
   end
 
   def check_KeyedEntry(o)
     rvalue(o.key)
     rvalue(o.value)
     # In case there are additional things to forbid than non-rvalues
     # acceptor.accept(Issues::ILLEGAL_EXPRESSION, o.key, :feature => 'hash key', :container => o.eContainer)
   end
 
   # A Lambda is a Definition, but it may appear in other scopes than top scope (Which check_Definition asserts).
   #
   def check_LambdaExpression(o)
   end
 
   def check_LiteralList(o)
     o.values.each {|v| rvalue(v) }
   end
 
   def check_NodeDefinition(o)
     # Check that hostnames are valid hostnames (or regular expressions)
     hostname(o.host_matches, o)
     hostname(o.parent, o, 'parent') unless o.parent.nil?
     top(o.eContainer, o)
   end
 
   # No checking takes place - all expressions using a QualifiedName need to check. This because the
   # rules are slightly different depending on the container (A variable allows a numeric start, but not
   # other names). This means that (if the lexer/parser so chooses) a QualifiedName
   # can be anything when it represents a Bare Word and evaluates to a String.
   #
   def check_QualifiedName(o)
   end
 
   # Checks that the value is a valid UpperCaseWord (a CLASSREF), and optionally if it contains a hypen.
   # DOH: QualifiedReferences are created with LOWER CASE NAMES at parse time
   def check_QualifiedReference(o)
     # Is this a valid qualified name?
     if o.value !~ Puppet::Pops::Patterns::CLASSREF
       acceptor.accept(Issues::ILLEGAL_CLASSREF, o, {:name=>o.value})
     end
   end
 
   def check_QueryExpression(o)
     query(o.expr) if o.expr  # is optional
   end
 
-  def relation_Object(o, rel_expr)
-    acceptor.accept(Issues::ILLEGAL_EXPRESSION, o, {:feature => o.eContainingFeature, :container => rel_expr})
-  end
-
-  def relation_AccessExpression(o, rel_expr); end
-
-  def relation_CollectExpression(o, rel_expr); end
-
-  def relation_VariableExpression(o, rel_expr); end
-
-  def relation_LiteralString(o, rel_expr); end
-
-  def relation_ConcatenatedStringExpression(o, rel_expr); end
-
-  def relation_SelectorExpression(o, rel_expr); end
-
-  def relation_CaseExpression(o, rel_expr); end
-
-  def relation_ResourceExpression(o, rel_expr); end
-
-  def relation_RelationshipExpression(o, rel_expr); end
 
   def check_Parameter(o)
     if o.name =~ /^[0-9]+$/
       acceptor.accept(Issues::ILLEGAL_NUMERIC_PARAMETER, o, :name => o.name)
     end
   end
 
-  #relationship_side: resource
-  #  | resourceref
-  #  | collection
-  #  | variable
-  #  | quotedtext
-  #  | selector
-  #  | casestatement
-  #  | hasharrayaccesses
-
   def check_RelationshipExpression(o)
-    relation(o.left_expr, o)
-    relation(o.right_expr, o)
+    rvalue(o.left_expr)
+    rvalue(o.right_expr)
   end
 
   def check_ResourceExpression(o)
     # A resource expression must have a lower case NAME as its type e.g. 'file { ... }'
     unless o.type_name.is_a? Model::QualifiedName
       acceptor.accept(Issues::ILLEGAL_EXPRESSION, o.type_name, :feature => 'resource type', :container => o)
     end
 
     # This is a runtime check - the model is valid, but will have runtime issues when evaluated
     # and storeconfigs is not set.
     if acceptor.will_accept?(Issues::RT_NO_STORECONFIGS) && o.exported
       acceptor.accept(Issues::RT_NO_STORECONFIGS_EXPORT, o)
     end
   end
 
   def check_ResourceDefaultsExpression(o)
     if o.form && o.form != :regular
       acceptor.accept(Issues::NOT_VIRTUALIZEABLE, o)
     end
   end
 
   def check_SelectorExpression(o)
     rvalue(o.left_expr)
   end
 
   def check_SelectorEntry(o)
     rvalue(o.matching_expr)
   end
 
   def check_UnaryExpression(o)
     rvalue(o.expr)
   end
 
   def check_UnlessExpression(o)
     rvalue(o.test)
     # TODO: Unless may not have an else part that is an IfExpression (grammar denies this though)
   end
 
   # Checks that variable is either strictly 0, or a non 0 starting decimal number, or a valid VAR_NAME
   def check_VariableExpression(o)
     # The expression must be a qualified name
     if !o.expr.is_a? Model::QualifiedName
       acceptor.accept(Issues::ILLEGAL_EXPRESSION, o, :feature => 'name', :container => o)
     else
       # name must be either a decimal value, or a valid NAME
       name = o.expr.value
       if name[0,1] =~ /[0-9]/
         unless name =~ Puppet::Pops::Patterns::NUMERIC_VAR_NAME
           acceptor.accept(Issues::ILLEGAL_NUMERIC_VAR_NAME, o, :name => name)
         end
       else
         check(o.expr)
       end
     end
   end
 
   #--- HOSTNAME CHECKS
 
   # Transforms Array of host matching expressions into a (Ruby) array of AST::HostName
   def hostname_Array(o, semantic, single_feature_name)
     if single_feature_name
       acceptor.accept(Issues::ILLEGAL_EXPRESSION, o, {:feature=>single_feature_name, :container=>semantic})
     end
     o.each {|x| hostname(x, semantic, false) }
   end
 
   def hostname_String(o, semantic, single_feature_name)
     # The 3.x checker only checks for illegal characters - if matching /[^-\w.]/ the name is invalid,
     # but this allows pathological names like "a..b......c", "----"
     # TODO: Investigate if more illegal hostnames should be flagged.
     #
     if o =~ Puppet::Pops::Patterns::ILLEGAL_HOSTNAME_CHARS
       acceptor.accept(Issues::ILLEGAL_HOSTNAME_CHARS, semantic, :hostname => o)
     end
   end
 
   def hostname_LiteralValue(o, semantic, single_feature_name)
     hostname_String(o.value.to_s, o, single_feature_name)
   end
 
   def hostname_ConcatenatedString(o, semantic, single_feature_name)
     # Puppet 3.1. only accepts a concatenated string without interpolated expressions
     if the_expr = o.segments.index {|s| s.is_a?(Model::TextExpression) }
       acceptor.accept(Issues::ILLEGAL_HOSTNAME_INTERPOLATION, o.segments[the_expr].expr)
     elsif o.segments.size() != 1
       # corner case, bad model, concatenation of several plain strings
       acceptor.accept(Issues::ILLEGAL_HOSTNAME_INTERPOLATION, o)
     else
       # corner case, may be ok, but lexer may have replaced with plain string, this is
       # here if it does not
       hostname_String(o.segments[0], o.segments[0], false)
     end
   end
 
   def hostname_QualifiedName(o, semantic, single_feature_name)
     hostname_String(o.value.to_s, o, single_feature_name)
   end
 
   def hostname_QualifiedReference(o, semantic, single_feature_name)
     hostname_String(o.value.to_s, o, single_feature_name)
   end
 
   def hostname_LiteralNumber(o, semantic, single_feature_name)
     # always ok
   end
 
   def hostname_LiteralDefault(o, semantic, single_feature_name)
     # always ok
   end
 
   def hostname_LiteralRegularExpression(o, semantic, single_feature_name)
     # always ok
   end
 
   def hostname_Object(o, semantic, single_feature_name)
     acceptor.accept(Issues::ILLEGAL_EXPRESSION, o, {:feature=> single_feature_name || 'hostname', :container=>semantic})
   end
 
   #---QUERY CHECKS
 
   # Anything not explicitly allowed is flagged as error.
   def query_Object(o)
     acceptor.accept(Issues::ILLEGAL_QUERY_EXPRESSION, o)
   end
 
   # Puppet AST only allows == and !=
   #
   def query_ComparisonExpression(o)
     acceptor.accept(Issues::ILLEGAL_QUERY_EXPRESSION, o) unless [:'==', :'!='].include? o.operator
   end
 
   # Allows AND, OR, and checks if left/right are allowed in query.
   def query_BooleanExpression(o)
     query o.left_expr
     query o.right_expr
   end
 
   def query_ParenthesizedExpression(o)
     query(o.expr)
   end
 
   def query_VariableExpression(o); end
 
   def query_QualifiedName(o); end
 
   def query_LiteralNumber(o); end
 
   def query_LiteralString(o); end
 
   def query_LiteralBoolean(o); end
 
   #---RVALUE CHECKS
 
   # By default, all expressions are reported as being rvalues
   # Implement specific rvalue checks for those that are not.
   #
   def rvalue_Expression(o); end
 
   def rvalue_ImportExpression(o)          ; acceptor.accept(Issues::NOT_RVALUE, o) ; end
 
   def rvalue_BlockExpression(o)           ; acceptor.accept(Issues::NOT_RVALUE, o) ; end
 
 #  def rvalue_CaseExpression(o)            ; acceptor.accept(Issues::NOT_RVALUE, o) ; end
 
 #  def rvalue_IfExpression(o)              ; acceptor.accept(Issues::NOT_RVALUE, o) ; end
 
 #  def rvalue_UnlessExpression(o)          ; acceptor.accept(Issues::NOT_RVALUE, o) ; end
 
-  def rvalue_ResourceExpression(o)        ; acceptor.accept(Issues::NOT_RVALUE, o) ; end
+#  def rvalue_ResourceExpression(o)        ; acceptor.accept(Issues::NOT_RVALUE, o) ; end
 
   def rvalue_ResourceDefaultsExpression(o); acceptor.accept(Issues::NOT_RVALUE, o) ; end
 
   def rvalue_ResourceOverrideExpression(o); acceptor.accept(Issues::NOT_RVALUE, o) ; end
 
   def rvalue_CollectExpression(o)         ; acceptor.accept(Issues::NOT_RVALUE, o) ; end
 
   def rvalue_Definition(o)                ; acceptor.accept(Issues::NOT_RVALUE, o) ; end
 
   def rvalue_NodeDefinition(o)            ; acceptor.accept(Issues::NOT_RVALUE, o) ; end
 
   def rvalue_UnaryExpression(o)           ; rvalue o.expr                 ; end
 
   #---TOP CHECK
 
   def top_NilClass(o, definition)
     # ok, reached the top, no more parents
   end
 
   def top_Object(o, definition)
     # fail, reached a container that is not top level
     acceptor.accept(Issues::NOT_TOP_LEVEL, definition)
   end
 
   def top_BlockExpression(o, definition)
     # ok, if this is a block representing the body of a class, or is top level
     top o.eContainer, definition
   end
 
   def top_HostClassDefinition(o, definition)
     # ok, stop scanning parents
   end
 
   def top_Program(o, definition)
     # ok
   end
 
   # A LambdaExpression is a BlockExpression, and this method is needed to prevent the polymorph method for BlockExpression
   # to accept a lambda.
   # A lambda can not iteratively create classes, nodes or defines as the lambda does not have a closure.
   #
   def top_LambdaExpression(o, definition)
     # fail, stop scanning parents
     acceptor.accept(Issues::NOT_TOP_LEVEL, definition)
   end
 
   #--- NON POLYMORPH, NON CHECKING CODE
 
   # Produces string part of something named, or nil if not a QualifiedName or QualifiedReference
   #
   def varname_to_s(o)
     case o
     when Model::QualifiedName
       o.value
     when Model::QualifiedReference
       o.value
     else
       nil
     end
   end
 end
diff --git a/spec/unit/pops/evaluator/evaluating_parser_spec.rb b/spec/unit/pops/evaluator/evaluating_parser_spec.rb
index d5df607b9..6fc772367 100644
--- a/spec/unit/pops/evaluator/evaluating_parser_spec.rb
+++ b/spec/unit/pops/evaluator/evaluating_parser_spec.rb
@@ -1,920 +1,926 @@
 #! /usr/bin/env ruby
 require 'spec_helper'
 
 require 'puppet/pops'
 require 'puppet/pops/evaluator/evaluator_impl'
 require 'puppet_spec/pops'
 require 'puppet_spec/scope'
 require 'puppet/parser/e4_parser_adapter'
 
 
 # relative to this spec file (./) does not work as this file is loaded by rspec
 #require File.join(File.dirname(__FILE__), '/evaluator_rspec_helper')
 
 describe 'Puppet::Pops::Evaluator::EvaluatorImpl' do
   include PuppetSpec::Pops
   include PuppetSpec::Scope
   before(:each) do
     Puppet[:strict_variables] = true
   end
 
   let(:parser) { Puppet::Pops::Parser::EvaluatingParser::Transitional.new }
   let(:node) { 'node.example.com' }
   let(:scope) { s = create_test_scope_for_node(node); s }
   types = Puppet::Pops::Types::TypeFactory
 
   context "When evaluator evaluates literals" do
     {
       "1"             => 1,
       "010"           => 8,
       "0x10"          => 16,
       "3.14"          => 3.14,
       "0.314e1"       => 3.14,
       "31.4e-1"       => 3.14,
       "'1'"           => '1',
       "'banana'"      => 'banana',
       '"banana"'      => 'banana',
       "banana"        => 'banana',
       "banana::split" => 'banana::split',
       "false"         => false,
       "true"          => true,
       "Array"         => types.array_of_data(),
       "/.*/"          => /.*/
     }.each do |source, result|
         it "should parse and evaluate the expression '#{source}' to #{result}" do
           parser.evaluate_string(scope, source, __FILE__).should == result
         end
       end
   end
 
   context "When the evaluator evaluates Lists and Hashes" do
     {
       "[]"                                              => [],
       "[1,2,3]"                                         => [1,2,3],
       "[1,[2.0, 2.1, [2.2]],[3.0, 3.1]]"                => [1,[2.0, 2.1, [2.2]],[3.0, 3.1]],
       "[2 + 2]"                                         => [4],
       "[1,2,3] == [1,2,3]"                              => true,
       "[1,2,3] != [2,3,4]"                              => true,
       "[1,2,3] == [2,2,3]"                              => false,
       "[1,2,3] != [1,2,3]"                              => false,
       "[1,2,3][2]"                                      => 3,
       "[1,2,3] + [4,5]"                                 => [1,2,3,4,5],
       "[1,2,3] + [[4,5]]"                               => [1,2,3,[4,5]],
       "[1,2,3] + 4"                                     => [1,2,3,4],
       "[1,2,3] << [4,5]"                                => [1,2,3,[4,5]],
       "[1,2,3] << {'a' => 1, 'b'=>2}"                   => [1,2,3,{'a' => 1, 'b'=>2}],
       "[1,2,3] << 4"                                    => [1,2,3,4],
       "[1,2,3,4] - [2,3]"                               => [1,4],
       "[1,2,3,4] - [2,5]"                               => [1,3,4],
       "[1,2,3,4] - 2"                                   => [1,3,4],
       "[1,2,3,[2],4] - 2"                               => [1,3,[2],4],
       "[1,2,3,[2,3],4] - [[2,3]]"                       => [1,2,3,4],
       "[1,2,3,3,2,4,2,3] - [2,3]"                       => [1,4],
       "[1,2,3,['a',1],['b',2]] - {'a' => 1, 'b'=>2}"    => [1,2,3],
       "[1,2,3,{'a'=>1,'b'=>2}] - [{'a' => 1, 'b'=>2}]"  => [1,2,3],
     }.each do |source, result|
         it "should parse and evaluate the expression '#{source}' to #{result}" do
           parser.evaluate_string(scope, source, __FILE__).should == result
         end
       end
 
     {
       "[1,2,3] + {'a' => 1, 'b'=>2}"                    => [1,2,3,['a',1],['b',2]],
     }.each do |source, result|
         it "should parse and evaluate the expression '#{source}' to #{result}" do
           # This test must be done with match_array since the order of the hash
           # is undefined and Ruby 1.8.7 and 1.9.3 produce different results.
           expect(parser.evaluate_string(scope, source, __FILE__)).to match_array(result)
         end
       end
 
     {
       "[1,2,3][a]" => :error,
     }.each do |source, result|
         it "should parse and raise error for '#{source}'" do
           expect { parser.evaluate_string(scope, source, __FILE__) }.to raise_error(Puppet::ParseError)
         end
       end
 
     {
       "{}"                                       => {},
       "{'a'=>1,'b'=>2}"                          => {'a'=>1,'b'=>2},
       "{'a'=>1,'b'=>{'x'=>2.1,'y'=>2.2}}"        => {'a'=>1,'b'=>{'x'=>2.1,'y'=>2.2}},
       "{'a'=> 2 + 2}"                            => {'a'=> 4},
       "{'a'=> 1, 'b'=>2} == {'a'=> 1, 'b'=>2}"   => true,
       "{'a'=> 1, 'b'=>2} != {'x'=> 1, 'b'=>2}"   => true,
       "{'a'=> 1, 'b'=>2} == {'a'=> 2, 'b'=>3}"   => false,
       "{'a'=> 1, 'b'=>2} != {'a'=> 1, 'b'=>2}"   => false,
       "{a => 1, b => 2}[b]"                      => 2,
       "{2+2 => sum, b => 2}[4]"                  => 'sum',
       "{'a'=>1, 'b'=>2} + {'c'=>3}"              => {'a'=>1,'b'=>2,'c'=>3},
       "{'a'=>1, 'b'=>2} + {'b'=>3}"              => {'a'=>1,'b'=>3},
       "{'a'=>1, 'b'=>2} + ['c', 3, 'b', 3]"      => {'a'=>1,'b'=>3, 'c'=>3},
       "{'a'=>1, 'b'=>2} + [['c', 3], ['b', 3]]"  => {'a'=>1,'b'=>3, 'c'=>3},
       "{'a'=>1, 'b'=>2} - {'b' => 3}"            => {'a'=>1},
       "{'a'=>1, 'b'=>2, 'c'=>3} - ['b', 'c']"    => {'a'=>1},
       "{'a'=>1, 'b'=>2, 'c'=>3} - 'c'"           => {'a'=>1, 'b'=>2},
     }.each do |source, result|
         it "should parse and evaluate the expression '#{source}' to #{result}" do
           parser.evaluate_string(scope, source, __FILE__).should == result
         end
       end
 
     {
       "{'a' => 1, 'b'=>2} << 1" => :error,
     }.each do |source, result|
         it "should parse and raise error for '#{source}'" do
           expect { parser.evaluate_string(scope, source, __FILE__) }.to raise_error(Puppet::ParseError)
         end
       end
   end
 
   context "When the evaluator perform comparisons" do
     {
       "'a' == 'a'"     => true,
       "'a' == 'b'"     => false,
       "'a' != 'a'"     => false,
       "'a' != 'b'"     => true,
       "'a' < 'b' "     => true,
       "'a' < 'a' "     => false,
       "'b' < 'a' "     => false,
       "'a' <= 'b'"     => true,
       "'a' <= 'a'"     => true,
       "'b' <= 'a'"     => false,
       "'a' > 'b' "     => false,
       "'a' > 'a' "     => false,
       "'b' > 'a' "     => true,
       "'a' >= 'b'"     => false,
       "'a' >= 'a'"     => true,
       "'b' >= 'a'"     => true,
       "'a' == 'A'"     => true,
       "'a' != 'A'"     => false,
       "'a' >  'A'"     => false,
       "'a' >= 'A'"     => true,
       "'A' <  'a'"     => false,
       "'A' <= 'a'"     => true,
       "1 == 1"         => true,
       "1 == 2"         => false,
       "1 != 1"         => false,
       "1 != 2"         => true,
       "1 < 2 "         => true,
       "1 < 1 "         => false,
       "2 < 1 "         => false,
       "1 <= 2"         => true,
       "1 <= 1"         => true,
       "2 <= 1"         => false,
       "1 > 2 "         => false,
       "1 > 1 "         => false,
       "2 > 1 "         => true,
       "1 >= 2"         => false,
       "1 >= 1"         => true,
       "2 >= 1"         => true,
       "1 == 1.0 "      => true,
       "1 < 1.1  "      => true,
       "'1' < 1.1"      => true,
       "1.0 == 1 "      => true,
       "1.0 < 2  "      => true,
       "'1.0' < 1.1"    => true,
       "'1.0' < 'a'"    => true,
       "'1.0' < '' "    => true,
       "'1.0' < ' '"    => true,
       "'a' > '1.0'"    => true,
       "/.*/ == /.*/ "  => true,
       "/.*/ != /a.*/"  => true,
       "true  == true " => true,
       "false == false" => true,
       "true == false"  => false,
     }.each do |source, result|
         it "should parse and evaluate the expression '#{source}' to #{result}" do
           parser.evaluate_string(scope, source, __FILE__).should == result
         end
       end
 
    {
       "'a' =~ /.*/"                     => true,
       "'a' =~ '.*'"                     => true,
       "/.*/ != /a.*/"                   => true,
       "'a' !~ /b.*/"                    => true,
       "'a' !~ 'b.*'"                    => true,
       '$x = a; a =~ "$x.*"'             => true,
       "a =~ Pattern['a.*']"             => true,
       "a =~ Regexp['a.*']"              => true,
       "$x = /a.*/ a =~ $x"              => true,
       "$x = Pattern['a.*'] a =~ $x"     => true,
       "1 =~ Integer"                    => true,
       "1 !~ Integer"                    => false,
       "[1,2,3] =~ Array[Integer[1,10]]" => true,
     }.each do |source, result|
         it "should parse and evaluate the expression '#{source}' to #{result}" do
           parser.evaluate_string(scope, source, __FILE__).should == result
         end
       end
 
     {
       "666 =~ /6/"    => :error,
       "[a] =~ /a/"    => :error,
       "{a=>1} =~ /a/" => :error,
        "/a/ =~ /a/"    => :error,
       "Array =~ /A/"  => :error,
     }.each do |source, result|
         it "should parse and raise error for '#{source}'" do
           expect { parser.evaluate_string(scope, source, __FILE__) }.to raise_error(Puppet::ParseError)
         end
       end
 
     {
       "1 in [1,2,3]"                  => true,
       "4 in [1,2,3]"                  => false,
       "a in {x=>1, a=>2}"             => true,
       "z in {x=>1, a=>2}"             => false,
       "ana in bananas"                => true,
       "xxx in bananas"                => false,
       "/ana/ in bananas"              => true,
       "/xxx/ in bananas"              => false,
       "ANA in bananas"                => false, # ANA is a type, not a String
       "'ANA' in bananas"              => true,
       "ana in 'BANANAS'"              => true,
       "/ana/ in 'BANANAS'"            => false,
       "/ANA/ in 'BANANAS'"            => true,
       "xxx in 'BANANAS'"              => false,
       "[2,3] in [1,[2,3],4]"          => true,
       "[2,4] in [1,[2,3],4]"          => false,
       "[a,b] in ['A',['A','B'],'C']"  => true,
       "[x,y] in ['A',['A','B'],'C']"  => false,
       "a in {a=>1}"                   => true,
       "x in {a=>1}"                   => false,
       "'A' in {a=>1}"                 => true,
       "'X' in {a=>1}"                 => false,
       "a in {'A'=>1}"                 => true,
       "x in {'A'=>1}"                 => false,
       "/xxx/ in {'aaaxxxbbb'=>1}"     => true,
       "/yyy/ in {'aaaxxxbbb'=>1}"     => false,
       "15 in [1, 0xf]"                => true,
       "15 in [1, '0xf']"              => true,
       "'15' in [1, 0xf]"              => true,
       "15 in [1, 115]"                => false,
       "1 in [11, '111']"              => false,
       "'1' in [11, '111']"            => false,
       "Array[Integer] in [2, 3]"      => false,
       "Array[Integer] in [2, [3, 4]]" => true,
       "Array[Integer] in [2, [a, 4]]" => false,
       "Integer in { 2 =>'a'}"         => true,
       "Integer[5,10] in [1,5,3]"      => true,
       "Integer[5,10] in [1,2,3]"      => false,
       "Integer in {'a'=>'a'}"         => false,
       "Integer in {'a'=>1}"           => false,
     }.each do |source, result|
       it "should parse and evaluate the expression '#{source}' to #{result}" do
         parser.evaluate_string(scope, source, __FILE__).should == result
       end
     end
 
     {
       'Object'  => ['Data', 'Literal', 'Numeric', 'Integer', 'Float', 'Boolean', 'String', 'Pattern', 'Collection',
                     'Array', 'Hash', 'CatalogEntry', 'Resource', 'Class', 'Undef', 'File', 'NotYetKnownResourceType'],
 
       # Note, Data > Collection is false (so not included)
       'Data'    => ['Literal', 'Numeric', 'Integer', 'Float', 'Boolean', 'String', 'Pattern', 'Array', 'Hash',],
       'Literal' => ['Numeric', 'Integer', 'Float', 'Boolean', 'String', 'Pattern'],
       'Numeric' => ['Integer', 'Float'],
       'CatalogEntry' => ['Class', 'Resource', 'File', 'NotYetKnownResourceType'],
       'Integer[1,10]' => ['Integer[2,3]'],
     }.each do |general, specials|
       specials.each do |special |
         it "should compute that #{general} > #{special}" do
           parser.evaluate_string(scope, "#{general} > #{special}", __FILE__).should == true
         end
         it "should compute that  #{special} < #{general}" do
           parser.evaluate_string(scope, "#{special} < #{general}", __FILE__).should == true
         end
         it "should compute that #{general} != #{special}" do
           parser.evaluate_string(scope, "#{special} != #{general}", __FILE__).should == true
         end
       end
     end
 
     {
       'Integer[1,10] > Integer[2,3]'   => true,
       'Integer[1,10] == Integer[2,3]'  => false,
       'Integer[1,10] > Integer[0,5]'   => false,
       'Integer[1,10] > Integer[1,10]'  => false,
       'Integer[1,10] >= Integer[1,10]' => true,
       'Integer[1,10] == Integer[1,10]' => true,
     }.each do |source, result|
         it "should parse and evaluate the integer range comparison expression '#{source}' to #{result}" do
           parser.evaluate_string(scope, source, __FILE__).should == result
         end
       end
 
   end
 
   context "When the evaluator performs arithmetic" do
     context "on Integers" do
       {  "2+2"    => 4,
          "2 + 2"  => 4,
          "7 - 3"  => 4,
          "6 * 3"  => 18,
          "6 / 3"  => 2,
          "6 % 3"  => 0,
          "10 % 3" =>  1,
          "-(6/3)" => -2,
          "-6/3  " => -2,
          "8 >> 1" => 4,
          "8 << 1" => 16,
       }.each do |source, result|
           it "should parse and evaluate the expression '#{source}' to #{result}" do
             parser.evaluate_string(scope, source, __FILE__).should == result
           end
         end
 
     context "on Floats" do
       {
         "2.2 + 2.2"  => 4.4,
         "7.7 - 3.3"  => 4.4,
         "6.1 * 3.1"  => 18.91,
         "6.6 / 3.3"  => 2.0,
         "-(6.0/3.0)" => -2.0,
         "-6.0/3.0 "  => -2.0,
       }.each do |source, result|
           it "should parse and evaluate the expression '#{source}' to #{result}" do
             parser.evaluate_string(scope, source, __FILE__).should == result
           end
         end
 
       {
         "3.14 << 2" => :error,
         "3.14 >> 2" => :error,
         "6.6 % 3.3"  => 0.0,
         "10.0 % 3.0" =>  1.0,
       }.each do |source, result|
           it "should parse and raise error for '#{source}'" do
             expect { parser.evaluate_string(scope, source, __FILE__) }.to raise_error(Puppet::ParseError)
           end
         end
     end
 
     context "on strings requiring boxing to Numeric" do
       {
         "'2' + '2'"       => 4,
         "'2.2' + '2.2'"   => 4.4,
         "'0xF7' + '010'"  => 0xFF,
         "'0xF7' + '0x8'"  => 0xFF,
         "'0367' + '010'"  => 0xFF,
         "'012.3' + '010'" => 20.3,
       }.each do |source, result|
           it "should parse and evaluate the expression '#{source}' to #{result}" do
             parser.evaluate_string(scope, source, __FILE__).should == result
           end
         end
 
       {
         "'0888' + '010'"   => :error,
         "'0xWTF' + '010'"  => :error,
         "'0x12.3' + '010'" => :error,
         "'0x12.3' + '010'" => :error,
       }.each do |source, result|
           it "should parse and raise error for '#{source}'" do
             expect { parser.evaluate_string(scope, source, __FILE__) }.to raise_error(Puppet::ParseError)
           end
         end
       end
     end
   end # arithmetic
 
   context "When the evaluator evaluates assignment" do
     {
       "$a = 5"                     => 5,
       "$a = 5; $a"                 => 5,
       "$a = 5; $b = 6; $a"         => 5,
       "$a = $b = 5; $a == $b"      => true,
       "$a = [1,2,3]; [x].map |$x| { $a += x; $a }"      => [[1,2,3,'x']],
       "$a = [a,x,c]; [x].map |$x| { $a -= x; $a }"      => [['a','c']],
     }.each do |source, result|
         it "should parse and evaluate the expression '#{source}' to #{result}" do
           parser.evaluate_string(scope, source, __FILE__).should == result
         end
       end
 
     {
       "[a,b,c] = [1,2,3]; $a == 1 and $b == 2 and $c == 3"               => :error,
       "[a,b,c] = {b=>2,c=>3,a=>1}; $a == 1 and $b == 2 and $c == 3"      => :error,
       "$a = [1,2,3]; [x].collect |$x| { [a] += x; $a }"                  => :error,
       "$a = [a,x,c]; [x].collect |$x| { [a] -= x; $a }"                  => :error,
     }.each do |source, result|
         it "should parse and evaluate the expression '#{source}' to #{result}" do
           expect { parser.evaluate_string(scope, source, __FILE__)}.to raise_error(Puppet::ParseError)
         end
       end
   end
 
   context "When the evaluator evaluates conditionals" do
     {
       "if true {5}"                     => 5,
       "if false {5}"                    => nil,
       "if false {2} else {5}"           => 5,
       "if false {2} elsif true {5}"     => 5,
       "if false {2} elsif false {5}"    => nil,
       "unless false {5}"                => 5,
       "unless true {5}"                 => nil,
       "unless true {2} else {5}"        => 5,
       "$a = if true {5} $a"                     => 5,
       "$a = if false {5} $a"                    => nil,
       "$a = if false {2} else {5} $a"           => 5,
       "$a = if false {2} elsif true {5} $a"     => 5,
       "$a = if false {2} elsif false {5} $a"    => nil,
       "$a = unless false {5} $a"                => 5,
       "$a = unless true {5} $a"                 => nil,
       "$a = unless true {2} else {5} $a"        => 5,
     }.each do |source, result|
         it "should parse and evaluate the expression '#{source}' to #{result}" do
           parser.evaluate_string(scope, source, __FILE__).should == result
         end
       end
 
     {
       "case 1 { 1 : { yes } }"                               => 'yes',
       "case 2 { 1,2,3 : { yes} }"                            => 'yes',
       "case 2 { 1,3 : { no } 2: { yes} }"                    => 'yes',
       "case 2 { 1,3 : { no } 5: { no } default: { yes }}"    => 'yes',
       "case 2 { 1,3 : { no } 5: { no } }"                    => nil,
       "case 'banana' { 1,3 : { no } /.*ana.*/: { yes } }"    => 'yes',
       "case 'banana' { /.*(ana).*/: { $1 } }"                => 'ana',
       "case [1] { Array : { yes } }"                         => 'yes',
       "case [1] {
          Array[String] : { no }
          Array[Integer]: { 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
         end
       end
 
     {
       "2 ? { 1 => no, 2 => yes}"                          => 'yes',
       "3 ? { 1 => no, 2 => no}"                           => nil,
       "3 ? { 1 => no, 2 => no, default => yes }"          => 'yes',
       "3 ? { 1 => no, default => yes, 3 => no }"          => 'yes',
       "'banana' ? { /.*(ana).*/  => $1 }"                 => 'ana',
       "[2] ? { Array[String] => yes, Array => 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
         end
       end
   end
 
   context "When evaluator performs [] operations" do
     {
       "[1,2,3][0]"      => 1,
       "[1,2,3][2]"      => 3,
       "[1,2,3][3]"      => nil,
       "[1,2,3][-1]"     => 3,
       "[1,2,3][-2]"     => 2,
       "[1,2,3][-4]"     => nil,
       "[1,2,3,4][0,2]"  => [1,2],
       "[1,2,3,4][1,3]"  => [2,3,4],
       "[1,2,3,4][-2,2]"  => [3,4],
       "[1,2,3,4][-3,2]"  => [2,3],
       "[1,2,3,4][3,5]"   => [4],
       "[1,2,3,4][5,2]"   => [],
       "[1,2,3,4][0,-1]"  => [1,2,3,4],
       "[1,2,3,4][0,-2]"  => [1,2,3],
       "[1,2,3,4][0,-4]"  => [1],
       "[1,2,3,4][0,-5]"  => [],
       "[1,2,3,4][-5,2]"  => [1],
       "[1,2,3,4][-5,-3]" => [1,2],
       "[1,2,3,4][-6,-3]" => [1,2],
       "[1,2,3,4][2,-3]"  => [],
     }.each do |source, result|
       it "should parse and evaluate the expression '#{source}' to #{result}" do
         parser.evaluate_string(scope, source, __FILE__).should == result
       end
     end
 
     {
       "{a=>1, b=>2, c=>3}[a]"                => 1,
       "{a=>1, b=>2, c=>3}[c]"                => 3,
       "{a=>1, b=>2, c=>3}[x]"                => nil,
       "{a=>1, b=>2, c=>3}[c,b]"              => [3,2],
       "{a=>1, b=>2, c=>3}[a,b,c]"            => [1,2,3],
       "{a=>{b=>{c=>'it works'}}}[a][b][c]"   => 'it works',
       "$a = {undef => 10} $a[free_lunch]"     => nil,
       "$a = {undef => 10} $a[undef]"          => 10,
       "$a = {undef => 10} $a[$a[free_lunch]]" => 10,
       "$a = {} $a[free_lunch] == undef"       => true,
     }.each do |source, result|
       it "should parse and evaluate the expression '#{source}' to #{result}" do
         parser.evaluate_string(scope, source, __FILE__).should == result
       end
     end
 
     {
       "'abc'[0]"      => 'a',
       "'abc'[2]"      => 'c',
       "'abc'[-1]"     => 'c',
       "'abc'[-2]"     => 'b',
       "'abc'[-3]"     => 'a',
       "'abc'[-4]"     => '',
       "'abc'[3]"      => '',
       "abc[0]"        => 'a',
       "abc[2]"        => 'c',
       "abc[-1]"       => 'c',
       "abc[-2]"       => 'b',
       "abc[-3]"       => 'a',
       "abc[-4]"       => '',
       "abc[3]"        => '',
       "'abcd'[0,2]"   => 'ab',
       "'abcd'[1,3]"   => 'bcd',
       "'abcd'[-2,2]"  => 'cd',
       "'abcd'[-3,2]"  => 'bc',
       "'abcd'[3,5]"   => 'd',
       "'abcd'[5,2]"   => '',
       "'abcd'[0,-1]"  => 'abcd',
       "'abcd'[0,-2]"  => 'abc',
       "'abcd'[0,-4]"  => 'a',
       "'abcd'[0,-5]"  => '',
       "'abcd'[-5,2]"  => 'a',
       "'abcd'[-5,-3]" => 'ab',
       "'abcd'[-6,-3]" => 'ab',
       "'abcd'[2,-3]"  => '',
    }.each do |source, result|
       it "should parse and evaluate the expression '#{source}' to #{result}" do
         parser.evaluate_string(scope, source, __FILE__).should == result
       end
     end
 
     # Type operations (full set tested by tests covering type calculator)
     {
       "Array[Integer]"             => types.array_of(types.integer),
       "Hash[Integer,Integer]"      => types.hash_of(types.integer, types.integer),
       "Resource[File]"             => types.resource('File'),
       "Resource['File']"           => types.resource(types.resource('File')),
       "File[foo]"                  => types.resource('file', 'foo'),
       "File[foo, bar]"             => [types.resource('file', 'foo'), types.resource('file', 'bar')],
     }.each do |source, result|
       it "should parse and evaluate the expression '#{source}' to #{result}" do
         parser.evaluate_string(scope, source, __FILE__).should == result
       end
     end
 
     # LHS where [] not supported, and missing key(s)
     {
       "Array[]"                    => :error,
       "'abc'[]"                    => :error,
       "Resource[]"                 => :error,
       "File[]"                     => :error,
       "String[]"                   => :error,
       "1[]"                        => :error,
       "3.14[]"                     => :error,
       "/.*/[]"                     => :error,
       "$a=[1] $a[]"                => :error,
     }.each do |source, result|
       it "should parse and evaluate the expression '#{source}' to #{result}" do
         expect { parser.evaluate_string(scope, source, __FILE__)}.to raise_error(/Syntax error/)
       end
     end
 
     # 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[Integer,String]"       => 'Array-Type[] accepts 1 argument. Got 2',
       "Hash[Integer,String, Hash]"  => 'Hash-Type[] accepts 1 to 2 arguments. Got 3',
       "'abc'[x]"                    => "The value 'x' cannot be converted to Numeric",
       "'abc'[1.0]"                  => "A String[] cannot use Float where Integer is expected",
       "'abc'[1,2,3]"                => "String supports [] with one or two arguments. Got 3",
       "Resource[0]"                 => 'First argument to Resource[] must be a resource type or a String. Got Fixnum',
       "Resource[a, 0]"              => 'Error creating type specialization of a Resource-Type, Cannot use Fixnum where String is expected',
       "File[0]"                     => 'Error creating type specialization of a File-Type, Cannot use Fixnum where String is expected',
       "String[0]"                   => 'Error creating type specialization of a String-Type, Cannot use Fixnum where String is expected',
       "Pattern[0]"                  => 'Error creating type specialization of a Pattern-Type, Cannot use Fixnum where String or Regexp is expected',
       "Regexp[0]"                   => 'Error creating type specialization of a Regexp-Type, Cannot use Fixnum where String or Regexp is expected',
       "Regexp[a,b]"                 => 'A Regexp-Type[] accepts 1 argument. Got 2',
       "true[0]"                     => "Operator '[]' is not applicable to a Boolean",
       "1[0]"                        => "Operator '[]' is not applicable to an Integer",
       "3.14[0]"                     => "Operator '[]' is not applicable to a Float",
       "/.*/[0]"                     => "Operator '[]' is not applicable to a Regexp",
       "[1][a]"                      => "The value 'a' cannot be converted to Numeric",
       "[1][0.0]"                    => "An Array[] cannot use Float where Integer is expected",
       "[1]['0.0']"                  => "An Array[] cannot use Float where Integer is expected",
       "[1,2][1, 0.0]"               => "An Array[] cannot use Float where Integer is expected",
       "[1,2][1.0, -1]"              => "An Array[] cannot use Float where Integer is expected",
       "[1,2][1, -1.0]"              => "An Array[] cannot use Float where Integer is expected",
     }.each do |source, result|
       it "should parse and evaluate the expression '#{source}' to #{result}" do
         expect { parser.evaluate_string(scope, source, __FILE__)}.to raise_error(Regexp.new(Regexp.quote(result)))
       end
     end
 
     context "on catalog types" do
       it "[n] gets resource parameter [n]" do
         source = "notify { 'hello': message=>'yo'} Notify[hello][message]"
         parser.evaluate_string(scope, source, __FILE__).should == 'yo'
       end
 
       it "[n] gets class parameter [n]" do
         source = "class wonka($produces='chocolate'){ }
            include wonka
            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
         adapted_parser.file = __FILE__
         ast = adapted_parser.parse(source)
         scope.known_resource_types.import_ast(ast, '')
         ast.code.safeevaluate(scope).should == 'chocolate'
       end
 
       # Resource default and override expressions and resource parameter access with []
       {
         "notify { id: message=>explicit} Notify[id][message]"                   => "explicit",
         "Notify { message=>by_default} notify {foo:} Notify[foo][message]"      => "by_default",
         "notify {foo:} Notify[foo]{message =>by_override} Notify[foo][message]" => "by_override",
       }.each do |source, result|
         it "should parse and evaluate the expression '#{source}' to #{result}" do
           parser.evaluate_string(scope, source, __FILE__).should == result
         end
       end
 
       # Resource default and override expressions and resource parameter access error conditions
       {
         "notify { xid: message=>explicit} Notify[id][message]"  => /Resource not found/,
         "notify { id: message=>explicit} Notify[id][mustard]"   => /does not have a parameter called 'mustard'/,
       }.each do |source, result|
         it "should parse '#{source}' and raise error matching #{result}" do
           expect { parser.evaluate_string(scope, source, __FILE__)}.to raise_error(result)
         end
       end
 
       context 'with errors' do
         { "Class['fail-whale']" => /Illegal name/,
           "Class[0]"            => /An Integer cannot be used where a String is expected/,
           "Class[/.*/]"         => /A Regexp cannot be used where a String is expected/,
           "Class[4.1415]"       => /A Float cannot be used where a String is expected/,
           "Class[[1,2,3]]"      => /An Array cannot be used where a String is expected/,
           "Class[Integer]"      => /An Integer-Type cannot be used where a String is expected/,
           "Class[File['tmp']]"   => /A File\['tmp'\] Resource-Reference cannot be used where a String is expected/,
         }.each do | source, error_pattern|
           it "an error is flagged for '#{source}'" do
             expect { parser.evaluate_string(scope, source, __FILE__)}.to raise_error(error_pattern)
           end
         end
       end
     end
   # end [] operations
   end
 
   context "When the evaluator performs boolean operations" do
     {
       "true and true"   => true,
       "false and true"  => false,
       "true and false"  => false,
       "false and false" => false,
       "true or true"    => true,
       "false or true"   => true,
       "true or false"   => true,
       "false or false"  => false,
       "! true"          => false,
       "!! true"         => true,
       "!! false"        => false,
       "! 'x'"           => false,
       "! ''"            => true,
       "! undef"         => true,
       "! [a]"           => false,
       "! []"            => false,
       "! {a=>1}"        => false,
       "! {}"            => false,
       "true and false and '0xwtf' + 1"  => false,
       "false or true  or '0xwtf' + 1"  => true,
     }.each do |source, result|
         it "should parse and evaluate the expression '#{source}' to #{result}" do
           parser.evaluate_string(scope, source, __FILE__).should == result
         end
       end
 
     {
       "false || false || '0xwtf' + 1"   => :error,
     }.each do |source, result|
         it "should parse and raise error for '#{source}'" do
           expect { parser.evaluate_string(scope, source, __FILE__) }.to raise_error(Puppet::ParseError)
         end
       end
   end
 
   context "When evaluator performs operations on literal undef" do
     it "computes non existing hash lookup as undef" do
       parser.evaluate_string(scope, "{a => 1}[b] == undef", __FILE__).should == true
       parser.evaluate_string(scope, "undef == {a => 1}[b]", __FILE__).should == true
     end
   end
 
   context "When evaluator performs calls" do
     let(:populate) do
       parser.evaluate_string(scope, "$a = 10 $b = [1,2,3]")
     end
 
     {
       'sprintf( "x%iy", $a )'                 => "x10y",
       '"x%iy".sprintf( $a )'                  => "x10y",
       '$b.reduce |$memo,$x| { $memo + $x }'   => 6,
       'reduce($b) |$memo,$x| { $memo + $x }'  => 6,
     }.each do |source, result|
         it "should parse and evaluate the expression '#{source}' to #{result}" do
           populate
           parser.evaluate_string(scope, source, __FILE__).should == result
         end
       end
 
     {
       '"value is ${a*2} yo"'  => :error,
     }.each do |source, result|
         it "should parse and raise error for '#{source}'" do
           expect { parser.evaluate_string(scope, source, __FILE__) }.to raise_error(Puppet::ParseError)
         end
       end
   end
 
   context "When evaluator performs string interpolation" do
     let(:populate) do
       parser.evaluate_string(scope, "$a = 10 $b = [1,2,3]")
     end
 
     {
       '"value is $a yo"'                      => "value is 10 yo",
       '"value is \$a yo"'                     => "value is $a yo",
       '"value is ${a} yo"'                    => "value is 10 yo",
       '"value is \${a} yo"'                   => "value is ${a} yo",
       '"value is ${$a} yo"'                   => "value is 10 yo",
       '"value is ${$a*2} yo"'                 => "value is 20 yo",
       '"value is ${sprintf("x%iy",$a)} yo"'   => "value is x10y yo",
       '"value is ${"x%iy".sprintf($a)} yo"'   => "value is x10y yo",
       '"value is ${[1,2,3]} yo"'              => "value is [1, 2, 3] yo",
       '"value is ${/.*/} yo"'                 => "value is /.*/ yo",
       '$x = undef "value is $x yo"'           => "value is  yo",
       '$x = default "value is $x yo"'         => "value is default yo",
       '$x = Array[Integer] "value is $x yo"'  => "value is Array[Integer] yo",
       '"value is ${Array[Integer]} yo"'       => "value is Array[Integer] yo",
     }.each do |source, result|
         it "should parse and evaluate the expression '#{source}' to #{result}" do
           populate
           parser.evaluate_string(scope, source, __FILE__).should == result
         end
       end
 
     it "should parse and evaluate an interpolation of a hash" do
       source = '"value is ${{a=>1,b=>2}} yo"'
       # This test requires testing against two options because a hash to string
       # produces a result that is unordered
       hashstr = {'a' => 1, 'b' => 2}.to_s
       alt_results = ["value is {a => 1, b => 2} yo", "value is {b => 2, a => 1} yo" ]
       populate
       parse_result = parser.evaluate_string(scope, source, __FILE__)
       alt_results.include?(parse_result).should == true
     end
 
     {
       '"value is ${a*2} yo"'  => :error,
     }.each do |source, result|
         it "should parse and raise error for '#{source}'" do
           expect { parser.evaluate_string(scope, source, __FILE__) }.to raise_error(Puppet::ParseError)
         end
       end
   end
 
   context "When evaluating variables" do
     context "that are non existing an error is raised for" do
       it "unqualified variable" do
         expect { parser.evaluate_string(scope, "$quantum_gravity", __FILE__) }.to raise_error(/Unknown variable/)
       end
 
       it "qualified variable" do
         expect { parser.evaluate_string(scope, "$quantum_gravity::graviton", __FILE__) }.to raise_error(/Unknown variable/)
       end
     end
 
     it "a lex error should be raised for '$foo::::bar'" do
       expect { parser.evaluate_string(scope, "$foo::::bar") }.to raise_error(Puppet::LexError, /Illegal fully qualified name at line 1:7/)
     end
 
     { '$a = $0'   => nil,
       '$a = $1'   => nil,
     }.each do |source, value|
       it "it is ok to reference numeric unassigned variables '#{source}'" do
         parser.evaluate_string(scope, source, __FILE__).should == value
       end
     end
 
     { '$00 = 0'   => /must be a decimal value/,
       '$0xf = 0'  => /must be a decimal value/,
       '$0777 = 0' => /must be a decimal value/,
       '$123a = 0' => /must be a decimal value/,
     }.each do |source, error_pattern|
       it "should raise an error for '#{source}'" do
         expect { parser.evaluate_string(scope, source, __FILE__) }.to raise_error(error_pattern)
       end
     end
   end
 
   context "When evaluating relationships" do
-    it 'should form a relation with ->' do
+    it 'should form a relation with File[a] -> File[b]' do
       source = "File[a] -> File[b]"
       parser.evaluate_string(scope, source, __FILE__)
       scope.compiler.should have_relationship(['File', 'a', '->', 'File', 'b'])
     end
 
+    it 'should form a relation with resource -> resource' do
+      source = "notify{a:} -> notify{b:}"
+      parser.evaluate_string(scope, source, __FILE__)
+      scope.compiler.should have_relationship(['Notify', 'a', '->', 'Notify', 'b'])
+    end
+
     it 'should form a relation with <-' do
       source = "File[a] <- File[b]"
       parser.evaluate_string(scope, source, __FILE__)
       scope.compiler.should have_relationship(['File', 'b', '->', 'File', 'a'])
     end
 
     it 'should form a relation with <-' do
       source = "File[a] <~ File[b]"
       parser.evaluate_string(scope, source, __FILE__)
       scope.compiler.should have_relationship(['File', 'b', '~>', 'File', 'a'])
     end
   end
 
   context "Detailed Error messages are reported" do
     it 'for illegal type references' do
       source = '1+1 { "title": }'
       # Error references position 5 at the opening '{'
       # Set file to nil to make it easier to match with line number (no file name in output)
       expect { parser.parse_string(source, nil) }.to raise_error(/Expression is not valid as a resource.*line 1:5/)
     end
 
     it 'for non r-value producing <| |>' do
       expect { parser.parse_string("$a = File <| |>", nil) }.to raise_error(/A Virtual Query does not produce a value at line 1:6/)
     end
 
     it 'for non r-value producing <<| |>>' do
       expect { parser.parse_string("$a = File <<| |>>", nil) }.to raise_error(/An Exported Query does not produce a value at line 1:6/)
     end
 
     it 'for non r-value producing define' do
       Puppet.expects(:err).with("Invalid use of expression. A 'define' expression does not produce a value at line 1:6")
       Puppet.expects(:err).with("Classes, definitions, and nodes may only appear at toplevel or inside other classes at line 1:6")
       expect { parser.parse_string("$a = define foo { }", nil) }.to raise_error(/2 errors/)
     end
 
     it 'for non r-value producing class' do
       Puppet.expects(:err).with("Invalid use of expression. A Host Class Definition does not produce a value at line 1:6")
       Puppet.expects(:err).with("Classes, definitions, and nodes may only appear at toplevel or inside other classes at line 1:6")
       expect { parser.parse_string("$a = class foo { }", nil) }.to raise_error(/2 errors/)
     end
 
     it 'for unclosed quote with indication of start position of string' do
       source = <<-SOURCE.gsub(/^ {6}/,'')
       $a = "xx
       yyy
       SOURCE
       # first char after opening " reported as being in error.
       expect { parser.parse_string(source) }.to raise_error(/Unclosed quote after '"' followed by 'xx\\nyy\.\.\.' at line 1:7/)
     end
 
     it 'for multiple errors with a summary exception' do
       Puppet.expects(:err).with("Invalid use of expression. A Node Definition does not produce a value at line 1:6")
       Puppet.expects(:err).with("Classes, definitions, and nodes may only appear at toplevel or inside other classes at line 1:6")
       expect { parser.parse_string("$a = node x { }",nil) }.to raise_error(/2 errors/)
     end
 
     it 'for a bad hostname' do
       expect {
         parser.parse_string("node 'macbook+owned+by+name' { }", nil)
       }.to raise_error(/The hostname 'macbook\+owned\+by\+name' contains illegal characters.*at line 1:6/)
     end
 
     it 'for a hostname with interpolation' do
       source = <<-SOURCE.gsub(/^ {6}/,'')
       $name = 'fred'
       node "macbook-owned-by$name" { }
       SOURCE
       expect {
         parser.parse_string(source, nil)
       }.to raise_error(/An interpolated expression is not allowed in a hostname of a node at line 2:23/)
     end
 
   end
 
   matcher :have_relationship do |expected|
     calc = Puppet::Pops::Types::TypeCalculator.new
 
     match do |compiler|
       op_name = {'->' => :relationship, '~>' => :subscription}
       compiler.relationships.any? do | relation |
         relation.source.type == expected[0] &&
         relation.source.title == expected[1] &&
         relation.type == op_name[expected[2]] &&
         relation.target.type == expected[3] &&
         relation.target.title == expected[4]
       end
     end
 
     failure_message_for_should do |actual|
       "Relationship #{expected[0]}[#{expected[1]}] #{expected[2]} #{expected[3]}[#{expected[4]}] but was unknown to compiler"
     end
   end
 
 end