diff --git a/lib/puppet/pops/evaluator/evaluator_impl.rb b/lib/puppet/pops/evaluator/evaluator_impl.rb
index 129a8f3ec..2408ee947 100644
--- a/lib/puppet/pops/evaluator/evaluator_impl.rb
+++ b/lib/puppet/pops/evaluator/evaluator_impl.rb
@@ -1,1208 +1,1208 @@
 require 'rgen/ecore/ecore'
 require 'puppet/pops/evaluator/compare_operator'
 require 'puppet/pops/evaluator/relationship_operator'
 require 'puppet/pops/evaluator/access_operator'
 require 'puppet/pops/evaluator/closure'
 require 'puppet/pops/evaluator/external_syntax_support'
 
 # This implementation of {Puppet::Pops::Evaluator} performs evaluation using the puppet 3.x runtime system
 # in a manner largely compatible with Puppet 3.x, but adds new features and introduces constraints.
 #
 # The evaluation uses _polymorphic dispatch_ which works by dispatching to the first found method named after
 # the class or one of its super-classes. The EvaluatorImpl itself mainly deals with evaluation (it currently
 # also handles assignment), and it uses a delegation pattern to more specialized handlers of some operators
 # that in turn use polymorphic dispatch; this to not clutter EvaluatorImpl with too much responsibility).
 #
 # Since a pattern is used, only the main entry points are fully documented. The parameters _o_ and _scope_ are
 # the same in all the polymorphic methods, (the type of the parameter _o_ is reflected in the method's name;
 # either the actual class, or one of its super classes). The _scope_ parameter is always the scope in which
 # the evaluation takes place. If nothing else is mentioned, the return is always the result of evaluation.
 #
 # See {Puppet::Pops::Visitable} and {Puppet::Pops::Visitor} for more information about
 # polymorphic calling.
 #
 class Puppet::Pops::Evaluator::EvaluatorImpl
   include Puppet::Pops::Utils
 
   # Provides access to the Puppet 3.x runtime (scope, etc.)
   # This separation has been made to make it easier to later migrate the evaluator to an improved runtime.
   #
   include Puppet::Pops::Evaluator::Runtime3Support
   include Puppet::Pops::Evaluator::ExternalSyntaxSupport
 
   # This constant is not defined as Float::INFINITY in Ruby 1.8.7 (but is available in later version
   # Refactor when support is dropped for Ruby 1.8.7.
   #
   INFINITY = 1.0 / 0.0
   EMPTY_STRING = ''.freeze
   COMMA_SEPARATOR = ', '.freeze
 
   # Reference to Issues name space makes it easier to refer to issues
   # (Issues are shared with the validator).
   #
   Issues = Puppet::Pops::Issues
 
   def initialize
     @@eval_visitor     ||= Puppet::Pops::Visitor.new(self, "eval", 1, 1)
     @@lvalue_visitor   ||= Puppet::Pops::Visitor.new(self, "lvalue", 1, 1)
     @@assign_visitor   ||= Puppet::Pops::Visitor.new(self, "assign", 3, 3)
     @@string_visitor   ||= Puppet::Pops::Visitor.new(self, "string", 1, 1)
 
     @@type_calculator  ||= Puppet::Pops::Types::TypeCalculator.new()
     @@type_parser      ||= Puppet::Pops::Types::TypeParser.new()
 
     @@compare_operator     ||= Puppet::Pops::Evaluator::CompareOperator.new()
     @@relationship_operator ||= Puppet::Pops::Evaluator::RelationshipOperator.new()
 
     # Use null migration checker unless given in context
     @migration_checker = (Puppet.lookup(:migration_checker) { Puppet::Pops::Migration::MigrationChecker.new() })
   end
 
   # @api private
   def type_calculator
     @@type_calculator
   end
 
   # Evaluates the given _target_ object in the given scope.
   #
   # @overload evaluate(target, scope)
   # @param target [Object] evaluation target - see methods on the pattern assign_TYPE for actual supported types.
   # @param scope [Object] the runtime specific scope class where evaluation should take place
   # @return [Object] the result of the evaluation
   #
   # @api public
   #
   def evaluate(target, scope)
     begin
       @@eval_visitor.visit_this_1(self, target, scope)
 
     rescue Puppet::Pops::SemanticError => e
       # A raised issue may not know the semantic target, use errors call stack, but fill in the 
       # rest from a supplied semantic object, or the target instruction if there is not semantic
       # object.
       #
       fail(e.issue, e.semantic || target, e.options, e)
 
     rescue Puppet::PreformattedError => e
       # Already formatted with location information, and with the wanted call stack.
       # Note this is currently a specialized ParseError, so rescue-order is important
       #
       raise e
 
     rescue Puppet::ParseError => e
       # ParseError may be raised in ruby code without knowing the location
       # in puppet code.
       # Accept a ParseError that has file or line information available
       # as an error that should be used verbatim. (Tests typically run without
       # setting a file name).
       # ParseError can supply an original - it is impossible to determine which
       # call stack that should be propagated, using the ParseError's backtrace.
       #
       if e.file || e.line
         raise e
       else
         # Since it had no location information, treat it as user intended a general purpose
         # error. Pass on its call stack.
         fail(Issues::RUNTIME_ERROR, target, {:detail => e.message}, e)
       end
 
 
     rescue Puppet::Error => e
       # PuppetError has the ability to wrap an exception, if so, use the wrapped exception's
       # call stack instead
       fail(Issues::RUNTIME_ERROR, target, {:detail => e.message}, e.original || e)
 
     rescue StandardError => e
       # All other errors, use its message and call stack
       fail(Issues::RUNTIME_ERROR, target, {:detail => e.message}, e)
     end
   end
 
   # Assigns the given _value_ to the given _target_. The additional argument _o_ is the instruction that
   # produced the target/value tuple and it is used to set the origin of the result.
   #
   # @param target [Object] assignment target - see methods on the pattern assign_TYPE for actual supported types.
   # @param value [Object] the value to assign to `target`
   # @param o [Puppet::Pops::Model::PopsObject] originating instruction
   # @param scope [Object] the runtime specific scope where evaluation should take place
   #
   # @api private
   #
   def assign(target, value, o, scope)
     @@assign_visitor.visit_this_3(self, target, value, o, scope)
   end
 
   # Computes a value that can be used as the LHS in an assignment.
   # @param o [Object] the expression to evaluate as a left (assignable) entity
   # @param scope [Object] the runtime specific scope where evaluation should take place
   #
   # @api private
   #
   def lvalue(o, scope)
     @@lvalue_visitor.visit_this_1(self, o, scope)
   end
 
   # Produces a String representation of the given object _o_ as used in interpolation.
   # @param o [Object] the expression of which a string representation is wanted
   # @param scope [Object] the runtime specific scope where evaluation should take place
   #
   # @api public
   #
   def string(o, scope)
     @@string_visitor.visit_this_1(self, o, scope)
   end
 
   # Evaluate a BlockExpression in a new scope with variables bound to the
   # given values.
   #
   # @param scope [Puppet::Parser::Scope] the parent scope
   # @param variable_bindings [Hash{String => Object}] the variable names and values to bind (names are keys, bound values are values)
   # @param block [Puppet::Pops::Model::BlockExpression] the sequence of expressions to evaluate in the new scope
   #
   # @api private
   #
   def evaluate_block_with_bindings(scope, variable_bindings, block_expr)
     with_guarded_scope(scope) do
       # change to create local scope_from - cannot give it file and line -
       # that is the place of the call, not "here"
       create_local_scope_from(variable_bindings, scope)
       evaluate(block_expr, scope)
     end
   end
 
   protected
 
   def lvalue_VariableExpression(o, scope)
     # evaluate the name
     evaluate(o.expr, scope)
   end
 
   # Catches all illegal lvalues
   #
   def lvalue_Object(o, scope)
     fail(Issues::ILLEGAL_ASSIGNMENT, o)
   end
 
   # Assign value to named variable.
   # The '$' sign is never part of the name.
   # @example In Puppet DSL
   #   $name = value
   # @param name [String] name of variable without $
   # @param value [Object] value to assign to the variable
   # @param o [Puppet::Pops::Model::PopsObject] originating instruction
   # @param scope [Object] the runtime specific scope where evaluation should take place
   # @return [value<Object>]
   #
   def assign_String(name, value, o, scope)
     if name =~ /::/
       fail(Issues::CROSS_SCOPE_ASSIGNMENT, o.left_expr, {:name => name})
     end
     set_variable(name, value, o, scope)
     value
   end
 
   def assign_Numeric(n, value, o, scope)
     fail(Issues::ILLEGAL_NUMERIC_ASSIGNMENT, o.left_expr, {:varname => n.to_s})
   end
 
   # Catches all illegal assignment (e.g. 1 = 2, {'a'=>1} = 2, etc)
   #
   def assign_Object(name, value, o, scope)
     fail(Issues::ILLEGAL_ASSIGNMENT, o)
   end
 
   def eval_Factory(o, scope)
     evaluate(o.current, scope)
   end
 
   # Evaluates any object not evaluated to something else to itself.
   def eval_Object o, scope
     o
   end
 
   # Allows nil to be used as a Nop, Evaluates to nil
   def eval_NilClass(o, scope)
     nil
   end
 
   # Evaluates Nop to nil.
   def eval_Nop(o, scope)
     nil
   end
 
   # Captures all LiteralValues not handled elsewhere.
   #
   def eval_LiteralValue(o, scope)
     o.value
   end
 
   # Reserved Words fail to evaluate
   #
   def eval_ReservedWord(o, scope)
     fail(Puppet::Pops::Issues::RESERVED_WORD, o, {:word => o.word})
   end
 
   def eval_LiteralDefault(o, scope)
     :default
   end
 
   def eval_LiteralUndef(o, scope)
     nil
   end
 
   # A QualifiedReference (i.e. a  capitalized qualified name such as Foo, or Foo::Bar) evaluates to a PType
   #
   def eval_QualifiedReference(o, scope)
     @@type_parser.interpret(o)
   end
 
   def eval_NotExpression(o, scope)
     ! is_true?(evaluate(o.expr, scope), o.expr)
   end
 
   def eval_UnaryMinusExpression(o, scope)
     - coerce_numeric(evaluate(o.expr, scope), o, scope)
   end
 
   def eval_UnfoldExpression(o, scope)
     candidate = evaluate(o.expr, scope)
     case candidate
     when nil
       []
     when Array
       candidate
     when Hash
       candidate.to_a
     else
       # turns anything else into an array (so result can be unfolded)
       [candidate]
     end
   end
 
   # Abstract evaluation, returns array [left, right] with the evaluated result of left_expr and
   # right_expr
   # @return <Array<Object, Object>> array with result of evaluating left and right expressions
   #
   def eval_BinaryExpression o, scope
     [ evaluate(o.left_expr, scope), evaluate(o.right_expr, scope) ]
   end
 
   # Evaluates assignment with operators =, +=, -= and
   #
   # @example Puppet DSL
   #   $a = 1
   #   $a += 1
   #   $a -= 1
   #
   def eval_AssignmentExpression(o, scope)
     name = lvalue(o.left_expr, scope)
     value = evaluate(o.right_expr, scope)
 
     if o.operator == :'='
       assign(name, value, o, scope)
     else
       fail(Issues::UNSUPPORTED_OPERATOR, o, {:operator => o.operator})
     end
     value
   end
 
   ARITHMETIC_OPERATORS = [:'+', :'-', :'*', :'/', :'%', :'<<', :'>>']
   COLLECTION_OPERATORS = [:'+', :'-', :'<<']
 
   # Handles binary expression where lhs and rhs are array/hash or numeric and operator is +, - , *, % / << >>
   #
   def eval_ArithmeticExpression(o, scope)
     left = evaluate(o.left_expr, scope)
     right = evaluate(o.right_expr, scope)
 
     begin
       result = calculate(left, right, o.operator, o.left_expr, o.right_expr, scope)
     rescue ArgumentError => e
       fail(Issues::RUNTIME_ERROR, o, {:detail => e.message}, e)
     end
     result
   end
 
 
   # Handles binary expression where lhs and rhs are array/hash or numeric and operator is +, - , *, % / << >>
   #
   def calculate(left, right, operator, left_o, right_o, scope)
     unless ARITHMETIC_OPERATORS.include?(operator)
       fail(Issues::UNSUPPORTED_OPERATOR, left_o.eContainer, {:operator => o.operator})
     end
 
     if (left.is_a?(Array) || left.is_a?(Hash)) && COLLECTION_OPERATORS.include?(operator)
       # Handle operation on collections
       case operator
       when :'+'
         concatenate(left, right)
       when :'-'
         delete(left, right)
       when :'<<'
         unless left.is_a?(Array)
           fail(Issues::OPERATOR_NOT_APPLICABLE, left_o, {:operator => operator, :left_value => left})
         end
         left + [right]
       end
     else
       # Handle operation on numeric
       left = coerce_numeric(left, left_o, scope)
       right = coerce_numeric(right, right_o, scope)
       begin
         if operator == :'%' && (left.is_a?(Float) || right.is_a?(Float))
           # Deny users the fun of seeing severe rounding errors and confusing results
           fail(Issues::OPERATOR_NOT_APPLICABLE, left_o, {:operator => operator, :left_value => left})
         end
         result = left.send(operator, right)
       rescue NoMethodError => e
         fail(Issues::OPERATOR_NOT_APPLICABLE, left_o, {:operator => operator, :left_value => left})
       rescue ZeroDivisionError => e
         fail(Issues::DIV_BY_ZERO, right_o)
       end
       if result == INFINITY || result == -INFINITY
         fail(Issues::RESULT_IS_INFINITY, left_o, {:operator => operator})
       end
       result
     end
   end
 
   def eval_EppExpression(o, scope)
     scope["@epp"] = []
     evaluate(o.body, scope)
     result = scope["@epp"].join
     result
   end
 
   def eval_RenderStringExpression(o, scope)
     scope["@epp"] << o.value.dup
     nil
   end
 
   def eval_RenderExpression(o, scope)
     scope["@epp"] << string(evaluate(o.expr, scope), scope)
     nil
   end
 
   # Evaluates Puppet DSL ->, ~>, <-, and <~
   def eval_RelationshipExpression(o, scope)
     # First level evaluation, reduction to basic data types or puppet types, the relationship operator then translates this
     # to the final set of references (turning strings into references, which can not naturally be done by the main evaluator since
     # all strings should not be turned into references.
     #
     real = eval_BinaryExpression(o, scope)
     @@relationship_operator.evaluate(real, o, scope)
   end
 
   # Evaluates x[key, key, ...]
   #
   def eval_AccessExpression(o, scope)
     left = evaluate(o.left_expr, scope)
     keys = o.keys.nil? ? [] : o.keys.collect {|key| evaluate(key, scope) }
     Puppet::Pops::Evaluator::AccessOperator.new(o).access(left, scope, *keys)
   end
 
   # Evaluates <, <=, >, >=, and ==
   #
   def eval_ComparisonExpression o, scope
     left = evaluate(o.left_expr, scope)
     right = evaluate(o.right_expr, scope)
 
     @migration_checker.report_uc_bareword_type(left, o.left_expr)
     @migration_checker.report_uc_bareword_type(right, o.right_expr)
 
     begin
     # Left is a type
     if left.is_a?(Puppet::Pops::Types::PAnyType)
       case o.operator
       when :'=='
         @migration_checker.report_equality_type_mismatch(left, right, o)
         @@type_calculator.equals(left,right)
 
       when :'!='
         @migration_checker.report_equality_type_mismatch(left, right, o)
         !@@type_calculator.equals(left,right)
 
       when :'<'
         # left can be assigned to right, but they are not equal
         @@type_calculator.assignable?(right, left) && ! @@type_calculator.equals(left,right)
       when :'<='
         # left can be assigned to right
         @@type_calculator.assignable?(right, left)
       when :'>'
         # right can be assigned to left, but they are not equal
         @@type_calculator.assignable?(left,right) && ! @@type_calculator.equals(left,right)
       when :'>='
         # right can be assigned to left
         @@type_calculator.assignable?(left, right)
       else
         fail(Issues::UNSUPPORTED_OPERATOR, o, {:operator => o.operator})
       end
     else
       case o.operator
       when :'=='
         @migration_checker.report_equality_type_mismatch(left, right, o)
         @@compare_operator.equals(left,right)
       when :'!='
         @migration_checker.report_equality_type_mismatch(left, right, o)
         ! @@compare_operator.equals(left,right)
       when :'<'
         @@compare_operator.compare(left,right) < 0
       when :'<='
         @@compare_operator.compare(left,right) <= 0
       when :'>'
         @@compare_operator.compare(left,right) > 0
       when :'>='
         @@compare_operator.compare(left,right) >= 0
       else
         fail(Issues::UNSUPPORTED_OPERATOR, o, {:operator => o.operator})
       end
     end
     rescue ArgumentError => e
       fail(Issues::COMPARISON_NOT_POSSIBLE, o, {
         :operator => o.operator,
         :left_value => left,
         :right_value => right,
         :detail => e.message}, e)
     end
   end
 
   # Evaluates matching expressions with type, string or regexp rhs expression.
   # If RHS is a type, the =~ matches compatible (instance? of) type.
   #
   # @example
   #   x =~ /abc.*/
   # @example
   #   x =~ "abc.*/"
   # @example
   #   y = "abc"
   #   x =~ "${y}.*"
   # @example
   #   [1,2,3] =~ Array[Integer[1,10]]
   #
   # Note that a string is not instance? of Regexp, only Regular expressions are.
   # The Pattern type should instead be used as it is specified as subtype of String.
   #
   # @return [Boolean] if a match was made or not. Also sets $0..$n to matchdata in current scope.
   #
   def eval_MatchExpression o, scope
     left = evaluate(o.left_expr, scope)
     pattern = evaluate(o.right_expr, scope)
 
     @migration_checker.report_uc_bareword_type(left, o.left_expr)
 
     # matches RHS types as instance of for all types except a parameterized Regexp[R]
     if pattern.is_a?(Puppet::Pops::Types::PAnyType)
       # evaluate as instance? of type check
       matched = @@type_calculator.instance?(pattern, left)
       # convert match result to Boolean true, or false
       return o.operator == :'=~' ? !!matched : !matched
     end
 
     begin
       pattern = Regexp.new(pattern) unless pattern.is_a?(Regexp)
     rescue StandardError => e
       fail(Issues::MATCH_NOT_REGEXP, o.right_expr, {:detail => e.message}, e)
     end
     unless left.is_a?(String)
       fail(Issues::MATCH_NOT_STRING, o.left_expr, {:left_value => left})
     end
 
     matched = pattern.match(left) # nil, or MatchData
     set_match_data(matched,scope) # creates ephemeral
 
     # convert match result to Boolean true, or false
     o.operator == :'=~' ? !!matched : !matched
   end
 
   # Evaluates Puppet DSL `in` expression
   #
   def eval_InExpression o, scope
     left = evaluate(o.left_expr, scope)
     right = evaluate(o.right_expr, scope)
     @migration_checker.report_uc_bareword_type(left, o.left_expr)
     @migration_checker.report_in_expression(o)
     @@compare_operator.include?(right, left, scope)
   end
 
   # @example
   #   $a and $b
   # b is only evaluated if a is true
   #
   def eval_AndExpression o, scope
     is_true?(evaluate(o.left_expr, scope), o.left_expr) ? is_true?(evaluate(o.right_expr, scope), o.right_expr) : false
   end
 
   # @example
   #   a or b
   # b is only evaluated if a is false
   #
   def eval_OrExpression o, scope
     is_true?(evaluate(o.left_expr, scope), o.left_expr) ? true : is_true?(evaluate(o.right_expr, scope), o.right_expr)
   end
 
   # Evaluates each entry of the literal list and creates a new Array
   # Supports unfolding of entries
   # @return [Array] with the evaluated content
   #
   def eval_LiteralList o, scope
     unfold([], o.values, scope)
   end
 
   # Evaluates each entry of the literal hash and creates a new Hash.
   # @return [Hash] with the evaluated content
   #
   def eval_LiteralHash o, scope
     # optimized
     o.entries.reduce({}) {|h,entry| h[evaluate(entry.key, scope)] = evaluate(entry.value, scope); h }
   end
 
   # Evaluates all statements and produces the last evaluated value
   #
   def eval_BlockExpression o, scope
     r = nil
     o.statements.each {|s| r = evaluate(s, scope)}
     r
   end
 
   # Performs optimized search over case option values, lazily evaluating each
   # until there is a match. If no match is found, the case expression's default expression
   # is evaluated (it may be nil or Nop if there is no default, thus producing nil).
   # If an option matches, the result of evaluating that option is returned.
   # @return [Object, nil] what a matched option returns, or nil if nothing matched.
   #
   def eval_CaseExpression(o, scope)
     # memo scope level before evaluating test - don't want a match in the case test to leak $n match vars
     # to expressions after the case expression.
     #
     with_guarded_scope(scope) do
       test = evaluate(o.test, scope)
       @migration_checker.report_uc_bareword_type(test, o.test)
 
       result = nil
       the_default = nil
       if o.options.find do |co|
         # the first case option that matches
         if co.values.find do |c|
           c = unwind_parentheses(c)
           case c
           when Puppet::Pops::Model::LiteralDefault
             the_default = co.then_expr
-            is_match?(test, evaluate(c, scope), c, co, scope)
+            next false
           when Puppet::Pops::Model::UnfoldExpression
             # not ideal for error reporting, since it is not known which unfolded result
             # that caused an error - the entire unfold expression is blamed (i.e. the var c, passed to is_match?)
             evaluate(c, scope).any? {|v| is_match?(test, v, c, co, scope) }
           else
             is_match?(test, evaluate(c, scope), c, co, scope)
           end
         end
         result = evaluate(co.then_expr, scope)
         true # the option was picked
         end
       end
         result # an option was picked, and produced a result
       else
         evaluate(the_default, scope) # evaluate the default (should be a nop/nil) if there is no default).
       end
     end
   end
 
   # Evaluates a CollectExpression by creating a collector transformer. The transformer
   # will evaulate the collection, create the appropriate collector, and hand it off
   # to the compiler to collect the resources specified by the query.
   #
   def eval_CollectExpression o, scope
     Puppet::Pops::Evaluator::CollectorTransformer.new().transform(o,scope)
   end
 
   def eval_ParenthesizedExpression(o, scope)
     evaluate(o.expr, scope)
   end
 
   # This evaluates classes, nodes and resource type definitions to nil, since 3x:
   # instantiates them, and evaluates their parameters and body. This is achieved by
   # providing bridge AST classes in Puppet::Parser::AST::PopsBridge that bridges a
   # Pops Program and a Pops Expression.
   #
   # Since all Definitions are handled "out of band", they are treated as a no-op when
   # evaluated.
   #
   def eval_Definition(o, scope)
     nil
   end
 
   def eval_Program(o, scope)
     evaluate(o.body, scope)
   end
 
   # Produces Array[PAnyType], an array of resource references
   #
   def eval_ResourceExpression(o, scope)
     exported = o.exported
     virtual = o.virtual
 
     # Get the type name
     type_name =
     if (tmp_name = o.type_name).is_a?(Puppet::Pops::Model::QualifiedName)
       tmp_name.value # already validated as a name
     else
       type_name_acceptable =
       case o.type_name
       when Puppet::Pops::Model::QualifiedReference
         true
       when Puppet::Pops::Model::AccessExpression
         o.type_name.left_expr.is_a?(Puppet::Pops::Model::QualifiedReference)
       end
 
       evaluated_name = evaluate(tmp_name, scope)
       unless type_name_acceptable
         actual = type_calculator.generalize!(type_calculator.infer(evaluated_name)).to_s
         fail(Puppet::Pops::Issues::ILLEGAL_RESOURCE_TYPE, o.type_name, {:actual => actual})
       end
 
       # must be a CatalogEntry subtype
       case evaluated_name
       when Puppet::Pops::Types::PHostClassType
         unless evaluated_name.class_name.nil?
           fail(Puppet::Pops::Issues::ILLEGAL_RESOURCE_TYPE, o.type_name, {:actual=> evaluated_name.to_s})
         end
         'class'
 
       when Puppet::Pops::Types::PResourceType
         unless evaluated_name.title().nil?
           fail(Puppet::Pops::Issues::ILLEGAL_RESOURCE_TYPE, o.type_name, {:actual=> evaluated_name.to_s})
         end
         evaluated_name.type_name # assume validated
 
       else
         actual = type_calculator.generalize!(type_calculator.infer(evaluated_name)).to_s
         fail(Puppet::Pops::Issues::ILLEGAL_RESOURCE_TYPE, o.type_name, {:actual=>actual})
       end
     end
 
     # This is a runtime check - the model is valid, but will have runtime issues when evaluated
     # and storeconfigs is not set.
     if(o.exported)
       optionally_fail(Puppet::Pops::Issues::RT_NO_STORECONFIGS_EXPORT, o);
     end
 
     titles_to_body = {}
     body_to_titles = {}
     body_to_params = {}
 
     # titles are evaluated before attribute operations
     o.bodies.map do | body |
       titles = evaluate(body.title, scope)
 
       # Title may not be nil
       # Titles may be given as an array, it is ok if it is empty, but not if it contains nil entries
       # Titles may not be an empty String
       # Titles must be unique in the same resource expression
       # There may be a :default entry, its entries apply with lower precedence
       #
       if titles.nil?
         fail(Puppet::Pops::Issues::MISSING_TITLE, body.title)
       end
       titles = [titles].flatten
 
       # Check types of evaluated titles and duplicate entries
       titles.each_with_index do |title, index|
         if title.nil?
           fail(Puppet::Pops::Issues::MISSING_TITLE_AT, body.title, {:index => index})
 
         elsif !title.is_a?(String) && title != :default
           actual = type_calculator.generalize!(type_calculator.infer(title)).to_s
           fail(Puppet::Pops::Issues::ILLEGAL_TITLE_TYPE_AT, body.title, {:index => index, :actual => actual})
 
         elsif title == EMPTY_STRING
          fail(Puppet::Pops::Issues::EMPTY_STRING_TITLE_AT, body.title, {:index => index})
 
         elsif titles_to_body[title]
           fail(Puppet::Pops::Issues::DUPLICATE_TITLE, o, {:title => title})
         end
         titles_to_body[title] = body
       end
 
       # Do not create a real instance from the :default case
       titles.delete(:default)
 
       body_to_titles[body] = titles
 
       # Store evaluated parameters in a hash associated with the body, but do not yet create resource
       # since the entry containing :defaults may appear later
       body_to_params[body] = body.operations.reduce({}) do |param_memo, op|
         params = evaluate(op, scope)
         params = [params] unless params.is_a?(Array)
         params.each do |p|
           if param_memo.include? p.name
             fail(Puppet::Pops::Issues::DUPLICATE_ATTRIBUTE, o, {:attribute => p.name})
           end
           param_memo[p.name] = p
         end
         param_memo
       end
     end
 
     # Titles and Operations have now been evaluated and resources can be created
     # Each production is a PResource, and an array of all is produced as the result of
     # evaluating the ResourceExpression.
     #
     defaults_hash = body_to_params[titles_to_body[:default]] || {}
     o.bodies.map do | body |
       titles = body_to_titles[body]
       params = defaults_hash.merge(body_to_params[body] || {})
       create_resources(o, scope, virtual, exported, type_name, titles, params.values)
     end.flatten.compact
   end
 
   def eval_ResourceOverrideExpression(o, scope)
     evaluated_resources = evaluate(o.resources, scope)
     evaluated_parameters = o.operations.map { |op| evaluate(op, scope) }
     create_resource_overrides(o, scope, [evaluated_resources].flatten, evaluated_parameters)
     evaluated_resources
   end
 
   # Produces 3x parameter
   def eval_AttributeOperation(o, scope)
     create_resource_parameter(o, scope, o.attribute_name, evaluate(o.value_expr, scope), o.operator)
   end
 
   def eval_AttributesOperation(o, scope)
     hashed_params = evaluate(o.expr, scope)
     unless hashed_params.is_a?(Hash)
       actual = type_calculator.generalize!(type_calculator.infer(hashed_params)).to_s
       fail(Puppet::Pops::Issues::TYPE_MISMATCH, o.expr, {:expected => 'Hash', :actual => actual})
     end
     hashed_params.map { |k,v| create_resource_parameter(o, scope, k, v, :'=>') }
   end
 
   # Sets default parameter values for a type, produces the type
   #
   def eval_ResourceDefaultsExpression(o, scope)
     type = evaluate(o.type_ref, scope)
     type_name =
     if type.is_a?(Puppet::Pops::Types::PResourceType) && !type.type_name.nil? && type.title.nil?
       type.type_name # assume it is a valid name
     else
       actual = type_calculator.generalize!(type_calculator.infer(type))
       fail(Issues::ILLEGAL_RESOURCE_TYPE, o.type_ref, {:actual => actual})
     end
     evaluated_parameters = o.operations.map {|op| evaluate(op, scope) }
     create_resource_defaults(o, scope, type_name, evaluated_parameters)
     # Produce the type
     type
   end
 
   # Evaluates function call by name.
   #
   def eval_CallNamedFunctionExpression(o, scope)
     # The functor expression is not evaluated, it is not possible to select the function to call
     # via an expression like $a()
     case o.functor_expr
     when Puppet::Pops::Model::QualifiedName
       # ok
     when Puppet::Pops::Model::RenderStringExpression
       # helpful to point out this easy to make Epp error
       fail(Issues::ILLEGAL_EPP_PARAMETERS, o)
     else
       fail(Issues::ILLEGAL_EXPRESSION, o.functor_expr, {:feature=>'function name', :container => o})
     end
     name = o.functor_expr.value
     call_function_with_block(name, unfold([], o.arguments, scope), o, scope)
   end
 
   # Evaluation of CallMethodExpression handles a NamedAccessExpression functor (receiver.function_name)
   #
   def eval_CallMethodExpression(o, scope)
     unless o.functor_expr.is_a? Puppet::Pops::Model::NamedAccessExpression
       fail(Issues::ILLEGAL_EXPRESSION, o.functor_expr, {:feature=>'function accessor', :container => o})
     end
     receiver = unfold([], [o.functor_expr.left_expr], scope)
     name = o.functor_expr.right_expr
     unless name.is_a? Puppet::Pops::Model::QualifiedName
       fail(Issues::ILLEGAL_EXPRESSION, o.functor_expr, {:feature=>'function name', :container => o})
     end 
     name = name.value # the string function name
     call_function_with_block(name, unfold(receiver, o.arguments || [], scope), o, scope)
   end
 
   def call_function_with_block(name, evaluated_arguments, o, scope)
     if o.lambda.nil?
       call_function(name, evaluated_arguments, o, scope)
     else
       closure = Puppet::Pops::Evaluator::Closure.new(self, o.lambda, scope)
       call_function(name, evaluated_arguments, o, scope, &proc_from_closure(closure))
     end
   end
   private :call_function_with_block
 
   # Creates a Proc with an arity count that matches the parameters of the given closure. The arity will
   # be correct up to 10 parameters and then default to varargs (-1)
   #
   def proc_from_closure(closure)
     return Puppet::Pops::Evaluator::PuppetProc.new(closure) { |*args| closure.call(*args) } unless RUBY_VERSION[0,3] == '1.8'
 
     # This code is required since a Proc isn't propagated by reference in Ruby 1.8.x. It produces a standard
     # Proc that has correct arity as a replacement for the otherwise used PuppetProc
     # TODO: Remove when Ruby 1.8.x support is dropped
     arity = closure.parameters.reduce(0) do |memo, param|
       count = memo + 1
       break -count if param.captures_rest || !param.value.nil?
       count
     end
 
     case arity
     when 0
       proc { || closure.call }
     when 1
       proc { |a| closure.call(a) }
     when 2
       proc { |a, b| closure.call(a, b) }
     when 3
       proc { |a, b, c| closure.call(a, b, c) }
     when 4
       proc { |a, b, c, d| closure.call(a, b, c, d) }
     when 5
       proc { |a, b, c, d, e| closure.call(a, b, c, d, e) }
     when 6
       proc { |a, b, c, d, e, f| closure.call(a, b, c, d, e, f) }
     when 7
       proc { |a, b, c, d, e, f, g| closure.call(a, b, c, d, e, f, g) }
     when 8
       proc { |a, b, c, d, e, f, g, h| closure.call(a, b, c, d, e, f, g, h) }
     when 9
       proc { |a, b, c, d, e, f, g, h, i| closure.call(a, b, c, d, e, f, g, h, i) }
     when 10
       proc { |a, b, c, d, e, f, g, h, i, j| closure.call(a, b, c, d, e, f, g, h, i, j) }
     when -1
       proc { |*v| closure.call(*v) }
     when -2
       proc { |a, *v| closure.call(a, *v) }
     when -3
       proc { |a, b, *v| closure.call(a, b, *v) }
     when -4
       proc { |a, b, c, *v| closure.call(a, b, c, *v) }
     when -5
       proc { |a, b, c, d, *v| closure.call(a, b, c, d, *v) }
     when -6
       proc { |a, b, c, d, e, *v| closure.call(a, b, c, d, e, *v) }
     when -7
       proc { |a, b, c, d, e, f, *v| closure.call(a, b, c, d, e, f, *v) }
     when -8
       proc { |a, b, c, d, e, f, g, *v| closure.call(a, b, c, d, e, f, g, *v) }
     when -9
       proc { |a, b, c, d, e, f, g, h, *v| closure.call(a, b, c, d, e, f,g, h, *v) }
     when -10
       proc { |a, b, c, d, e, f, g, h, i, *v| closure.call(a, b, c, d, e, f,g, h, i, *v) }
     else
       proc { |*a| closure.call(*a) }
     end
   end
   private :proc_from_closure
 
   # @example
   #   $x ? { 10 => true, 20 => false, default => 0 }
   #
   def eval_SelectorExpression o, scope
     # memo scope level before evaluating test - don't want a match in the case test to leak $n match vars
     # to expressions after the selector expression.
     #
     with_guarded_scope(scope) do
       test = evaluate(o.left_expr, scope)
       @migration_checker.report_uc_bareword_type(test, o.left_expr)
 
       the_default = nil
       selected = o.selectors.find do |s|
         me = unwind_parentheses(s.matching_expr)
         case me
         when Puppet::Pops::Model::LiteralDefault
           the_default = s.value_expr
           false
         when Puppet::Pops::Model::UnfoldExpression
           # not ideal for error reporting, since it is not known which unfolded result
           # that caused an error - the entire unfold expression is blamed (i.e. the var c, passed to is_match?)
           evaluate(me, scope).any? {|v| is_match?(test, v, me, s, scope) }
         else
           is_match?(test, evaluate(me, scope), me, s, scope)
         end
       end
       if selected
         evaluate(selected.value_expr, scope)
       elsif the_default
         evaluate(the_default, scope)
       else
         fail(Issues::UNMATCHED_SELECTOR, o.left_expr, :param_value => test)
       end
     end
   end
 
   # SubLocatable is simply an expression that holds location information
   def eval_SubLocatedExpression o, scope
     evaluate(o.expr, scope)
   end
 
   # Evaluates Puppet DSL Heredoc
   def eval_HeredocExpression o, scope
     result = evaluate(o.text_expr, scope)
     assert_external_syntax(scope, result, o.syntax, o.text_expr)
     result
   end
 
   # Evaluates Puppet DSL `if`
   def eval_IfExpression o, scope
     with_guarded_scope(scope) do
       if is_true?(evaluate(o.test, scope), o.test)
         evaluate(o.then_expr, scope)
       else
         evaluate(o.else_expr, scope)
       end
     end
   end
 
   # Evaluates Puppet DSL `unless`
   def eval_UnlessExpression o, scope
     with_guarded_scope(scope) do
       unless is_true?(evaluate(o.test, scope), o.test)
         evaluate(o.then_expr, scope)
       else
         evaluate(o.else_expr, scope)
       end
     end
   end
 
   # Evaluates a variable (getting its value)
   # The evaluator is lenient; any expression producing a String is used as a name
   # of a variable.
   #
   def eval_VariableExpression o, scope
     # Evaluator is not too fussy about what constitutes a name as long as the result
     # is a String and a valid variable name
     #
     name = evaluate(o.expr, scope)
 
     # Should be caught by validation, but make this explicit here as well, or mysterious evaluation issues
     # may occur for some evaluation use cases.
     case name
     when String
     when Numeric
     else
       fail(Issues::ILLEGAL_VARIABLE_EXPRESSION, o.expr)
     end
     get_variable_value(name, o, scope)
   end
 
   # Evaluates double quoted strings that may contain interpolation
   #
   def eval_ConcatenatedString o, scope
     o.segments.collect {|expr| string(evaluate(expr, scope), scope)}.join
   end
 
 
   # If the wrapped expression is a QualifiedName, it is taken as the name of a variable in scope.
   # Note that this is different from the 3.x implementation, where an initial qualified name
   # is accepted. (e.g. `"---${var + 1}---"` is legal. This implementation requires such concrete
   # syntax to be expressed in a model as `(TextExpression (+ (Variable var) 1)` - i.e. moving the decision to
   # the parser.
   #
   # Semantics; the result of an expression is turned into a string, nil is silently transformed to empty
   # string.
   # @return [String] the interpolated result
   #
   def eval_TextExpression o, scope
     if o.expr.is_a?(Puppet::Pops::Model::QualifiedName)
       string(get_variable_value(o.expr.value, o, scope), scope)
     else
       string(evaluate(o.expr, scope), scope)
     end
   end
 
   def string_Object(o, scope)
     o.to_s
   end
 
   def string_Symbol(o, scope)
     if :undef == o  # optimized comparison 1.44 vs 1.95
       EMPTY_STRING
     else
       o.to_s
     end
   end
 
   def string_Array(o, scope)
     "[#{o.map {|e| string(e, scope)}.join(COMMA_SEPARATOR)}]"
   end
 
   def string_Hash(o, scope)
     "{#{o.map {|k,v| "#{string(k, scope)} => #{string(v, scope)}"}.join(COMMA_SEPARATOR)}}"
   end
 
   def string_Regexp(o, scope)
     "/#{o.source}/"
   end
 
   def string_PAnyType(o, scope)
     @@type_calculator.string(o)
   end
 
   # Produces concatenation / merge of x and y.
   #
   # When x is an Array, y of type produces:
   #
   # * Array => concatenation `[1,2], [3,4] => [1,2,3,4]`
   # * Hash => concatenation of hash as array `[key, value, key, value, ...]`
   # * any other => concatenation of single value
   #
   # When x is a Hash, y of type produces:
   #
   # * Array => merge of array interpreted as `[key, value, key, value,...]`
   # * Hash => a merge, where entries in `y` overrides
   # * any other => error
   #
   # When x is something else, wrap it in an array first.
   #
   # When x is nil, an empty array is used instead.
   #
   # @note to concatenate an Array, nest the array - i.e. `[1,2], [[2,3]]`
   #
   # @overload concatenate(obj_x, obj_y)
   #   @param obj_x [Object] object to wrap in an array and concatenate to; see other overloaded methods for return type
   #   @param ary_y [Object] array to concatenate at end of `ary_x`
   #   @return [Object] wraps obj_x in array before using other overloaded option based on type of obj_y
   # @overload concatenate(ary_x, ary_y)
   #   @param ary_x [Array] array to concatenate to
   #   @param ary_y [Array] array to concatenate at end of `ary_x`
   #   @return [Array] new array with `ary_x` + `ary_y`
   # @overload concatenate(ary_x, hsh_y)
   #   @param ary_x [Array] array to concatenate to
   #   @param hsh_y [Hash] converted to array form, and concatenated to array
   #   @return [Array] new array with `ary_x` + `hsh_y` converted to array
   # @overload concatenate (ary_x, obj_y)
   #   @param ary_x [Array] array to concatenate to
   #   @param obj_y [Object] non array or hash object to add to array
   #   @return [Array] new array with `ary_x` + `obj_y` added as last entry
   # @overload concatenate(hsh_x, ary_y)
   #   @param hsh_x [Hash] the hash to merge with
   #   @param ary_y [Array] array interpreted as even numbered sequence of key, value merged with `hsh_x`
   #   @return [Hash] new hash with `hsh_x` merged with `ary_y` interpreted as hash in array form
   # @overload concatenate(hsh_x, hsh_y)
   #   @param hsh_x [Hash] the hash to merge to
   #   @param hsh_y [Hash] hash merged with `hsh_x`
   #   @return [Hash] new hash with `hsh_x` merged with `hsh_y`
   # @raise [ArgumentError] when `xxx_x` is neither an Array nor a Hash
   # @raise [ArgumentError] when `xxx_x` is a Hash, and `xxx_y` is neither Array nor Hash.
   #
   def concatenate(x, y)
     x = [x] unless x.is_a?(Array) || x.is_a?(Hash)
     case x
     when Array
       y = case y
       when Array then y
       when Hash  then y.to_a
       else
         [y]
       end
       x + y # new array with concatenation
     when Hash
       y = case y
       when Hash then y
       when Array
         # Hash[[a, 1, b, 2]] => {}
         # Hash[a,1,b,2] => {a => 1, b => 2}
         # Hash[[a,1], [b,2]] => {[a,1] => [b,2]}
         # Hash[[[a,1], [b,2]]] => {a => 1, b => 2}
         # Use type calcultor to determine if array is Array[Array[?]], and if so use second form
         # of call
         t = @@type_calculator.infer(y)
         if t.element_type.is_a? Puppet::Pops::Types::PArrayType
           Hash[y]
         else
           Hash[*y]
         end
       else
         raise ArgumentError.new("Can only append Array or Hash to a Hash")
       end
       x.merge y # new hash with overwrite
     else
       raise ArgumentError.new("Can only append to an Array or a Hash.")
     end
   end
 
   # Produces the result x \ y (set difference)
   # When `x` is an Array, `y` is transformed to an array and then all matching elements removed from x.
   # When `x` is a Hash, all contained keys are removed from x as listed in `y` if it is an Array, or all its keys if it is a Hash.
   # The difference is returned. The given `x` and `y` are not modified by this operation.
   # @raise [ArgumentError] when `x` is neither an Array nor a Hash
   #
   def delete(x, y)
     result = x.dup
     case x
     when Array
       y = case y
       when Array then y
       when Hash then y.to_a
       else
         [y]
       end
       y.each {|e| result.delete(e) }
     when Hash
       y = case y
       when Array then y
       when Hash then y.keys
       else
         [y]
       end
       y.each {|e| result.delete(e) }
     else
       raise ArgumentError.new("Can only delete from an Array or Hash.")
     end
     result
   end
 
   # Implementation of case option matching.
   #
   # This is the type of matching performed in a case option, using == for every type
   # of value except regular expression where a match is performed.
   #
   def is_match?(left, right, o, option_expr, scope)
     @migration_checker.report_option_type_mismatch(left, right, option_expr, o)
     if right.is_a?(Puppet::Pops::Types::PAnyType)
       @migration_checker.report_uc_bareword_type(right, o)
     end
     @@compare_operator.match(left, right, scope)
   end
 
   def with_guarded_scope(scope)
     scope_memo = get_scope_nesting_level(scope)
     begin
       yield
     ensure
       set_scope_nesting_level(scope, scope_memo)
     end
   end
 
   # Maps the expression in the given array to their product except for UnfoldExpressions which are first unfolded.
   # The result is added to the given result Array.
   # @param result [Array] Where to add the result (may contain information to add to)
   # @param array [Array[Puppet::Pops::Model::Expression] the expressions to map
   # @param scope [Puppet::Parser::Scope] the scope to evaluate in
   # @return [Array] the given result array with content added from the operation
   #
   def unfold(result, array, scope)
     array.each do |x|
       x = unwind_parentheses(x)
       if x.is_a?(Puppet::Pops::Model::UnfoldExpression)
         result.concat(evaluate(x, scope))
       else
         result << evaluate(x, scope)
       end
     end
     result
   end
   private :unfold
 
   def unwind_parentheses(o)
     return o unless o.is_a?(Puppet::Pops::Model::ParenthesizedExpression)
     unwind_parentheses(o.expr)
   end
   private :unwind_parentheses
 end
diff --git a/spec/unit/pops/evaluator/evaluating_parser_spec.rb b/spec/unit/pops/evaluator/evaluating_parser_spec.rb
index ad492c530..884c795fa 100644
--- a/spec/unit/pops/evaluator/evaluating_parser_spec.rb
+++ b/spec/unit/pops/evaluator/evaluating_parser_spec.rb
@@ -1,1414 +1,1418 @@
 require 'spec_helper'
 
 require 'puppet/pops'
 require 'puppet/pops/evaluator/evaluator_impl'
 require 'puppet/loaders'
 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
 
     # These must be set since the 3x logic switches some behaviors on these even if the tests explicitly
     # use the 4x parser and evaluator.
     #
     Puppet[:parser] = 'future'
 
     # Puppetx cannot be loaded until the correct parser has been set (injector is turned off otherwise)
     require 'puppetx'
 
     # Tests needs a known configuration of node/scope/compiler since it parses and evaluates
     # snippets as the compiler will evaluate them, butwithout the overhead of compiling a complete
     # catalog for each tested expression.
     #
     @parser  = Puppet::Pops::Parser::EvaluatingParser.new
     @node = Puppet::Node.new('node.example.com')
     @node.environment = Puppet::Node::Environment.create(:testing, [])
     @compiler = Puppet::Parser::Compiler.new(@node)
     @scope = Puppet::Parser::Scope.new(@compiler)
     @scope.source = Puppet::Resource::Type.new(:node, 'node.example.com')
     @scope.parent = @compiler.topscope
   end
 
   let(:parser) {  @parser }
   let(:scope) { @scope }
   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,5])]"                               => [1,2,3,4,5],
       "[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.0 == 1 "      => true,
       "1.0 < 2  "      => true,
       "'1.0' < 'a'"    => true,
       "'1.0' < '' "    => false,
       "'1.0' < ' '"    => false,
       "'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 > 1" => /String > Integer/,
      "a >= 1" => /String >= Integer/,
      "a < 1" => /String < Integer/,
      "a <= 1" => /String <= Integer/,
      "1 > a" => /Integer > String/,
      "1 >= a" => /Integer >= String/,
      "1 < a" => /Integer < String/,
      "1 <= a" => /Integer <= String/,
    }.each do | source, error|
      it "should not allow comparison of String and Number '#{source}'" do
        expect { parser.evaluate_string(scope, source, __FILE__)}.to raise_error(error)
      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.*']"              => false, # String is not subtype of Regexp. PUP-957
       "$x = /a.*/ a =~ $x"              => true,
       "$x = Pattern['a.*'] a =~ $x"     => true,
       "1 =~ Integer"                    => true,
       "1 !~ Integer"                    => false,
       "undef =~ NotUndef"               => false,
       "undef !~ NotUndef"               => true,
       "[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
       "String[1] in bananas"          => false, # Philosophically true though :-)
       "'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']"              => false,
       "'15' in [1, 0xf]"              => false,
       "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
 
     {
       "if /(ana)/ in bananas {$1}" => 'ana',
       "if /(xyz)/ in bananas {$1} else {$1}" => nil,
       "$a = bananas =~ /(ana)/; $b = /(xyz)/ in bananas; $1" => 'ana',
       "$a = xyz =~ /(xyz)/; $b = /(ana)/ in bananas; $1" => 'ana',
       "if /p/ in [pineapple, bananas] {$0}" => 'p',
       "if /b/ in [pineapple, bananas] {$0}" => 'b',
     }.each do |source, result|
       it "sets match variables for a regexp search using in such that '#{source}' produces '#{result}'" do
           parser.evaluate_string(scope, source, __FILE__).should == result
       end
     end
 
     {
       'Any'  => ['NotUndef', 'Data', 'Scalar', 'Numeric', 'Integer', 'Float', 'Boolean', 'String', 'Pattern', 'Collection',
                     'Array', 'Hash', 'CatalogEntry', 'Resource', 'Class', 'Undef', 'File', 'NotYetKnownResourceType'],
 
       # Note, Data > Collection is false (so not included)
       'Data'    => ['Scalar', 'Numeric', 'Integer', 'Float', 'Boolean', 'String', 'Pattern', 'Array', 'Hash',],
       'Scalar' => ['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'"      => 0,
         "'- 2' + '2'"     => 0,
         '"-\t 2" + "2"'   => 0,
         "'+2' + '2'"      => 4,
         "'+ 2' + '2'"     => 4,
         "'2.2' + '2.2'"   => 4.4,
         "'-2.2' + '2.2'"  => 0.0,
         "'0xF7' + '010'"  => 0xFF,
         "'0xF7' + '0x8'"  => 0xFF,
         "'0367' + '010'"  => 0xFF,
         "'012.3' + '010'" => 20.3,
         "'-0x2' + '0x4'"  => 2,
         "'+0x2' + '0x4'"  => 6,
         "'-02' + '04'"    => 2,
         "'+02' + '04'"    => 6,
       }.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,
         '"-\n 2" + "2"'    => :error,
         '"-\v 2" + "2"'    => :error,
         '"-2\n" + "2"'     => :error,
         '"-2\n " + "2"'    => :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,
     }.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]"               => /attempt to assign to 'an Array Expression'/,
       "[a,b,c] = {b=>2,c=>3,a=>1}"      => /attempt to assign to 'an Array Expression'/,
     }.each do |source, result|
         it "should parse and evaluate the expression '#{source}' to error with #{result}" do
           expect { parser.evaluate_string(scope, source, __FILE__)}.to raise_error(Puppet::ParseError, result)
         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,
       "unless true {} 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',
       "case 1 {
          Integer : { yes }
          Type[Integer] : { no } }"                           => 'yes',
       "case Integer {
          Integer : { no }
          Type[Integer] : { yes } }"                          => 'yes',
       # supports unfold
       "case ringo {
          *[paul, john, ringo, george] : { 'beatle' } }"      => 'beatle',
 
       "case ringo {
          (*[paul, john, ringo, george]) : { 'beatle' } }"    => 'beatle',
 
       "case undef {
          undef : { 'yes' } }"                                => 'yes',
 
       "case undef {
          *undef : { 'no' }
          default :{ 'yes' }}"                                => 'yes',
 
       "case [green, 2, whatever] {
          [/ee/, Integer[0,10], default] : { 'yes' }
          default :{ 'no' }}"                                => 'yes',
 
+      "case [green, 2, whatever] {
+         default :{ 'no' }
+         [/ee/, Integer[0,10], default] : { 'yes' }}"        => 'yes',
+
       "case {a=>1, b=>2, whatever=>3, extra => ignored} {
          { a => Integer[0,5],
            b => Integer[0,5],
            whatever => default
          }       : { 'yes' }
          default : { 'no' }}"                               => '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, default => yes }"          => 'yes',
       "3 ? { 1 => no, default => yes, 3 => no }"          => 'no',
       "3 ? { 1 => no, 3 => no, default => yes }"          => 'no',
       "4 ? { 1 => no, default => yes, 3 => no }"          => 'yes',
       "4 ? { 1 => no, 3 => no, default => yes }"          => 'yes',
       "'banana' ? { /.*(ana).*/  => $1 }"                 => 'ana',
       "[2] ? { Array[String] => yes, Array => yes}"       => 'yes',
       "ringo ? *[paul, john, ringo, george] => 'beatle'"  => 'beatle',
       "ringo ? (*[paul, john, ringo, george]) => 'beatle'"=> 'beatle',
       "undef ? undef => 'yes'"                            => 'yes',
       "undef ? {*undef => 'no', default => 'yes'}"        => 'yes',
 
       "[green, 2, whatever] ? {
          [/ee/, Integer[0,10], default
          ]       => 'yes',
          default => 'no'}"                                => 'yes',
 
       "{a=>1, b=>2, whatever=>3, extra => ignored} ?
          {{ a => Integer[0,5],
            b => Integer[0,5],
            whatever => default
          }       => 'yes',
          default => 'no' }"                               => '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
 
     it 'fails if a selector does not match' do
       expect{parser.evaluate_string(scope, "2 ? 3 => 4")}.to raise_error(/No matching entry for selector parameter with value '2'/)
     end
   end
 
   context "When evaluator evaluated unfold" do
     {
       "*[1,2,3]"             => [1,2,3],
       "*1"                   => [1],
       "*'a'"                 => ['a']
     }.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
 
     it "should parse and evaluate the expression '*{a=>10, b=>20} to [['a',10],['b',20]]" do
       result = parser.evaluate_string(scope, '*{a=>10, b=>20}', __FILE__)
       expect(result).to include(['a', 10])
       expect(result).to include(['b', 20])
     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]"  => [],
       "[1,*[2,3],4]"     => [1,2,3,4],
       "[1,*[2,3],4][1]"  => 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, 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),
       "Array[Integer,1]"                => types.constrain_size(types.array_of(types.integer),1, :default),
       "Array[Integer,1,2]"              => types.constrain_size(types.array_of(types.integer),1, 2),
       "Array[Integer,Integer[1,2]]"     => types.constrain_size(types.array_of(types.integer),1, 2),
       "Array[Integer,Integer[1]]"       => types.constrain_size(types.array_of(types.integer),1, :default),
       "Hash[Integer,Integer]"           => types.hash_of(types.integer, types.integer),
       "Hash[Integer,Integer,1]"         => types.constrain_size(types.hash_of(types.integer, types.integer),1, :default),
       "Hash[Integer,Integer,1,2]"       => types.constrain_size(types.hash_of(types.integer, types.integer),1, 2),
       "Hash[Integer,Integer,Integer[1,2]]" => types.constrain_size(types.hash_of(types.integer, types.integer),1, 2),
       "Hash[Integer,Integer,Integer[1]]"   => types.constrain_size(types.hash_of(types.integer, types.integer),1, :default),
       "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')],
       "Pattern[a, /b/, Pattern[c], Regexp[d]]"  => types.pattern('a', 'b', 'c', 'd'),
       "String[1,2]"                     => types.constrain_size(types.string,1, 2),
       "String[Integer[1,2]]"            => types.constrain_size(types.string,1, 2),
       "String[Integer[1]]"              => types.constrain_size(types.string,1, :default),
     }.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,1,2,3]"        => 'Array-Type[] accepts 1 to 3 arguments. Got 4',
       "Array[Integer,String]"       => "A Type's size constraint arguments must be a single Integer type, or 1-2 integers (or default). Got a String-Type",
       "Hash[Integer,String, 1,2,3]" => 'Hash-Type[] accepts 2 to 4 arguments. Got 5',
       "'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",
       "NotUndef[0]"                 => 'NotUndef-Type[] argument must be a Type or a String. Got Fixnum',
       "NotUndef[a,b]"               => 'NotUndef-Type[] accepts 0 to 1 arguments. Got 2',
       "Resource[0]"                 => 'First argument to Resource[] must be a resource type or a String. Got Integer',
       "Resource[a, 0]"              => 'Error creating type specialization of a Resource-Type, Cannot use Integer where a resource title String is expected',
       "File[0]"                     => 'Error creating type specialization of a File-Type, Cannot use Integer where a resource title String is expected',
       "String[a]"                   => "A Type's size constraint arguments must be a single Integer type, or 1-2 integers (or default). Got a String",
       "Pattern[0]"                  => 'Error creating type specialization of a Pattern-Type, Cannot use Integer where String or Regexp or Pattern-Type or Regexp-Type is expected',
       "Regexp[0]"                   => 'Error creating type specialization of a Regexp-Type, Cannot use Integer 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)
         Puppet.override({:global_scope => scope}, "test") do
           scope.known_resource_types.import_ast(ast, '')
           ast.code.safeevaluate(scope).should == 'chocolate'
         end
       end
 
       # Resource default and override expressions and resource parameter access with []
       {
         # Properties
         "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",
         # Parameters
         "notify { id: withpath=>explicit} Notify[id][withpath]"                 => "explicit",
         "Notify { withpath=>by_default } notify { foo: } Notify[foo][withpath]" => "by_default",
         "notify {foo:}
          Notify[foo]{withpath=>by_override}
          Notify[foo][withpath]"                                                 => "by_override",
         # Metaparameters
         "notify { foo: tag => evoe} Notify[foo][tag]"                           => "evoe",
         # Does not produce the defaults for tag parameter (title, type or names of scopes)
         "notify { foo: } Notify[foo][tag]"                                      => nil,
         # But a default may be specified on the type
         "Notify { tag=>by_default } notify { foo: } Notify[foo][tag]"           => "by_default",
         "Notify { tag=>by_default }
          notify { foo: }
          Notify[foo]{ tag=>by_override }
          Notify[foo][tag]"                                                      => "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
 
       # Virtual and realized resource default and overridden resource parameter access with []
       {
         # Properties
         "@notify { id: message=>explicit } Notify[id][message]"                 => "explicit",
         "@notify { id: message=>explicit }
          realize Notify[id]
          Notify[id][message]"                                                   => "explicit",
         "Notify { message=>by_default } @notify { id: } Notify[id][message]"    => "by_default",
         "Notify { message=>by_default }
          @notify { id: tag=>thisone }
          Notify <| tag == thisone |>;
          Notify[id][message]"                                                   => "by_default",
         "@notify { id: } Notify[id]{message=>by_override} Notify[id][message]"  => "by_override",
         # Parameters
         "@notify { id: withpath=>explicit } Notify[id][withpath]"               => "explicit",
         "Notify { withpath=>by_default }
          @notify { id: }
          Notify[id][withpath]"                                                  => "by_default",
         "@notify { id: }
          realize Notify[id]
          Notify[id]{withpath=>by_override}
          Notify[id][withpath]"                                                  => "by_override",
         # Metaparameters
         "@notify { id: tag=>explicit } Notify[id][tag]"                         => "explicit",
       }.each do |source, result|
         it "parses and evaluates virtual and realized resources in the expression '#{source}' to #{result}" do
           expect(parser.evaluate_string(scope, source, __FILE__)).to eq(result)
         end
       end
 
       # Exported resource attributes
       {
         "@@notify { id: message=>explicit } Notify[id][message]"                => "explicit",
         "@@notify { id: message=>explicit, tag=>thisone }
          Notify <<| tag == thisone |>>
          Notify[id][message]"                                                   => "explicit",
       }.each do |source, result|
         it "parses and evaluates exported resources in the expression '#{source}' to #{result}" do
           expect(parser.evaluate_string(scope, source, __FILE__)).to eq(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'/,
         # NOTE: these meta-esque parameters are not recognized as such
         "notify { id: message=>explicit} Notify[id][title]"   => /does not have a parameter called 'title'/,
         "notify { id: message=>explicit} Notify[id]['type']"   => /does not have a parameter called 'type'/,
         "notify { id: message=>explicit } Notify[id]{message=>override}" => /'message' is already set on Notify\[id\]/
       }.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[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,
       "! ''"            => false,
       "! 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",
       # unfolds
       'sprintf( *["x%iy", $a] )'              => "x10y",
       '( *["x%iy", $a] ).sprintf'             => "x10y",
       '((*["x%iy", $a])).sprintf'             => "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
 
     it "provides location information on error in unparenthesized call logic" do
     expect{parser.evaluate_string(scope, "include non_existing_class", __FILE__)}.to raise_error(Puppet::ParseError, /line 1\:1/)
     end
 
     it 'defaults can be given in a lambda and used only when arg is missing' do
       env_loader = @compiler.loaders.public_environment_loader
       fc = Puppet::Functions.create_function(:test) do
         dispatch :test do
           param 'Integer', 'count'
           required_block_param
         end
         def test(count)
           yield(*[].fill(10, 0, count))
         end
       end
       the_func = fc.new({}, env_loader)
       env_loader.add_entry(:function, 'test', the_func, __FILE__)
       expect(parser.evaluate_string(scope, "test(1) |$x, $y=20| { $x + $y}")).to eql(30)
       expect(parser.evaluate_string(scope, "test(2) |$x, $y=20| { $x + $y}")).to eql(20)
     end
 
     it 'a given undef does not select the default value' do
       env_loader = @compiler.loaders.public_environment_loader
       fc = Puppet::Functions.create_function(:test) do
         dispatch :test do
           param 'Any', 'lambda_arg'
           required_block_param
         end
         def test(lambda_arg)
           yield(lambda_arg)
         end
       end
       the_func = fc.new({}, env_loader)
       env_loader.add_entry(:function, 'test', the_func, __FILE__)
 
       expect(parser.evaluate_string(scope, "test(undef) |$x=20| { $x == undef}")).to eql(true)
     end
 
     it 'a given undef is given as nil' do
       env_loader = @compiler.loaders.public_environment_loader
       fc = Puppet::Functions.create_function(:assert_no_undef) do
         dispatch :assert_no_undef do
           param 'Any', 'x'
         end
 
         def assert_no_undef(x)
           case x
           when Array
             return unless x.include?(:undef)
           when Hash
             return unless x.keys.include?(:undef) || x.values.include?(:undef)
           else
             return unless x == :undef
           end
           raise "contains :undef"
         end
       end
 
       the_func = fc.new({}, env_loader)
       env_loader.add_entry(:function, 'assert_no_undef', the_func, __FILE__)
 
       expect{parser.evaluate_string(scope, "assert_no_undef(undef)")}.to_not raise_error()
       expect{parser.evaluate_string(scope, "assert_no_undef([undef])")}.to_not raise_error()
       expect{parser.evaluate_string(scope, "assert_no_undef({undef => 1})")}.to_not raise_error()
       expect{parser.evaluate_string(scope, "assert_no_undef({1 => undef})")}.to_not raise_error()
     end
 
     context 'using the 3x function api' do
       it 'can call a 3x function' do
         Puppet::Parser::Functions.newfunction("bazinga", :type => :rvalue) { |args| args[0] }
         parser.evaluate_string(scope, "bazinga(42)", __FILE__).should == 42
       end
 
       it 'maps :undef to empty string' do
         Puppet::Parser::Functions.newfunction("bazinga", :type => :rvalue) { |args| args[0] }
         parser.evaluate_string(scope, "$a = {} bazinga($a[nope])", __FILE__).should == ''
         parser.evaluate_string(scope, "bazinga(undef)", __FILE__).should == ''
       end
 
       it 'does not map :undef to empty string in arrays' do
         Puppet::Parser::Functions.newfunction("bazinga", :type => :rvalue) { |args| args[0][0] }
         parser.evaluate_string(scope, "$a = {} $b = [$a[nope]] bazinga($b)", __FILE__).should == :undef
         parser.evaluate_string(scope, "bazinga([undef])", __FILE__).should == :undef
       end
 
       it 'does not map :undef to empty string in hashes' do
         Puppet::Parser::Functions.newfunction("bazinga", :type => :rvalue) { |args| args[0]['a'] }
         parser.evaluate_string(scope, "$a = {} $b = {a => $a[nope]} bazinga($b)", __FILE__).should == :undef
         parser.evaluate_string(scope, "bazinga({a => undef})", __FILE__).should == :undef
       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
 
     it 'should accept a variable with leading underscore when used directly' do
       source = '$_x = 10; "$_x"'
       expect(parser.evaluate_string(scope, source, __FILE__)).to eql('10')
     end
 
     it 'should accept a variable with leading underscore when used as an expression' do
       source = '$_x = 10; "${_x}"'
       expect(parser.evaluate_string(scope, source, __FILE__)).to eql('10')
     end
 
     it 'should accept a numeric variable expressed as $n' do
       source = '$x = "abc123def" =~ /(abc)(123)(def)/; "${$2}"'
       expect(parser.evaluate_string(scope, source, __FILE__)).to eql('123')
     end
 
     it 'should accept a numeric variable expressed as just an integer' do
       source = '$x = "abc123def" =~ /(abc)(123)(def)/; "${2}"'
       expect(parser.evaluate_string(scope, source, __FILE__)).to eql('123')
     end
 
     it 'should accept a numeric variable expressed as $n in an access operation' do
       source = '$x = "abc123def" =~ /(abc)(123)(def)/; "${$0[4,3]}"'
       expect(parser.evaluate_string(scope, source, __FILE__)).to eql('23d')
     end
 
     it 'should accept a numeric variable expressed as just an integer in an access operation' do
       source = '$x = "abc123def" =~ /(abc)(123)(def)/; "${0[4,3]}"'
       expect(parser.evaluate_string(scope, source, __FILE__)).to eql('23d')
     end
 
     {
       '"value is ${a*2} yo"'  => :error,
     }.each do |source, result|
         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::ParseErrorWithIssue, /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
 
     context "an initial underscore in the last segment of a var name is allowed" do
       { '$_a  = 1'   => 1,
         '$__a = 1'   => 1,
       }.each do |source, value|
         it "as in this example '#{source}'" do
           parser.evaluate_string(scope, source, __FILE__).should == value
         end
       end
     end
   end
 
   context "When evaluating relationships" 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 [File[a], File[b]] -> [File[x], File[y]]' do
       source = "[File[a], File[b]] -> [File[x], File[y]]"
       parser.evaluate_string(scope, source, __FILE__)
       scope.compiler.should have_relationship(['File', 'a', '->', 'File', 'x'])
       scope.compiler.should have_relationship(['File', 'b', '->', 'File', 'x'])
       scope.compiler.should have_relationship(['File', 'a', '->', 'File', 'y'])
       scope.compiler.should have_relationship(['File', 'b', '->', 'File', 'y'])
     end
 
     it 'should tolerate (eliminate) duplicates in operands' do
       source = "[File[a], File[a]] -> File[x]"
       parser.evaluate_string(scope, source, __FILE__)
       scope.compiler.should have_relationship(['File', 'a', '->', 'File', 'x'])
       scope.compiler.relationships.size.should == 1
     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 "When evaluating heredoc" do
     it "evaluates plain heredoc" do
       src = "@(END)\nThis is\nheredoc text\nEND\n"
       parser.evaluate_string(scope, src).should == "This is\nheredoc text\n"
     end
 
     it "parses heredoc with margin" do
       src = [
       "@(END)",
       "   This is",
       "   heredoc text",
       "   | END",
       ""
       ].join("\n")
       parser.evaluate_string(scope, src).should == "This is\nheredoc text\n"
     end
 
     it "parses heredoc with margin and right newline trim" do
       src = [
       "@(END)",
       "   This is",
       "   heredoc text",
       "   |- END",
       ""
       ].join("\n")
       parser.evaluate_string(scope, src).should == "This is\nheredoc text"
     end
 
     it "parses escape specification" do
       src = <<-CODE
       @(END/t)
       Tex\\tt\\n
       |- END
       CODE
       parser.evaluate_string(scope, src).should == "Tex\tt\\n"
     end
 
     it "parses syntax checked specification" do
       src = <<-CODE
       @(END:json)
       ["foo", "bar"]
       |- END
       CODE
       parser.evaluate_string(scope, src).should == '["foo", "bar"]'
     end
 
     it "parses syntax checked specification with error and reports it" do
       src = <<-CODE
       @(END:json)
       ['foo', "bar"]
       |- END
       CODE
       expect { parser.evaluate_string(scope, src)}.to raise_error(/Cannot parse invalid JSON string/)
     end
 
     it "parses interpolated heredoc expression" do
       src = <<-CODE
       $name = 'Fjodor'
       @("END")
       Hello $name
       |- END
       CODE
       parser.evaluate_string(scope, src).should == "Hello Fjodor"
     end
 
     it "parses interpolated heredoc expression with escapes" do
       src = <<-CODE
       $name = 'Fjodor'
       @("END")
       Hello\\ \\$name
       |- END
       CODE
       parser.evaluate_string(scope, src).should == "Hello\\ \\Fjodor"
     end
 
   end
   context "Handles Deprecations and Discontinuations" do
     it 'of import statements' do
       source = "\nimport foo"
       # 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.evaluate_string(scope, source) }.to raise_error(/'import' has been discontinued.*line 2:1/)
     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.evaluate_string(scope, source) }.to raise_error(
         /Illegal Resource Type expression, expected result to be a type name, or untitled Resource.*line 1:2/)
     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::Util::Log.expects(:create).with(has_entries(:level => :err, :message => "Invalid use of expression. A 'define' expression does not produce a value", :line => 1, :pos => 6))
       Puppet::Util::Log.expects(:create).with(has_entries(:level => :err, :message => 'Classes, definitions, and nodes may only appear at toplevel or inside other classes', :line => 1, :pos => 6))
       expect { parser.parse_string("$a = define foo { }", nil) }.to raise_error(/2 errors/)
     end
 
     it 'for non r-value producing class' do
       Puppet::Util::Log.expects(:create).with(has_entries(:level => :err, :message => 'Invalid use of expression. A Host Class Definition does not produce a value', :line => 1, :pos => 6))
       Puppet::Util::Log.expects(:create).with(has_entries(:level => :err, :message => 'Classes, definitions, and nodes may only appear at toplevel or inside other classes', :line => 1, :pos => 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::Util::Log.expects(:create).with(has_entries(:level => :err, :message => 'Invalid use of expression. A Node Definition does not produce a value', :line => 1, :pos => 6))
       Puppet::Util::Log.expects(:create).with(has_entries(:level => :err, :message => 'Classes, definitions, and nodes may only appear at toplevel or inside other classes', :line => 1, :pos => 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
 
   context 'does not leak variables' do
     it 'local variables are gone when lambda ends' do
       source = <<-SOURCE
       [1,2,3].each |$x| { $y = $x}
       $a = $y
       SOURCE
       expect do
         parser.evaluate_string(scope, source)
       end.to raise_error(/Unknown variable: 'y'/)
     end
 
     it 'lambda parameters are gone when lambda ends' do
       source = <<-SOURCE
       [1,2,3].each |$x| { $y = $x}
       $a = $x
       SOURCE
       expect do
         parser.evaluate_string(scope, source)
       end.to raise_error(/Unknown variable: 'x'/)
     end
 
     it 'does not leak match variables' do
       source = <<-SOURCE
       if 'xyz' =~ /(x)(y)(z)/ { notice $2 }
       case 'abc' {
         /(a)(b)(c)/ : { $x = $2 }
       }
       "-$x-$2-"
       SOURCE
       expect(parser.evaluate_string(scope, source)).to eq('-b--')
     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
diff --git a/spec/unit/pops/migration_spec.rb b/spec/unit/pops/migration_spec.rb
index 4f506faec..8c049131b 100644
--- a/spec/unit/pops/migration_spec.rb
+++ b/spec/unit/pops/migration_spec.rb
@@ -1,180 +1,180 @@
 require 'spec_helper'
 
 require 'puppet/pops'
 require 'puppet/pops/evaluator/evaluator_impl'
 require 'puppet/loaders'
 require 'puppet_spec/pops'
 require 'puppet_spec/scope'
 require 'puppet/parser/e4_parser_adapter'
 
 describe 'Puppet::Pops::MigrationMigrationChecker' do
   include PuppetSpec::Pops
   include PuppetSpec::Scope
   before(:each) do
     Puppet[:strict_variables] = true
 
     # These must be set since the 3x logic switches some behaviors on these even if the tests explicitly
     # use the 4x parser and evaluator.
     #
     Puppet[:parser] = 'future'
 
     # Puppetx cannot be loaded until the correct parser has been set (injector is turned off otherwise)
     require 'puppetx'
 
     # Tests needs a known configuration of node/scope/compiler since it parses and evaluates
     # snippets as the compiler will evaluate them, butwithout the overhead of compiling a complete
     # catalog for each tested expression.
     #
     @parser  = Puppet::Pops::Parser::EvaluatingParser.new
     @node = Puppet::Node.new('node.example.com')
     @node.environment = Puppet::Node::Environment.create(:testing, [])
     @compiler = Puppet::Parser::Compiler.new(@node)
     @scope = Puppet::Parser::Scope.new(@compiler)
     @scope.source = Puppet::Resource::Type.new(:node, 'node.example.com')
     @scope.parent = @compiler.topscope
   end
 
   let(:scope) { @scope }
 
   describe "when there is no MigrationChecker in the PuppetContext" do
     it "a null implementation of the MigrationChecker gets created (once per impl that needs one)" do
       migration_checker = Puppet::Pops::Migration::MigrationChecker.new()
       Puppet::Pops::Migration::MigrationChecker.expects(:new).at_least_once.returns(migration_checker)
       Puppet::Pops::Parser::EvaluatingParser.new.evaluate_string(scope, "1", __FILE__).should == 1
       Puppet::Pops::Migration::MigrationChecker.unstub(:new)
     end
   end
 
   describe "when there is a MigrationChecker in the Puppet Context" do
     it "does not create any MigrationChecker instances when parsing and evaluating" do
       migration_checker = mock()
       Puppet::Pops::Migration::MigrationChecker.expects(:new).never
       Puppet.override({:migration_checker => migration_checker}, "test-context") do
         Puppet::Pops::Parser::EvaluatingParser.new.evaluate_string(scope, "true", __FILE__)
       end
       Puppet::Pops::Migration::MigrationChecker.unstub(:new)
     end
   end
 
   describe "when validating parsed code" do
     it "is called for each integer" do
       migration_checker = mock()
       migration_checker.expects(:report_ambiguous_integer).times(3)
       Puppet.override({:migration_checker => migration_checker}, "migration-context") do
         Puppet::Pops::Parser::EvaluatingParser.new.evaluate_string(scope, "$a = [1,2,3]", __FILE__)
       end
     end
 
     it "is called for each float" do
       migration_checker = mock()
       migration_checker.expects(:report_ambiguous_float).times(3)
       Puppet.override({:migration_checker => migration_checker}, "migration-context") do
         Puppet::Pops::Parser::EvaluatingParser.new.evaluate_string(scope, "$a = [1.0,2.0,3.1415]", __FILE__)
       end
     end
 
     it "last expressions in blocks are checked" do
       migration_checker = mock()
       migration_checker.expects(:report_array_last_in_block).twice  # the program itself is a block too
       Puppet.override({:migration_checker => migration_checker}, "migration-context") do
         Puppet::Pops::Parser::EvaluatingParser.new.evaluate_string(scope, "$b = {} if true { $a = $b [false] }", __FILE__)
       end
     end
 
   end
 
   describe "when evaluating code" do
     it "is called for boolean coercion of String" do
       migration_checker = mock()
       migration_checker.expects(:report_empty_string_true).times(2)
       Puppet.override({:migration_checker => migration_checker}, "migration-context") do
         Puppet::Pops::Parser::EvaluatingParser.new.evaluate_string(scope, "$a = ('a' and '')", __FILE__)
       end
     end
 
     context "with a case expression" do
       it "the test expression is checked for UC_bareword" do
         migration_checker = mock()
         migration_checker.expects(:report_uc_bareword_type).once
         migration_checker.expects(:report_option_type_mismatch).once
         Puppet.override({:migration_checker => migration_checker}, "migration-context") do
-          Puppet::Pops::Parser::EvaluatingParser.new.evaluate_string(scope, "case Foo { default: {}}", __FILE__)
+          Puppet::Pops::Parser::EvaluatingParser.new.evaluate_string(scope, "case Foo { 'Foo': {}}", __FILE__)
         end
       end
 
       it "all case options are checked for UC_bareword" do
         migration_checker = mock()
         migration_checker.expects(:report_uc_bareword_type).times(4)
         migration_checker.expects(:report_option_type_mismatch).times(4)
         Puppet.override({:migration_checker => migration_checker}, "migration-context") do
           Puppet::Pops::Parser::EvaluatingParser.new.evaluate_string(scope, 
             "case true { Foo, Bar: {} Fee, 'not': {}}", __FILE__)
         end
       end
     end
 
     context "with a selector expression" do
       it "the test expression is checked for UC_bareword" do
         migration_checker = mock()
         migration_checker.expects(:report_uc_bareword_type).once
         Puppet.override({:migration_checker => migration_checker}, "migration-context") do
           Puppet::Pops::Parser::EvaluatingParser.new.evaluate_string(scope, "Foo ? { default => false}", __FILE__)
         end
       end
 
       it "all options are checked for UC_bareword" do
         migration_checker = mock()
         migration_checker.expects(:report_uc_bareword_type).times(3)
         migration_checker.expects(:report_option_type_mismatch).times(3)
         Puppet.override({:migration_checker => migration_checker}, "migration-context") do
           Puppet::Pops::Parser::EvaluatingParser.new.evaluate_string(scope, 
             "true ? { Foo => false, Bar => false, 'not' => false, default => true}", __FILE__)
         end
       end
     end
 
     context "with a comparison of" do
       ['==', '!=', ].each do |operator|
         it "'a' #{operator} 'b'" do
           migration_checker = mock()
           migration_checker.expects(:report_uc_bareword_type).twice
           migration_checker.expects(:report_equality_type_mismatch).once
           Puppet.override({:migration_checker => migration_checker}, "migration-context") do
             Puppet::Pops::Parser::EvaluatingParser.new.evaluate_string(scope, "'a' #{operator} 'b'", __FILE__)
           end
         end
       end
 
       ['<', '>', '<=', '>='].each do |operator|
         it "'a' #{operator} 'b'" do
           migration_checker = mock()
           migration_checker.expects(:report_uc_bareword_type).twice
           Puppet.override({:migration_checker => migration_checker}, "migration-context") do
             Puppet::Pops::Parser::EvaluatingParser.new.evaluate_string(scope, "'a' #{operator} 'b'", __FILE__)
           end
         end
       end
 
       ['=~', '!~'].each do |operator|
         it "'a' #{operator} /.*/" do
           migration_checker = mock()
           migration_checker.expects(:report_uc_bareword_type).once
           Puppet.override({:migration_checker => migration_checker}, "migration-context") do
             Puppet::Pops::Parser::EvaluatingParser.new.evaluate_string(scope, "'a' #{operator} /.*/", __FILE__)
           end
         end
       end
     end
 
     context "with an in operator" do
       it "'a' in [true,false]" do
         migration_checker = mock()
         migration_checker.expects(:report_uc_bareword_type).once
         migration_checker.expects(:report_in_expression).once
         Puppet.override({:migration_checker => migration_checker}, "migration-context") do
           Puppet::Pops::Parser::EvaluatingParser.new.evaluate_string(scope, "'a' in [true, false]", __FILE__)
         end
       end
     end
   end
 end