fluentd 0.14.4-x86-mingw32

data/test/config/test_element.rb

@@ -0,0 +1,403 @@
+require_relative '../helper'
+require 'fluent/config/element'
+require 'fluent/config/configure_proxy'
+require 'fluent/configurable'
+
+class TestConfigElement < ::Test::Unit::TestCase
+  def element(name = 'ROOT', arg = '', attrs = {}, elements = [], unused = nil)
+    Fluent::Config::Element.new(name, arg, attrs, elements, unused)
+  end
+
+  sub_test_case '#elements=' do
+    test 'elements can be set by others' do
+      e = element()
+      assert_equal [], e.elements
+
+      e1 = element('e1')
+      e2 = element('e2')
+      e.elements = [e1, e2]
+      assert_equal [e1, e2], e.elements
+    end
+  end
+
+  sub_test_case '#elements' do
+    setup do
+      @c1 = element('source')
+      @c2 = element('source', 'yay')
+      @c3 = element('match', 'test.**')
+      @c4 = element('label', '@mytest', {}, [ element('filter', '**'), element('match', '**') ])
+      children = [@c1, @c2, @c3, @c4]
+      @e = Fluent::Config::Element.new('ROOT', '', {}, children)
+    end
+
+    test 'returns all elements without arguments' do
+      assert_equal [@c1, @c2, @c3, @c4], @e.elements
+    end
+
+    test 'returns elements with specified names' do
+      assert_equal [@c1, @c2, @c3], @e.elements('source', 'match')
+      assert_equal [@c3, @c4], @e.elements('match', 'label')
+    end
+
+    test 'returns elements with specified name, and arg if specified' do
+      assert_equal [@c1, @c2], @e.elements(name: 'source')
+      assert_equal [@c2], @e.elements(name: 'source', arg: 'yay')
+    end
+
+    test 'keyword argument name/arg and names are exclusive' do
+      assert_raise ArgumentError do
+        @e.elements('source', name: 'match')
+      end
+      assert_raise ArgumentError do
+        @e.elements('source', 'match', name: 'label', arg: '@mytest')
+      end
+    end
+
+    test 'specifying only arg without name is invalid' do
+      assert_raise ArgumentError do
+        @e.elements(arg: '@mytest')
+      end
+    end
+  end
+
+  sub_test_case '#initialize' do
+    test 'creates object with blank attrs and elements' do
+      e = element('ROOT', '', {}, [])
+      assert_equal([], e.elements)
+    end
+
+    test 'creates object which contains attrs and elements' do
+      e = element('ROOT', '', {"k1" => "v1", "k2" => "v2"}, [
+                    element('test', 'mydata', {'k3' => 'v3'}, [])
+                  ])
+      assert_equal('ROOT', e.name)
+      assert_equal('',  e.arg)
+      assert_equal('v1', e["k1"])
+      assert_equal('v2', e["k2"])
+      assert_equal(1, e.elements.size)
+      e.each_element('test') do |el|
+        assert_equal('test', el.name)
+        assert_equal('mydata', el.arg)
+        assert_equal('v3', el["k3"])
+      end
+    end
+
+    test 'creates object which contains attrs, elements and unused' do
+      e = element('ROOT', '', {"k1" => "v1", "k2" => "v2", "k4" => "v4"}, [
+                    element('test', 'mydata', {'k3' => 'v3'}, [])
+                  ], "k3")
+      assert_equal("k3", e.unused)
+      assert_equal('ROOT', e.name)
+      assert_equal('',  e.arg)
+      assert_equal('v1', e["k1"])
+      assert_equal('v2', e["k2"])
+      assert_equal('v4', e["k4"])
+      assert_equal(1, e.elements.size)
+      e.each_element('test') do |el|
+        assert_equal('test', el.name)
+        assert_equal('mydata', el.arg)
+        assert_equal('v3', el["k3"])
+      end
+      assert_equal("k3", e.unused)
+    end
+  end
+
+  sub_test_case "@unused" do
+    sub_test_case '#[] has side effect for @unused' do
+      test 'without unused argument' do
+        e = element('ROOT', '', {"k1" => "v1", "k2" => "v2", "k4" => "v4"}, [
+                      element('test', 'mydata', {'k3' => 'v3'}, [])
+                    ])
+        assert_equal(["k1", "k2", "k4"], e.unused)
+        assert_equal('v1', e["k1"])
+        assert_equal(["k2", "k4"], e.unused)
+        assert_equal('v2', e["k2"])
+        assert_equal(["k4"], e.unused)
+        assert_equal('v4', e["k4"])
+        assert_equal([], e.unused)
+      end
+
+      test 'with unused argument' do
+        e = element('ROOT', '', {"k1" => "v1", "k2" => "v2", "k4" => "v4"}, [
+                      element('test', 'mydata', {'k3' => 'v3'}, [])
+                    ], ["k4"])
+        assert_equal(["k4"], e.unused)
+        assert_equal('v1', e["k1"])
+        assert_equal(["k4"], e.unused)
+        assert_equal('v2', e["k2"])
+        assert_equal(["k4"], e.unused)
+        assert_equal('v4', e["k4"])
+        # only consume for "k4"
+        assert_equal([], e.unused)
+      end
+    end
+  end
+
+  sub_test_case '#add_element' do
+    test 'elements can be set by #add_element' do
+      e = element()
+      assert_equal [], e.elements
+
+      e.add_element('e1', '')
+      e.add_element('e2', '')
+      assert_equal [element('e1', ''), element('e2', '')], e.elements
+    end
+  end
+
+  sub_test_case '#==' do
+    sub_test_case 'compare with two element objects' do
+      test 'equal' do
+        e1 = element('ROOT', '', {}, [])
+        e2 = element('ROOT', '', {}, [])
+        assert_true(e1 == e2)
+      end
+
+      data("differ args" => [Fluent::Config::Element.new('ROOT', '', {}, []),
+                             Fluent::Config::Element.new('ROOT', 'mydata', {}, [])],
+           "differ keys" => [Fluent::Config::Element.new('ROOT', 'mydata', {}, []),
+                             Fluent::Config::Element.new('ROOT', 'mydata', {"k1" => "v1"}, [])],
+           "differ elemnts" =>
+           [Fluent::Config::Element.new('ROOT', 'mydata', {"k1" => "v1"}, []),
+            Fluent::Config::Element.new('ROOT', 'mydata', {"k1" => "v1"}, [
+              Fluent::Config::Element.new('test', 'mydata', {'k3' => 'v3'}, [])
+            ])])
+      test 'not equal' do |data|
+        e1, e2 = data
+        assert_false(e1 == e2)
+      end
+    end
+  end
+
+  sub_test_case '#+' do
+    test 'can merge 2 elements: object side is primary' do
+      e1 = element('ROOT', 'mydata', {"k1" => "v1"}, [])
+      e2 = element('ROOT', 'mydata2', {"k1" => "ignored", "k2" => "v2"}, [
+                     element('test', 'ext', {'k3' => 'v3'}, [])
+                   ])
+      e = e1 + e2
+
+      assert_equal('ROOT', e.name)
+      assert_equal('mydata', e.arg)
+      assert_equal('v1', e['k1'])
+      assert_equal('v2', e['k2'])
+      assert_equal(1, e.elements.size)
+      e.each_element('test') do |el|
+        assert_equal('test', el.name)
+        assert_equal('ext', el.arg)
+        assert_equal('v3', el["k3"])
+      end
+    end
+  end
+
+  sub_test_case '#check_not_fetched' do
+    sub_test_case 'without unused' do
+      test 'can get attribute keys and original Config::Element' do
+        e = element('ROOT', 'mydata', {"k1" => "v1"}, [])
+        e.check_not_fetched { |key, elem|
+          assert_equal("k1", key)
+          assert_equal(e, elem)
+        }
+      end
+    end
+
+    sub_test_case 'with unused' do
+      test 'can get unused marked attribute keys and original Config::Element' do
+        e = element('ROOT', 'mydata', {"k1" => "v1", "k2" => "unused", "k3" => "k3"})
+        e.unused = "k2"
+        e.check_not_fetched { |key, elem|
+          assert_equal("k2", key)
+          assert_equal(e, elem)
+        }
+      end
+    end
+  end
+
+  sub_test_case '#has_key?' do
+    test 'can get boolean with key name' do
+      e = element('ROOT', 'mydata', {"k1" => "v1"}, [])
+      assert_true(e.has_key?("k1"))
+      assert_false(e.has_key?("noexistent"))
+    end
+  end
+
+
+  sub_test_case '#to_s' do
+    data("without v1_config" => [false, <<-CONF
+<ROOT>
+  k1 v1
+  k2 "stringVal"
+  <test ext>
+    k2 v2
+  </test>
+</ROOT>
+CONF
+                                ],
+         "with v1_config" => [true, <<-CONF
+<ROOT>
+  k1 v1
+  k2 "stringVal"
+  <test ext>
+    k2 v2
+  </test>
+</ROOT>
+CONF
+                             ],
+        )
+    test 'dump config element with #to_s' do |data|
+      v1_config, expected = data
+      e = element('ROOT', '', {'k1' => 'v1', "k2" =>"\"stringVal\""}, [
+                    element('test', 'ext', {'k2' => 'v2'}, [])
+                  ])
+      e.v1_config = v1_config
+      dump = expected
+      assert_not_equal(e.inspect, e.to_s)
+      assert_equal(dump, e.to_s)
+    end
+  end
+
+  sub_test_case '#inspect' do
+    test 'dump config element with #inspect' do
+      e = element('ROOT', '', {'k1' => 'v1'}, [
+                   element('test', 'ext', {'k2' => 'v2'}, [])
+                  ])
+      dump = <<-CONF
+name:ROOT, arg:, {\"k1\"=>\"v1\"}, [name:test, arg:ext, {\"k2\"=>\"v2\"}, []]
+CONF
+      assert_not_equal(e.to_s, e.inspect)
+      assert_equal(dump.chomp, e.inspect)
+    end
+  end
+
+  sub_test_case 'for sections which has secret parameter' do
+    setup do
+      @type_lookup = ->(type){ Fluent::Configurable.lookup_type(type) }
+      p1 = Fluent::Config::ConfigureProxy.new(:match, type_lookup: @type_lookup)
+      p1.config_param :str1, :string
+      p1.config_param :str2, :string, secret: true
+      p1.config_param :enum1, :enum, list: [:a, :b, :c]
+      p1.config_param :enum2, :enum, list: [:a, :b, :c], secret: true
+      p1.config_param :bool1, :bool
+      p1.config_param :bool2, :bool, secret: true
+      p1.config_param :int1, :integer
+      p1.config_param :int2, :integer, secret: true
+      p1.config_param :float1, :float
+      p1.config_param :float2, :float, secret: true
+      p2 = Fluent::Config::ConfigureProxy.new(:match, type_lookup: @type_lookup)
+      p2.config_param :size1, :size
+      p2.config_param :size2, :size, secret: true
+      p2.config_param :time1, :time
+      p2.config_param :time2, :time, secret: true
+      p2.config_param :array1, :array
+      p2.config_param :array2, :array, secret: true
+      p2.config_param :hash1, :hash
+      p2.config_param :hash2, :hash, secret: true
+      p1.config_section :mysection do
+        config_param :str1, :string
+        config_param :str2, :string, secret: true
+        config_param :enum1, :enum, list: [:a, :b, :c]
+        config_param :enum2, :enum, list: [:a, :b, :c], secret: true
+        config_param :bool1, :bool
+        config_param :bool2, :bool, secret: true
+        config_param :int1, :integer
+        config_param :int2, :integer, secret: true
+        config_param :float1, :float
+        config_param :float2, :float, secret: true
+        config_param :size1, :size
+        config_param :size2, :size, secret: true
+        config_param :time1, :time
+        config_param :time2, :time, secret: true
+        config_param :array1, :array
+        config_param :array2, :array, secret: true
+        config_param :hash1, :hash
+        config_param :hash2, :hash, secret: true
+      end
+      params = {
+        'str1' => 'aaa', 'str2' => 'bbb', 'enum1' => 'a', 'enum2' => 'b', 'bool1' => 'true', 'bool2' => 'yes',
+        'int1' => '1', 'int2' => '2', 'float1' => '1.0', 'float2' => '0.5', 'size1' => '1k', 'size2' => '1m',
+        'time1' => '5m', 'time2' => '3h', 'array1' => 'a,b,c', 'array2' => 'd,e,f',
+        'hash1' => 'a:1,b:2', 'hash2' => 'a:2,b:4',
+        'unknown1' => 'yay', 'unknown2' => 'boo',
+      }
+      e2 = Fluent::Config::Element.new('mysection', '', params.dup, [])
+      e2.corresponding_proxies << p1.sections.values.first
+      @e = Fluent::Config::Element.new('match', '**', params, [e2])
+      @e.corresponding_proxies << p1
+      @e.corresponding_proxies << p2
+    end
+
+    sub_test_case '#to_masked_element' do
+      test 'returns a new element object which has masked values for secret parameters and elements' do
+        e = @e.to_masked_element
+        assert_equal 'aaa',    e['str1']
+        assert_equal 'xxxxxx', e['str2']
+        assert_equal 'a',      e['enum1']
+        assert_equal 'xxxxxx', e['enum2']
+        assert_equal 'true',   e['bool1']
+        assert_equal 'xxxxxx', e['bool2']
+        assert_equal '1',      e['int1']
+        assert_equal 'xxxxxx', e['int2']
+        assert_equal '1.0',    e['float1']
+        assert_equal 'xxxxxx', e['float2']
+        assert_equal '1k',     e['size1']
+        assert_equal 'xxxxxx', e['size2']
+        assert_equal '5m',     e['time1']
+        assert_equal 'xxxxxx', e['time2']
+        assert_equal 'a,b,c',  e['array1']
+        assert_equal 'xxxxxx', e['array2']
+        assert_equal 'a:1,b:2', e['hash1']
+        assert_equal 'xxxxxx',  e['hash2']
+        assert_equal 'yay', e['unknown1']
+        assert_equal 'boo', e['unknown2']
+        e2 = e.elements.first
+        assert_equal 'aaa',    e2['str1']
+        assert_equal 'xxxxxx', e2['str2']
+        assert_equal 'a',      e2['enum1']
+        assert_equal 'xxxxxx', e2['enum2']
+        assert_equal 'true',   e2['bool1']
+        assert_equal 'xxxxxx', e2['bool2']
+        assert_equal '1',      e2['int1']
+        assert_equal 'xxxxxx', e2['int2']
+        assert_equal '1.0',    e2['float1']
+        assert_equal 'xxxxxx', e2['float2']
+        assert_equal '1k',     e2['size1']
+        assert_equal 'xxxxxx', e2['size2']
+        assert_equal '5m',     e2['time1']
+        assert_equal 'xxxxxx', e2['time2']
+        assert_equal 'a,b,c',  e2['array1']
+        assert_equal 'xxxxxx', e2['array2']
+        assert_equal 'a:1,b:2', e2['hash1']
+        assert_equal 'xxxxxx',  e2['hash2']
+        assert_equal 'yay', e2['unknown1']
+        assert_equal 'boo', e2['unknown2']
+      end
+    end
+
+    sub_test_case '#secret_param?' do
+      test 'returns boolean which shows values of given key will be masked' do
+        assert !@e.secret_param?('str1')
+        assert @e.secret_param?('str2')
+        assert !@e.elements.first.secret_param?('str1')
+        assert @e.elements.first.secret_param?('str2')
+      end
+    end
+
+    sub_test_case '#param_type' do
+      test 'returns parameter type which are registered in corresponding proxy' do
+        assert_equal :string, @e.param_type('str1')
+        assert_equal :string, @e.param_type('str2')
+        assert_equal :enum, @e.param_type('enum1')
+        assert_equal :enum, @e.param_type('enum2')
+        assert_nil @e.param_type('unknown1')
+        assert_nil @e.param_type('unknown2')
+      end
+    end
+
+    # sub_test_case '#dump_value'
+    sub_test_case '#dump_value' do
+      test 'dumps parameter_name and values with leading indentation' do
+        assert_equal "str1 aaa\n", @e.dump_value("str1", @e["str1"], "")
+        assert_equal "str2 xxxxxx\n", @e.dump_value("str2", @e["str2"], "")
+      end
+    end
+  end
+end

data/test/config/test_literal_parser.rb

@@ -0,0 +1,297 @@
+require_relative "../helper"
+require_relative 'assertions'
+require "fluent/config/error"
+require "fluent/config/literal_parser"
+require "fluent/config/v1_parser"
+require 'json'
+
+module Fluent::Config
+  class TestLiteralParser < ::Test::Unit::TestCase
+    def parse_text(text)
+      basepath = File.expand_path(File.dirname(__FILE__)+'/../../')
+      ss = StringScanner.new(text)
+      parser = Fluent::Config::V1Parser.new(ss, basepath, "(test)", eval_context)
+      parser.parse_literal
+    end
+
+    TestLiteralParserContext = Struct.new(:v1, :v2, :v3)
+
+    def v1
+      :test
+    end
+
+    def v2
+      true
+    end
+
+    def v3
+      nil
+    end
+
+    def eval_context
+      @eval_context ||= TestLiteralParserContext.new(v1, v2, v3)
+    end
+
+    sub_test_case 'boolean parsing' do
+      def test_true
+        assert_text_parsed_as('true', "true")
+      end
+      def test_false
+        assert_text_parsed_as('false', "false")
+      end
+      def test_trueX
+        assert_text_parsed_as('trueX', "trueX")
+      end
+      def test_falseX
+        assert_text_parsed_as('falseX', "falseX")
+      end
+    end
+
+    sub_test_case 'integer parsing' do
+      test('0') { assert_text_parsed_as('0', "0") }
+      test('1') { assert_text_parsed_as('1', "1") }
+      test('10') { assert_text_parsed_as('10', "10") }
+      test('-1') { assert_text_parsed_as('-1', "-1") }
+      test('-10') { assert_text_parsed_as('-10', "-10") }
+      test('0 ') { assert_text_parsed_as('0', "0 ") }
+      test(' -1 ') { assert_text_parsed_as("-1", ' -1 ') }
+      # string
+      test('01') { assert_text_parsed_as('01', "01") }
+      test('00') { assert_text_parsed_as('00', "00") }
+      test('-01') { assert_text_parsed_as('-01', "-01") }
+      test('-00') { assert_text_parsed_as('-00', "-00") }
+      test('0x61') { assert_text_parsed_as('0x61', "0x61") }
+      test('0s') { assert_text_parsed_as('0s', "0s") }
+    end
+
+    sub_test_case 'float parsing' do
+      test('1.1') { assert_text_parsed_as('1.1', "1.1") }
+      test('0.1') { assert_text_parsed_as('0.1', "0.1") }
+      test('0.0') { assert_text_parsed_as('0.0', "0.0") }
+      test('-1.1') { assert_text_parsed_as('-1.1', "-1.1") }
+      test('-0.1') { assert_text_parsed_as('-0.1', "-0.1") }
+      test('1.10') { assert_text_parsed_as('1.10', "1.10") }
+      # string
+      test('12e8') { assert_text_parsed_as('12e8', "12e8") }
+      test('12.1e7') { assert_text_parsed_as('12.1e7', "12.1e7") }
+      test('-12e8') { assert_text_parsed_as('-12e8', "-12e8") }
+      test('-12.1e7') { assert_text_parsed_as('-12.1e7', "-12.1e7") }
+      test('.0') { assert_text_parsed_as('.0', ".0") }
+      test('.1') { assert_text_parsed_as('.1', ".1") }
+      test('0.') { assert_text_parsed_as('0.', "0.") }
+      test('1.') { assert_text_parsed_as('1.', "1.") }
+      test('.0a') { assert_text_parsed_as('.0a', ".0a") }
+      test('1.a') { assert_text_parsed_as('1.a', "1.a") }
+      test('0@') { assert_text_parsed_as('0@', "0@") }
+    end
+
+    sub_test_case 'float keywords parsing' do
+      test('NaN') { assert_text_parsed_as('NaN', "NaN") }
+      test('Infinity') { assert_text_parsed_as('Infinity', "Infinity") }
+      test('-Infinity') { assert_text_parsed_as('-Infinity', "-Infinity") }
+      test('NaNX') { assert_text_parsed_as('NaNX', "NaNX") }
+      test('InfinityX') { assert_text_parsed_as('InfinityX', "InfinityX") }
+      test('-InfinityX') { assert_text_parsed_as('-InfinityX', "-InfinityX") }
+    end
+
+    sub_test_case 'double quoted string' do
+      test('""') { assert_text_parsed_as("", '""') }
+      test('"text"') { assert_text_parsed_as("text", '"text"') }
+      test('"\\""') { assert_text_parsed_as("\"", '"\\""') }
+      test('"\\t"') { assert_text_parsed_as("\t", '"\\t"') }
+      test('"\\n"') { assert_text_parsed_as("\n", '"\\n"') }
+      test('"\\r\\n"') { assert_text_parsed_as("\r\n", '"\\r\\n"') }
+      test('"\\f\\b"') { assert_text_parsed_as("\f\b", '"\\f\\b"') }
+      test('"\\.t"') { assert_text_parsed_as(".t", '"\\.t"') }
+      test('"\\$t"') { assert_text_parsed_as("$t", '"\\$t"') }
+      test('"\\"') { assert_text_parsed_as("#t", '"\\#t"') }
+      test('"\\z"') { assert_parse_error('"\\z"') }  # unknown escaped character
+      test('"\\0"') { assert_parse_error('"\\0"') }  # unknown escaped character
+      test('"\\1"') { assert_parse_error('"\\1"') }  # unknown escaped character
+      test('"t') { assert_parse_error('"t') }  # non-terminated quoted character
+      test("\"t\nt\"") { assert_text_parsed_as("t\nt", "\"t\nt\"" ) } # multiline string
+      test("\"t\\\nt\"") { assert_text_parsed_as("tt", "\"t\\\nt\"" ) } # multiline string
+      test('t"') { assert_text_parsed_as('t"', 't"') }
+      test('"."') { assert_text_parsed_as('.', '"."') }
+      test('"*"') { assert_text_parsed_as('*', '"*"') }
+      test('"@"') { assert_text_parsed_as('@', '"@"') }
+      test('"\\#{test}"') { assert_text_parsed_as("\#{test}", '"\\#{test}"') }
+      test('"$"') { assert_text_parsed_as('$', '"$"') }
+      test('"$t"') { assert_text_parsed_as('$t', '"$t"') }
+      test('"$}"') { assert_text_parsed_as('$}', '"$}"') }
+      test('"\\\\"') { assert_text_parsed_as("\\", '"\\\\"') }
+      test('"\\["') { assert_text_parsed_as("[", '"\\["') }
+    end
+
+    sub_test_case 'single quoted string' do
+      test("''") { assert_text_parsed_as("", "''") }
+      test("'text'") { assert_text_parsed_as("text", "'text'") }
+      test("'\\''") { assert_text_parsed_as('\'', "'\\''") }
+      test("'\\t'") { assert_text_parsed_as('\t', "'\\t'") }
+      test("'\\n'") { assert_text_parsed_as('\n', "'\\n'") }
+      test("'\\r\\n'") { assert_text_parsed_as('\r\n', "'\\r\\n'") }
+      test("'\\f\\b'") { assert_text_parsed_as('\f\b', "'\\f\\b'") }
+      test("'\\.t'") { assert_text_parsed_as('\.t', "'\\.t'") }
+      test("'\\$t'") { assert_text_parsed_as('\$t', "'\\$t'") }
+      test("'\\#t'") { assert_text_parsed_as('\#t', "'\\#t'") }
+      test("'\\z'") { assert_text_parsed_as('\z', "'\\z'") }
+      test("'\\0'") { assert_text_parsed_as('\0', "'\\0'") }
+      test("'\\1'") { assert_text_parsed_as('\1', "'\\1'") }
+      test("'t") { assert_parse_error("'t") }  # non-terminated quoted character
+      test("t'") { assert_text_parsed_as("t'", "t'") }
+      test("'.'") { assert_text_parsed_as('.', "'.'") }
+      test("'*'") { assert_text_parsed_as('*', "'*'") }
+      test("'@'") { assert_text_parsed_as('@', "'@'") }
+      test(%q['#{test}']) { assert_text_parsed_as('#{test}', %q['#{test}']) }
+      test("'$'") { assert_text_parsed_as('$', "'$'") }
+      test("'$t'") { assert_text_parsed_as('$t', "'$t'") }
+      test("'$}'") { assert_text_parsed_as('$}', "'$}'") }
+      test("'\\\\'") { assert_text_parsed_as('\\', "'\\\\'") }
+      test("'\\['") { assert_text_parsed_as('\[', "'\\['") }
+    end
+
+    sub_test_case 'nonquoted string parsing' do
+      test("''") { assert_text_parsed_as(nil, '') }
+      test('text') { assert_text_parsed_as('text', 'text') }
+      test('\"') { assert_text_parsed_as('\"', '\"') }
+      test('\t') { assert_text_parsed_as('\t', '\t') }
+      test('\n') { assert_text_parsed_as('\n', '\n') }
+      test('\r\n') { assert_text_parsed_as('\r\n', '\r\n') }
+      test('\f\b') { assert_text_parsed_as('\f\b', '\f\b') }
+      test('\.t') { assert_text_parsed_as('\.t', '\.t') }
+      test('\$t') { assert_text_parsed_as('\$t', '\$t') }
+      test('\#t') { assert_text_parsed_as('\#t', '\#t') }
+      test('\z') { assert_text_parsed_as('\z', '\z') }
+      test('\0') { assert_text_parsed_as('\0', '\0') }
+      test('\1') { assert_text_parsed_as('\1', '\1') }
+      test('.') { assert_text_parsed_as('.', '.') }
+      test('*') { assert_text_parsed_as('*', '*') }
+      test('@') { assert_text_parsed_as('@', '@') }
+      test('#{test}') { assert_text_parsed_as('#{test}', '#{test}') }
+      test('$') { assert_text_parsed_as('$', '$') }
+      test('$t') { assert_text_parsed_as('$t', '$t') }
+      test('$}') { assert_text_parsed_as('$}', '$}') }
+      test('\\\\') { assert_text_parsed_as('\\\\', '\\\\') }
+      test('\[') { assert_text_parsed_as('\[', '\[') }
+      test('#foo') { assert_text_parsed_as('#foo', '#foo') } # not comment out
+      test('foo#bar') { assert_text_parsed_as('foo#bar', 'foo#bar') } # not comment out
+      test(' text') { assert_text_parsed_as('text', ' text') } # remove starting spaces
+      test(' #foo') { assert_text_parsed_as('#foo', ' #foo') } # remove starting spaces
+      test('foo #bar') { assert_text_parsed_as('foo', 'foo #bar') } # comment out
+      test('foo\t#bar') { assert_text_parsed_as('foo', "foo\t#bar") } # comment out
+
+      test('t') { assert_text_parsed_as('t', 't') }
+      test('T') { assert_text_parsed_as('T', 'T') }
+      test('_') { assert_text_parsed_as('_', '_') }
+      test('T1') { assert_text_parsed_as('T1', 'T1') }
+      test('_2') { assert_text_parsed_as('_2', '_2') }
+      test('t0') { assert_text_parsed_as('t0', 't0') }
+      test('t@') { assert_text_parsed_as('t@', 't@') }
+      test('t-') { assert_text_parsed_as('t-', 't-') }
+      test('t.') { assert_text_parsed_as('t.', 't.') }
+      test('t+') { assert_text_parsed_as('t+', 't+') }
+      test('t/') { assert_text_parsed_as('t/', 't/') }
+      test('t=') { assert_text_parsed_as('t=', 't=') }
+      test('t,') { assert_text_parsed_as('t,', 't,') }
+      test('0t') { assert_text_parsed_as('0t', "0t") }
+      test('@1t') { assert_text_parsed_as('@1t', '@1t') }
+      test('-1t') { assert_text_parsed_as('-1t', '-1t') }
+      test('.1t') { assert_text_parsed_as('.1t', '.1t') }
+      test(',1t') { assert_text_parsed_as(',1t', ',1t') }
+      test('.t') { assert_text_parsed_as('.t', '.t') }
+      test('*t') { assert_text_parsed_as('*t', '*t') }
+      test('@t') { assert_text_parsed_as('@t', '@t') }
+      test('{t') { assert_parse_error('{t') }  # '{' begins map
+      test('t{') { assert_text_parsed_as('t{', 't{') }
+      test('}t') { assert_text_parsed_as('}t', '}t') }
+      test('[t') { assert_parse_error('[t') }  # '[' begins array
+      test('t[') { assert_text_parsed_as('t[', 't[') }
+      test(']t') { assert_text_parsed_as(']t', ']t') }
+      test('t:') { assert_text_parsed_as('t:', 't:') }
+      test('t;') { assert_text_parsed_as('t;', 't;') }
+      test('t?') { assert_text_parsed_as('t?', 't?') }
+      test('t^') { assert_text_parsed_as('t^', 't^') }
+      test('t`') { assert_text_parsed_as('t`', 't`') }
+      test('t~') { assert_text_parsed_as('t~', 't~') }
+      test('t|') { assert_text_parsed_as('t|', 't|') }
+      test('t>') { assert_text_parsed_as('t>', 't>') }
+      test('t<') { assert_text_parsed_as('t<', 't<') }
+      test('t(') { assert_text_parsed_as('t(', 't(') }
+    end
+
+    sub_test_case 'embedded ruby code parsing' do
+      test('"#{v1}"') { assert_text_parsed_as("#{v1}", '"#{v1}"') }
+      test('"#{v2}"') { assert_text_parsed_as("#{v2}", '"#{v2}"') }
+      test('"#{v3}"') { assert_text_parsed_as("#{v3}", '"#{v3}"') }
+      test('"#{1+1}"') { assert_text_parsed_as("2", '"#{1+1}"') }
+      test('"#{}"') { assert_text_parsed_as("", '"#{}"') }
+      test('"t#{v1}"') { assert_text_parsed_as("t#{v1}", '"t#{v1}"') }
+      test('"t#{v1}t"') { assert_text_parsed_as("t#{v1}t", '"t#{v1}t"') }
+      test('"#{"}"}"') { assert_text_parsed_as("}", '"#{"}"}"') }
+      test('"#{#}"') { assert_parse_error('"#{#}"') }  # error in embedded ruby code
+      test("\"\#{\n=begin\n}\"") { assert_parse_error("\"\#{\n=begin\n}\"") }  # error in embedded ruby code
+      test('"#{v1}foo#{v2}"') { assert_text_parsed_as("#{v1}foo#{v2}", '"#{v1}foo#{v2}"') }
+      test('"#{1+1}foo#{2+2}bar"') { assert_text_parsed_as("#{1+1}foo#{2+2}bar", '"#{1+1}foo#{2+2}bar"') }
+    end
+
+    sub_test_case 'array parsing' do
+      test('[]') { assert_text_parsed_as_json([], '[]') }
+      test('[1]') { assert_text_parsed_as_json([1], '[1]') }
+      test('[1,2]') { assert_text_parsed_as_json([1,2], '[1,2]') }
+      test('[1, 2]') { assert_text_parsed_as_json([1,2], '[1, 2]') }
+      test('[ 1 , 2 ]') { assert_text_parsed_as_json([1,2], '[ 1 , 2 ]') }
+      test('[1,2,]') { assert_parse_error('[1,2,]') } # TODO: Need trailing commas support?
+      test("[\n1\n,\n2\n]") { assert_text_parsed_as_json([1,2], "[\n1\n,\n2\n]") }
+      test('["a"]') { assert_text_parsed_as_json(["a"], '["a"]') }
+      test('["a","b"]') { assert_text_parsed_as_json(["a","b"], '["a","b"]') }
+      test('[ "a" , "b" ]') { assert_text_parsed_as_json(["a","b"], '[ "a" , "b" ]') }
+      test("[\n\"a\"\n,\n\"b\"\n]") { assert_text_parsed_as_json(["a","b"], "[\n\"a\"\n,\n\"b\"\n]") }
+      test('["ab","cd"]') { assert_text_parsed_as_json(["ab","cd"], '["ab","cd"]') }
+      json_array_with_js_comment = <<EOA
+[
+ "a", // this is a
+ "b", // this is b
+ "c"  // this is c
+]
+EOA
+      test(json_array_with_js_comment) { assert_text_parsed_as_json(["a","b","c"], json_array_with_js_comment) }
+      json_array_with_comment = <<EOA
+[
+ "a", # this is a
+ "b", # this is b
+ "c"  # this is c
+]
+EOA
+      test(json_array_with_comment) { assert_text_parsed_as_json(["a","b","c"], json_array_with_comment) }
+      json_array_with_tailing_comma = <<EOA
+[
+ "a", # this is a
+ "b", # this is b
+ "c", # this is c
+]
+EOA
+      test(json_array_with_tailing_comma) { assert_parse_error(json_array_with_tailing_comma) }
+    end
+
+    sub_test_case 'map parsing' do
+      test('{}') { assert_text_parsed_as_json({}, '{}') }
+      test('{"a":1}') { assert_text_parsed_as_json({"a"=>1}, '{"a":1}') }
+      test('{"a":1,"b":2}') { assert_text_parsed_as_json({"a"=>1,"b"=>2}, '{"a":1,"b":2}') }
+      test('{ "a" : 1 , "b" : 2 }') { assert_text_parsed_as_json({"a"=>1,"b"=>2}, '{ "a" : 1 , "b" : 2 }') }
+      test('{"a":1,"b":2,}') { assert_parse_error('{"a":1,"b":2,}') } # TODO: Need trailing commas support?
+      test('{\n\"a\"\n:\n1\n,\n\"b\"\n:\n2\n}') { assert_text_parsed_as_json({"a"=>1,"b"=>2}, "{\n\"a\"\n:\n1\n,\n\"b\"\n:\n2\n}") }
+      test('{"a":"b"}') { assert_text_parsed_as_json({"a"=>"b"}, '{"a":"b"}') }
+      test('{"a":"b","c":"d"}') { assert_text_parsed_as_json({"a"=>"b","c"=>"d"}, '{"a":"b","c":"d"}') }
+      test('{ "a" : "b" , "c" : "d" }') { assert_text_parsed_as_json({"a"=>"b","c"=>"d"}, '{ "a" : "b" , "c" : "d" }') }
+      test('{\n\"a\"\n:\n\"b\"\n,\n\"c\"\n:\n\"d\"\n}') { assert_text_parsed_as_json({"a"=>"b","c"=>"d"}, "{\n\"a\"\n:\n\"b\"\n,\n\"c\"\n:\n\"d\"\n}") }
+      json_hash_with_comment = <<EOH
+{
+ "a": 1, # this is a
+ "b": 2, # this is b
+ "c": 3  # this is c
+}
+EOH
+      test(json_hash_with_comment) { assert_text_parsed_as_json({"a"=>1,"b"=>2,"c"=>3}, json_hash_with_comment) }
+    end
+  end
+end