puppet 4.3.0 → 4.4.0

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

@@ -598,6 +598,11 @@ describe 'Puppet::Pops::Evaluator::EvaluatorImpl' do
       expect(result).to include(['b', 20])
     end
 
+    it "should create an array from an Iterator" do
+      expect(parser.evaluate_string(scope, '[1,2,3].reverse_each', __FILE__).is_a?(Array)).to be(false)
+      result = parser.evaluate_string(scope, '*[1,2,3].reverse_each', __FILE__)
+      expect(result).to eql([3,2,1])
+    end
   end
 
   context "When evaluator performs [] operations" do
@@ -861,7 +866,8 @@ describe 'Puppet::Pops::Evaluator::EvaluatorImpl' do
         # 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\]/
+        "notify { id: message=>explicit } Notify[id]{message=>override}" => /'message' is already set on Notify\[id\]/,
+        "notify { id: message => 'once', message => 'twice' }" => /'message' has already been set/
       }.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)
@@ -960,7 +966,7 @@ describe 'Puppet::Pops::Evaluator::EvaluatorImpl' do
       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/)
+    expect{parser.evaluate_string(scope, "include non_existing_class", __FILE__)}.to raise_error(Puppet::ParseError, /:1:1/)
     end
 
     it 'defaults can be given in a lambda and used only when arg is missing' do

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

@@ -55,10 +55,10 @@ module EvaluatorRspecHelper
     result = evaluator.evaluate(in_top_scope.current, top_scope)
     if in_local_scope
       # This is really bad in 3.x scope
-      elevel = top_scope.ephemeral_level
-      top_scope.new_ephemeral(true)
-      result = evaluator.evaluate(in_local_scope.current, top_scope)
-      top_scope.unset_ephemeral_var(elevel)
+      top_scope.with_guarded_scope do
+        top_scope.new_ephemeral(true)
+        result = evaluator.evaluate(in_local_scope.current, top_scope)
+      end
     end
     if in_top_scope_again
       result = evaluator.evaluate(in_top_scope_again.current, top_scope)

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

@@ -0,0 +1,63 @@
+require 'spec_helper'
+
+require 'puppet/pops'
+require 'puppet/pops/evaluator/json_strict_literal_evaluator'
+
+describe "Puppet::Pops::Evaluator::JsonStrictLiteralEvaluator" do
+  let(:parser) {  Puppet::Pops::Parser::EvaluatingParser.new }
+  let(:leval)  {  Puppet::Pops::Evaluator::JsonStrictLiteralEvaluator.new }
+
+  { "1"       => 1,
+    "3.14"    => 3.14,
+    "true"    => true,
+    "false"   => false,
+    "'1'"     => '1',
+    "'a'"     => 'a',
+    '"a"'     => 'a',
+    'a'       => 'a',
+    'a::b'    => 'a::b',
+    'undef'   => nil,
+
+    # collections
+    '[1,2,3]'     => [1,2,3],
+    '{a=>1,b=>2}' => {'a' => 1, 'b' => 2},
+    '[undef]'     => [nil],
+    '{a=>undef}'  => { 'a' => nil }
+
+  }.each do |source, result|
+    it "evaluates '#{source}' to #{result}" do
+      expect(leval.literal(parser.parse_string(source))).to eq(result)
+    end
+  end
+
+  [ '1+1', 
+    'File',
+    '[1,2, 1+2]',
+    '{a=>1+1}', 
+    'Integer[1]', 
+    '"x$y"', 
+    '"x${y}z"'
+  ].each do |source|
+    it "throws :not_literal for non literal expression '#{source}'" do
+      expect{leval.literal(parser.parse_string('1+1'))}.to throw_symbol(:not_literal)
+    end
+  end
+
+  [ 'default', 
+    '/.*/', 
+    '{1=>100}', 
+    '{undef => 10}',
+    '{default => 10}',
+    '{/.*/ => 10}',
+    '{"ok" => {1 => 100}}',
+    '[default]',
+    '[[default]]',
+    '[/.*/]',
+    '[[/.*/]]',
+    '[{1 => 100}]',
+  ].each do |source|
+    it "throws :not_literal for values not representable as pure JSON '#{source}'" do
+      expect{leval.literal(parser.parse_string('1+1'))}.to throw_symbol(:not_literal)
+    end
+  end
+end

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

@@ -16,4 +16,10 @@ describe 'when converting to 3.x' do
     converted = Puppet::Pops::Evaluator::Runtime3Converter.instance.catalog_type_to_split_type_title(t)
     expect(converted).to eql(['class', 'kermit'])
   end
+
+  it "errors on attempts to convert an 'Iterator'" do
+    expect {
+      Puppet::Pops::Evaluator::Runtime3Converter.convert(Puppet::Pops::Types::Iterable.on((1..3)), {}, nil)
+    }.to raise_error(Puppet::Error, /Use of an Iterator is not supported here/)
+  end
 end

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

@@ -53,6 +53,59 @@ describe 'dependency loader' do
       expect(function.class.name).to eq('testmodule::foo')
       expect(function.is_a?(Puppet::Functions::Function)).to eq(true)
     end
+
+    describe "when parsing files from disk" do
+
+      # First line of Rune version of Rune poem at http://www.columbia.edu/~fdc/utf8/
+      # characters chosen since they will not parse on Windows with codepage 437 or 1252
+      # Section 3.2.1.3 of Ruby spec guarantees that \u strings are encoded as UTF-8
+      let (:node) { Puppet::Node.new('node') }
+      let (:rune_utf8) { "\u16A0\u16C7\u16BB" } # ᚠᛇᚻ
+      let (:code_utf8) do <<-CODE
+Puppet::Functions.create_function('testmodule::foo') {
+  def foo
+    return \"#{rune_utf8}\"
+  end
+}
+      CODE
+      end
+
+      context 'when loading files from disk' do
+        it 'should always read files as UTF-8' do
+          if Puppet.features.microsoft_windows? && Encoding.default_external == Encoding::UTF_8
+            raise 'This test must be run in a codepage other than 65001 to validate behavior'
+          end
+
+          module_dir = dir_containing('testmodule', {
+          'lib' => { 'puppet' => { 'functions' => { 'testmodule' => {
+            'foo.rb' => code_utf8
+          }}}}})
+
+          loader = loader_for('testmodule', module_dir)
+
+          function = loader.load_typed(typed_name(:function, 'testmodule::foo')).value
+          expect(function.call({})).to eq(rune_utf8)
+        end
+
+        it 'currently ignores the UTF-8 BOM (Byte Order Mark) when loading module files' do
+          bom = "\uFEFF"
+
+          if Puppet.features.microsoft_windows? && Encoding.default_external == Encoding::UTF_8
+            raise 'This test must be run in a codepage other than 65001 to validate behavior'
+          end
+
+          module_dir = dir_containing('testmodule', {
+          'lib' => { 'puppet' => { 'functions' => { 'testmodule' => {
+            'foo.rb' => "#{bom}#{code_utf8}"
+          }}}}})
+
+          loader = loader_for('testmodule', module_dir)
+
+          function = loader.load_typed(typed_name(:function, 'testmodule::foo')).value
+          expect(function.call({})).to eq(rune_utf8)
+        end
+      end
+    end
   end
 
   def loader_for(name, dir)

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

@@ -1,5 +1,6 @@
 require 'spec_helper'
 require 'puppet_spec/files'
+require 'puppet_spec/compiler'
 
 require 'puppet/pops'
 require 'puppet/loaders'
@@ -25,12 +26,15 @@ end
 
 describe 'loaders' do
   include PuppetSpec::Files
+  include PuppetSpec::Compiler
 
   let(:module_without_metadata) { File.join(config_dir('wo_metadata_module'), 'modules') }
   let(:module_without_lib) { File.join(config_dir('module_no_lib'), 'modules') }
   let(:mix_4x_and_3x_functions) { config_dir('mix_4x_and_3x_functions') }
   let(:module_with_metadata) { File.join(config_dir('single_module'), 'modules') }
   let(:dependent_modules_with_metadata) { config_dir('dependent_modules_with_metadata') }
+  let(:user_metadata_path) { File.join(dependent_modules_with_metadata, 'modules/user/metadata.json') }
+
   let(:empty_test_env) { environment_for() }
 
   # Loaders caches the puppet_system_loader, must reset between tests
@@ -103,7 +107,9 @@ describe 'loaders' do
     end
 
     it 'loader allows loading a function more than once' do
-      env = environment_for(dependent_modules_with_metadata)
+      File.stubs(:read).with(user_metadata_path).returns ''
+
+      env = environment_for(File.join(dependent_modules_with_metadata, 'modules'))
       loaders = Puppet::Pops::Loaders.new(env)
 
       moduleb_loader = loaders.private_loader_for_module('user')
@@ -116,13 +122,132 @@ describe 'loaders' do
   end
 
   context 'when loading from a module with metadata' do
+    let(:env) { environment_for(File.join(dependent_modules_with_metadata, 'modules')) }
+    let(:scope) { Puppet::Parser::Compiler.new(Puppet::Node.new("test", :environment => env)).newscope(nil) }
+
+    let(:environmentpath) { my_fixture_dir }
+    let(:node) { Puppet::Node.new('test', :facts => Puppet::Node::Facts.new('facts', {}), :environment => 'dependent_modules_with_metadata') }
+    let(:compiler) { Puppet::Parser::Compiler.new(node) }
+
+    let(:user_metadata) {
+      {
+        'name' => 'test-user',
+        'author' =>  'test',
+        'description' =>  '',
+        'license' =>  '',
+        'source' =>  '',
+        'version' =>  '1.0.0',
+        'dependencies' =>  []
+      }
+    }
+
+    def compile_and_get_notifications(code)
+      Puppet[:code] = code
+      catalog = block_given? ? compiler.compile { |catalog| yield(compiler.topscope); catalog } : compiler.compile
+      catalog.resources.map(&:ref).select { |r| r.start_with?('Notify[') }.map { |r| r[7..-2] }
+    end
+
+    around(:each) do |example|
+      # Initialize settings to get a full compile as close as possible to a real
+      # environment load
+      Puppet.settings.initialize_global_settings
+
+      # Initialize loaders based on the environmentpath. It does not work to
+      # just set the setting environmentpath for some reason - this achieves the same:
+      # - first a loader is created, loading directory environments from the fixture (there is
+      # one environment, 'sample', which will be loaded since the node references this
+      # environment by name).
+      # - secondly, the created env loader is set as 'environments' in the puppet context.
+      #
+      environments = Puppet::Environments::Directories.new(environmentpath, [])
+      Puppet.override(:environments => environments) do
+        example.run
+      end
+    end
+
     it 'all dependent modules are visible' do
-      env = environment_for(dependent_modules_with_metadata)
+      File.stubs(:read).with(user_metadata_path).returns user_metadata.merge('dependencies' => [ { 'name' => 'test-usee'}, { 'name' => 'test-usee2'} ]).to_pson
       loaders = Puppet::Pops::Loaders.new(env)
 
       moduleb_loader = loaders.private_loader_for_module('user')
       function = moduleb_loader.load_typed(typed_name(:function, 'user::caller')).value
       expect(function.call({})).to eql("usee::callee() was told 'passed value' + I am user::caller()")
+
+      function = moduleb_loader.load_typed(typed_name(:function, 'user::caller2')).value
+      expect(function.call({})).to eql("usee2::callee() was told 'passed value' + I am user::caller2()")
+    end
+
+    [ 'outside a function', 'a puppet function declared under functions', 'a puppet function declared in init.pp', 'a ruby function'].each_with_index do |from, from_idx|
+      [ {:from => from, :called => 'a puppet function declared under functions', :expects => "I'm the function usee::usee_puppet()"},
+        {:from => from, :called => 'a puppet function declared in init.pp', :expects => "I'm the function usee::usee_puppet_init()"},
+        {:from => from, :called => 'a ruby function', :expects => "I'm the function usee::usee_ruby()"} ].each_with_index do |desc, called_idx|
+        case_number = from_idx * 3 + called_idx + 1
+        it "can call #{desc[:called]} from #{desc[:from]} when dependency is present in metadata.json" do
+          File.stubs(:read).with(user_metadata_path).returns user_metadata.merge('dependencies' => [ { 'name' => 'test-usee'} ]).to_pson
+          Puppet[:code] = "$case_number = #{case_number}\ninclude ::user"
+          catalog = compiler.compile
+          resource = catalog.resource('Notify', "case_#{case_number}")
+          expect(resource).not_to be_nil
+          expect(resource['message']).to eq(desc[:expects])
+        end
+
+        it "can call #{desc[:called]} from #{desc[:from]} when no metadata is present" do
+          Puppet::Module.any_instance.expects('has_metadata?').at_least_once.returns(false)
+          Puppet[:code] = "$case_number = #{case_number}\ninclude ::user"
+          catalog = compiler.compile
+          resource = catalog.resource('Notify', "case_#{case_number}")
+          expect(resource).not_to be_nil
+          expect(resource['message']).to eq(desc[:expects])
+        end
+
+        it 'can not call ruby function in a dependent module from outside a function if dependency is missing in existing metadata.json' do
+          File.stubs(:read).with(user_metadata_path).returns user_metadata.merge('dependencies' => []).to_pson
+          Puppet[:code] = "$case_number = #{case_number}\ninclude ::user"
+          expect { catalog = compiler.compile }.to raise_error(Puppet::Error, /Unknown function/)
+        end
+      end
+    end
+
+    it "a type can reference an autoloaded type alias from another module when dependency is present in metadata.json" do
+      File.stubs(:read).with(user_metadata_path).returns user_metadata.merge('dependencies' => [ { 'name' => 'test-usee'} ]).to_pson
+      expect(eval_and_collect_notices(<<-CODE, node)).to eq(['ok'])
+        assert_type(Usee::Zero, 0)
+        notice(ok)
+      CODE
+    end
+
+    it "a type can reference an autoloaded type alias from another module when no metadata is present" do
+      Puppet::Module.any_instance.expects('has_metadata?').at_least_once.returns(false)
+      expect(eval_and_collect_notices(<<-CODE, node)).to eq(['ok'])
+        assert_type(Usee::Zero, 0)
+        notice(ok)
+      CODE
+    end
+
+    it "a type can reference a type alias from another module when other module has it declared in init.pp" do
+      File.stubs(:read).with(user_metadata_path).returns user_metadata.merge('dependencies' => [ { 'name' => 'test-usee'} ]).to_pson
+      expect(eval_and_collect_notices(<<-CODE, node)).to eq(['ok'])
+        include 'usee'
+        assert_type(Usee::One, 1)
+        notice(ok)
+      CODE
+    end
+
+    it "an autoloaded type can reference an autoloaded type alias from another module when dependency is present in metadata.json" do
+      File.stubs(:read).with(user_metadata_path).returns user_metadata.merge('dependencies' => [ { 'name' => 'test-usee'} ]).to_pson
+      expect(eval_and_collect_notices(<<-CODE, node)).to eq(['ok'])
+        assert_type(User::WithUseeZero, [0])
+        notice(ok)
+      CODE
+    end
+
+    it "an autoloaded type can reference an autoloaded type alias from another module when other module has it declared in init.pp" do
+      File.stubs(:read).with(user_metadata_path).returns user_metadata.merge('dependencies' => [ { 'name' => 'test-usee'} ]).to_pson
+      expect(eval_and_collect_notices(<<-CODE, node)).to eq(['ok'])
+        include 'usee'
+        assert_type(User::WithUseeOne, [1])
+        notice(ok)
+      CODE
     end
   end
 

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

@@ -329,13 +329,19 @@ describe 'Lexer2' do
     end
   end
 
+  it 'detects unterminated multiline comment' do
+    expect { tokens_scanned_from("/* not terminated\nmultiline\ncomment") }.to raise_error(Puppet::ParseErrorWithIssue) { |e|
+      expect(e.issue_code).to be(Puppet::Pops::Issues::UNCLOSED_MLCOMMENT.issue_code)
+    }
+  end
+
   { "=~" => [:MATCH, "=~ /./"],
     "!~" => [:NOMATCH, "!~ /./"],
     ","  => [:COMMA, ", /./"],
     "("  => [:LPAREN, "( /./"],
-    "["  => [:LISTSTART, "[ /./"],
-    "["  => [[:NAME, :LBRACK], "a[ /./"],
-    "["  => [[:NAME, :LISTSTART], "a [ /./"],
+    "[ (liststart)"             => [:LISTSTART, "[ /./"],
+    "[ (LBRACK)"                => [[:NAME, :LBRACK], "a[ /./"],
+    "[ (liststart after name)"  => [[:NAME, :LISTSTART], "a [ /./"],
     "{"  => [:LBRACE, "{ /./"],
     "+"  => [:PLUS, "+ /./"],
     "-"  => [:MINUS, "- /./"],
@@ -471,6 +477,18 @@ describe 'Lexer2' do
       end
     end
   end
+  context 'when not given multi byte characters' do
+    it 'produces byte offsets for tokens' do
+      code = <<-"CODE"
+1 2\n3
+      CODE
+      expect(tokens_scanned_from(code)).to match_tokens2(
+        [:NUMBER, '1', {:line => 1, :offset => 0, :length=>1}],
+        [:NUMBER, '2', {:line => 1, :offset => 2, :length=>1}],
+        [:NUMBER, '3', {:line => 2, :offset => 4, :length=>1}]
+      )
+    end
+  end
 
   context 'when dealing with multi byte characters' do
     it 'should support unicode characters' do
@@ -480,6 +498,7 @@ describe 'Lexer2' do
       # >= Ruby 1.9.3 reports \u
        expect(tokens_scanned_from(code)).to match_tokens2([:STRING, "x\u2713y"])
     end
+
     it 'should support unicode characters in long form' do
       code = <<-CODE
       "x\\u{1f452}y"
@@ -487,6 +506,23 @@ describe 'Lexer2' do
       expect(tokens_scanned_from(code)).to match_tokens2([:STRING, "x\u{1f452}y"])
     end
 
+    it 'produces byte offsets that counts each byte in a comment' do
+      code = <<-"CODE"
+      # \u{0400}\na
+      CODE
+      expect(tokens_scanned_from(code.strip)).to match_tokens2([:NAME, 'a', {:line => 2, :offset => 5, :length=>1}])
+    end
+
+    it 'produces byte offsets that counts each byte in value token' do
+      code = <<-"CODE"
+      '\u{0400}'\na
+      CODE
+      expect(tokens_scanned_from(code.strip)).to match_tokens2(
+        [:STRING, "\u{400}", {:line => 1, :offset => 0, :length=>4}],
+        [:NAME, 'a', {:line => 2, :offset => 5, :length=>1}]
+      )
+    end
+
     it 'should not select LISTSTART token when preceded by multibyte chars' do
       # This test is sensitive to the number of multibyte characters and position of the expressions
       # within the string - it is designed to fail if the position is calculated on the byte offset of the '['
@@ -696,4 +732,83 @@ describe 'Lexer2' do
       expect_issue('"asd', Puppet::Pops::Issues::UNCLOSED_QUOTE)
     end
   end
+
+  context 'when dealing with non UTF-8 and Byte Order Marks (BOMs)' do
+      {
+      'UTF_8'      => [0xEF, 0xBB, 0xBF],
+      'UTF_16_1'   => [0xFE, 0xFF],
+      'UTF_16_2'   => [0xFF, 0xFE],
+      'UTF_32_1'   => [0x00, 0x00, 0xFE, 0xFF],
+      'UTF_32_2'   => [0xFF, 0xFE, 0x00, 0x00],
+      'UTF_1'      => [0xF7, 0x64, 0x4C],
+      'UTF_EBCDIC' => [0xDD, 0x73, 0x66, 0x73],
+      'SCSU'       => [0x0E, 0xFE, 0xFF],
+      'BOCU'       => [0xFB, 0xEE, 0x28],
+      'GB_18030'   => [0x84, 0x31, 0x95, 0x33]
+      }.each do |key, bytes|
+        it "errors on the byte order mark for #{key} '[#{bytes.map() {|b| '%X' % b}.join(' ')}]'" do
+          format_name = key.split('_')[0,2].join('-')
+          bytes_str = "\\[#{bytes.map {|b| '%X' % b}.join(' ')}\\]"
+          fix =  " - remove these from the puppet source"
+          expect {
+            tokens_scanned_from(bytes.pack('C*'))
+          }.to raise_error(Puppet::ParseErrorWithIssue,
+            /Illegal #{format_name} .* at beginning of input: #{bytes_str}#{fix}/)
+        end
+
+       it "can use a possibly 'broken' UTF-16 string without problems for #{key}" do
+         format_name = key.split('_')[0,2].join('-')
+         string = bytes.pack('C*').force_encoding('UTF-16')
+         bytes_str = "\\[#{string.bytes.map {|b| '%X' % b}.join(' ')}\\]"
+         fix =  " - remove these from the puppet source"
+         expect {
+           tokens_scanned_from(string)
+         }.to raise_error(Puppet::ParseErrorWithIssue,
+           /Illegal #{format_name} .* at beginning of input: #{bytes_str}#{fix}/)
+       end
+    end
+  end
+end
+
+describe Puppet::Pops::Parser::Lexer2 do
+
+  include PuppetSpec::Files
+
+  # First line of Rune version of Rune poem at http://www.columbia.edu/~fdc/utf8/
+  # characters chosen since they will not parse on Windows with codepage 437 or 1252
+  # Section 3.2.1.3 of Ruby spec guarantees that \u strings are encoded as UTF-8
+  # Runes (may show up as garbage if font is not available): ᚠᛇᚻ᛫ᛒᛦᚦ᛫ᚠᚱᚩᚠᚢᚱ᛫ᚠᛁᚱᚪ᛫ᚷᛖᚻᚹᛦᛚᚳᚢᛗ
+  let (:rune_utf8) {
+    "\u16A0\u16C7\u16BB\u16EB\u16D2\u16E6\u16A6\u16EB\u16A0\u16B1\u16A9\u16A0\u16A2"
+    "\u16B1\u16EB\u16A0\u16C1\u16B1\u16AA\u16EB\u16B7\u16D6\u16BB\u16B9\u16E6\u16DA"
+    "\u16B3\u16A2\u16D7"
+  }
+
+  context 'when lexing files from disk' do
+    it 'should always read files as UTF-8' do
+      if Puppet.features.microsoft_windows? && Encoding.default_external == Encoding::UTF_8
+        raise 'This test must be run in a codepage other than 65001 to validate behavior'
+      end
+
+      manifest_code = "notify { '#{rune_utf8}': }"
+      manifest = file_containing('manifest.pp', manifest_code)
+      lexed_file = described_class.new.lex_file(manifest)
+
+      expect(lexed_file.string.encoding).to eq(Encoding::UTF_8)
+      expect(lexed_file.string).to eq(manifest_code)
+    end
+
+    it 'currently errors when the UTF-8 BOM (Byte Order Mark) is present when lexing files' do
+      bom = "\uFEFF"
+
+        manifest_code = "#{bom}notify { '#{rune_utf8}': }"
+        manifest = file_containing('manifest.pp', manifest_code)
+
+        expect {
+          lexed_file = described_class.new.lex_file(manifest)
+        }.to raise_error(Puppet::ParseErrorWithIssue,
+          'Illegal UTF-8 Byte Order mark at beginning of input: [EF BB BF] - remove these from the puppet source')
+    end
+  end
+
 end

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

@@ -26,6 +26,10 @@ describe "egrammar parsing function calls" do
         expect(dump(parse("foo(bar)"))).to eq("(invoke foo bar)")
       end
 
+      it "notice {a=>2}" do
+        expect(dump(parse("notice {a => 2}"))).to eq("(invoke notice ({} ('a' 2)))")
+      end
+
       it "foo(bar,)" do
         expect(dump(parse("foo(bar,)"))).to eq("(invoke foo bar)")
       end
@@ -37,6 +41,10 @@ describe "egrammar parsing function calls" do
       it "notice fqdn_rand(30)" do
         expect(dump(parse("notice fqdn_rand(30)"))).to eq('(invoke notice (call fqdn_rand 30))')
       end
+
+      it "notice type(42)" do
+        expect(dump(parse("notice type(42)"))).to eq('(invoke notice (call type 42))')
+      end
     end
 
     context "in nested scopes" do

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

@@ -13,4 +13,9 @@ module ParserRspecHelper
     parser = Puppet::Pops::Parser::Parser.new()
     parser.parse_string(code)
   end
+
+  def parse_epp(code)
+    parser = Puppet::Pops::Parser::EppParser.new()
+    parser.parse_string(code)
+  end
 end

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

@@ -31,6 +31,16 @@ describe Puppet::Pops::Parser::Parser do
     expect(adapter.length).to eq(0)
   end
 
+  it "multi byte characters in a comment are counted as individual bytes" do
+    parser = Puppet::Pops::Parser::Parser.new()
+    model = parser.parse_string("# \u{0400}comment\n").current
+    expect(model.class).to eq(Puppet::Pops::Model::Program)
+    expect(model.body.class).to eq(Puppet::Pops::Model::Nop)
+    adapter = Puppet::Pops::Adapters::SourcePosAdapter.adapt(model.body)
+    expect(adapter.offset).to eq(12)
+    expect(adapter.length).to eq(0)
+  end
+
   it "should raise an error with position information when error is raised from within parser" do
     parser = Puppet::Pops::Parser::Parser.new()
     the_error = nil

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

@@ -0,0 +1,26 @@
+require 'spec_helper'
+require 'puppet/pops'
+
+describe Puppet::Pops::Adapters::SourcePosAdapter do
+
+  it "multi byte characters in a comment does not interfere with AST node text extraction" do
+    parser = Puppet::Pops::Parser::Parser.new()
+    model = parser.parse_string("# \u{0400}comment\nabcdef#XXXXXXXXXX").current
+    expect(model.class).to eq(Puppet::Pops::Model::Program)
+    adapter = Puppet::Pops::Adapters::SourcePosAdapter.adapt(model.body)
+    expect(adapter.offset).to eq(12)
+    expect(adapter.length).to eq(6)
+    expect(adapter.extract_text).to eq('abcdef')
+  end
+
+  it "multi byte characters in a comment does not interfere with AST node text extraction" do
+    parser = Puppet::Pops::Parser::Parser.new()
+    model = parser.parse_string("# \u{0400}comment\n1 + 2#XXXXXXXXXX").current
+    expect(model.class).to eq(Puppet::Pops::Model::Program)
+    adapter = Puppet::Pops::Adapters::SourcePosAdapter.adapt(model.body)
+    expect(adapter.offset).to eq(14) # The '+'
+    expect(adapter.length).to eq(1)
+    expect(adapter.extract_tree_text).to eq('1 + 2')
+  end
+
+end