summaryrefslogtreecommitdiff
path: root/test/rdoc/test_rdoc_ruby_lex.rb
diff options
context:
space:
mode:
Diffstat (limited to 'test/rdoc/test_rdoc_ruby_lex.rb')
-rw-r--r--test/rdoc/test_rdoc_ruby_lex.rb1095
1 files changed, 0 insertions, 1095 deletions
diff --git a/test/rdoc/test_rdoc_ruby_lex.rb b/test/rdoc/test_rdoc_ruby_lex.rb
deleted file mode 100644
index 9ab5844b54..0000000000
--- a/test/rdoc/test_rdoc_ruby_lex.rb
+++ /dev/null
@@ -1,1095 +0,0 @@
-# coding: UTF-8
-# frozen_string_literal: false
-
-require 'rdoc/test_case'
-
-class TestRDocRubyLex < RDoc::TestCase
-
- def setup
- @TK = RDoc::RubyToken
- end
-
- def test_token_position
- tokens = RDoc::RubyLex.tokenize '[ 1, :a, nil ]', nil
-
- assert_equal '[', tokens[0].text
- assert_equal 0, tokens[0].seek
- assert_equal 1, tokens[0].line_no
- assert_equal 0, tokens[0].char_no
- assert_equal '1', tokens[2].text
- assert_equal 2, tokens[2].seek
- assert_equal 1, tokens[2].line_no
- assert_equal 2, tokens[2].char_no
- assert_equal ':a', tokens[5].text
- assert_equal 5, tokens[5].seek
- assert_equal 1, tokens[5].line_no
- assert_equal 5, tokens[5].char_no
- assert_equal 'nil', tokens[8].text
- assert_equal 9, tokens[8].seek
- assert_equal 1, tokens[8].line_no
- assert_equal 9, tokens[8].char_no
- assert_equal ']', tokens[10].text
- assert_equal 13, tokens[10].seek
- assert_equal 1, tokens[10].line_no
- assert_equal 13, tokens[10].char_no
- end
-
- def test_class_tokenize
- tokens = RDoc::RubyLex.tokenize "def x() end", nil
-
- expected = [
- @TK::TkDEF .new( 0, 1, 0, "def"),
- @TK::TkSPACE .new( 3, 1, 3, " "),
- @TK::TkIDENTIFIER.new( 4, 1, 4, "x"),
- @TK::TkLPAREN .new( 5, 1, 5, "("),
- @TK::TkRPAREN .new( 6, 1, 6, ")"),
- @TK::TkSPACE .new( 7, 1, 7, " "),
- @TK::TkEND .new( 8, 1, 8, "end"),
- @TK::TkNL .new(11, 1, 11, "\n"),
- ]
-
- assert_equal expected, tokens
- end
-
- def test_class_tokenize___END__
- tokens = RDoc::RubyLex.tokenize '__END__', nil
-
- expected = [
- @TK::TkEND_OF_SCRIPT.new(0, 1, 0, '__END__'),
- @TK::TkNL .new(7, 1, 7, "\n"),
- ]
-
- assert_equal expected, tokens
- end
-
- def test_class_tokenize___ENCODING__
- tokens = RDoc::RubyLex.tokenize '__ENCODING__', nil
-
- expected = [
- @TK::Tk__ENCODING__.new( 0, 1, 0, '__ENCODING__'),
- @TK::TkNL .new(12, 1, 12, "\n"),
- ]
-
- assert_equal expected, tokens
- end
-
- def test_class_tokenize_character_literal
- tokens = RDoc::RubyLex.tokenize "?c", nil
-
- expected = [
- @TK::TkCHAR.new( 0, 1, 0, "?c"),
- @TK::TkNL .new( 2, 1, 2, "\n"),
- ]
-
- assert_equal expected, tokens
- end
-
- def test_class_tokenize_character_literal_with_escape
- tokens = RDoc::RubyLex.tokenize "?\\s", nil
-
- expected = [
- @TK::TkCHAR.new( 0, 1, 0, "?\\s"),
- @TK::TkNL .new( 3, 1, 3, "\n"),
- ]
-
- assert_equal expected, tokens
- end
-
- def test_class_tokenize_def_heredoc
- tokens = RDoc::RubyLex.tokenize <<-'RUBY', nil
-def x
- <<E
-Line 1
-Line 2
-E
-end
- RUBY
-
- expected = [
- @TK::TkDEF .new( 0, 1, 0, 'def'),
- @TK::TkSPACE .new( 3, 1, 3, ' '),
- @TK::TkIDENTIFIER.new( 4, 1, 4, 'x'),
- @TK::TkNL .new( 5, 1, 5, "\n"),
- @TK::TkSPACE .new( 6, 2, 0, ' '),
-
- @TK::TkHEREDOCBEG.new( 8, 2, 2, '<<E'),
- @TK::TkNL .new(11, 2, 6, "\n"),
- @TK::TkHEREDOC .new(11, 2, 6, "Line 1\nLine 2\n"),
- @TK::TkHEREDOCEND.new(27, 5, 26, "E\n"),
- @TK::TkEND .new(28, 6, 0, 'end'),
- @TK::TkNL .new(31, 6, 28, "\n"),
- ]
-
- assert_equal expected, tokens
- end
-
- def test_class_tokenize_reserved_keyword_with_args
- tokens = RDoc::RubyLex.tokenize <<-'RUBY', nil
-yield :foo
-super :bar
-defined? :baz
- RUBY
-
- expected = [
- @TK::TkYIELD .new( 0, 1, 0, "yield"),
- @TK::TkSPACE .new( 5, 1, 5, " "),
- @TK::TkSYMBOL .new( 6, 1, 6, ":foo"),
- @TK::TkNL .new(10, 1, 10, "\n"),
- @TK::TkSUPER .new(11, 2, 0, "super"),
- @TK::TkSPACE .new(16, 2, 5, " "),
- @TK::TkSYMBOL .new(17, 2, 6, ":bar"),
- @TK::TkNL .new(21, 2, 11, "\n"),
- @TK::TkDEFINED.new(22, 3, 0, "defined?"),
- @TK::TkSPACE .new(30, 3, 8, " "),
- @TK::TkSYMBOL .new(31, 3, 9, ":baz"),
- @TK::TkNL .new(35, 3, 22, "\n")
- ]
-
- assert_equal expected, tokens
- end
-
- def test_class_tokenize_hash_symbol
- tokens = RDoc::RubyLex.tokenize '{ class:"foo" }', nil
-
- expected = [
- @TK::TkLBRACE.new( 0, 1, 0, '{'),
- @TK::TkSPACE .new( 1, 1, 1, ' '),
- @TK::TkSYMBOL.new( 2, 1, 2, 'class:'),
- @TK::TkSTRING.new( 8, 1, 8, '"foo"'),
- @TK::TkSPACE .new(13, 1, 13, ' '),
- @TK::TkRBRACE.new(14, 1, 14, '}'),
- @TK::TkNL .new(15, 1, 15, "\n"),
- ]
-
- assert_equal expected, tokens
- end
-
- def test_class_tokenize_double_colon_is_not_hash_symbol
- tokens = RDoc::RubyLex.tokenize 'self.class::Row', nil
-
- expected = [
- @TK::TkSELF .new( 0, 1, 0, "self"),
- @TK::TkDOT .new( 4, 1, 4, "."),
- @TK::TkIDENTIFIER.new( 5, 1, 5, "class"),
- @TK::TkCOLON2 .new(10, 1, 10, "::"),
- @TK::TkCONSTANT .new(12, 1, 12, "Row"),
- @TK::TkNL .new(15, 1, 15, "\n"),
- ]
-
- assert_equal expected, tokens
- end
-
- def test_class_tokenize_safe_nav_operator
- tokens = RDoc::RubyLex.tokenize 'receiver&.meth', nil
-
- expected = [
- @TK::TkIDENTIFIER.new( 0, 1, 0, "receiver"),
- @TK::TkSAFENAV .new( 8, 1, 8, "&."),
- @TK::TkIDENTIFIER.new(10, 1, 10, "meth"),
- @TK::TkNL .new(14, 1, 14, "\n"),
- ]
-
- assert_equal expected, tokens
- end
-
- def test_class_tokenize_hash_rocket
- tokens = RDoc::RubyLex.tokenize '{ :class => "foo" }', nil
-
- expected = [
- @TK::TkLBRACE .new( 0, 1, 0, '{'),
- @TK::TkSPACE .new( 1, 1, 1, ' '),
- @TK::TkSYMBOL .new( 2, 1, 2, ':class'),
- @TK::TkSPACE .new( 8, 1, 8, ' '),
- @TK::TkHASHROCKET.new( 9, 1, 9, '=>'),
- @TK::TkSPACE .new(11, 1, 11, ' '),
- @TK::TkSTRING .new(12, 1, 12, '"foo"'),
- @TK::TkSPACE .new(17, 1, 17, ' '),
- @TK::TkRBRACE .new(18, 1, 18, '}'),
- @TK::TkNL .new(19, 1, 19, "\n"),
- ]
-
- assert_equal expected, tokens
- end
-
- def test_class_tokenize_heredoc_CR_NL
- tokens = RDoc::RubyLex.tokenize <<-RUBY, nil
-string = <<-STRING\r
-Line 1\r
-Line 2\r
- STRING\r
- RUBY
-
- expected = [
- @TK::TkIDENTIFIER.new( 0, 1, 0, 'string'),
- @TK::TkSPACE .new( 6, 1, 6, ' '),
- @TK::TkASSIGN .new( 7, 1, 7, '='),
- @TK::TkSPACE .new( 8, 1, 8, ' '),
- @TK::TkHEREDOCBEG.new( 9, 1, 9, '<<-STRING'),
- @TK::TkSPACE .new(18, 1, 18, "\r"),
- @TK::TkNL .new(19, 1, 19, "\n"),
- @TK::TkHEREDOC .new(19, 1, 19,
- %Q{Line 1\nLine 2\n}),
- @TK::TkHEREDOCEND.new(45, 4, 36, " STRING\n"),
- ]
-
- assert_equal expected, tokens
- end
-
- def test_class_tokenize_opassign
- tokens = RDoc::RubyLex.tokenize <<'RUBY', nil
-a %= b
-a /= b
-a -= b
-a += b
-a |= b
-a &= b
-a >>= b
-a <<= b
-a *= b
-a &&= b
-a ||= b
-a **= b
-RUBY
-
- expected = [
- @TK::TkIDENTIFIER.new( 0, 1, 0, "a"),
- @TK::TkSPACE .new( 1, 1, 1, " "),
- @TK::TkOPASGN .new( 2, 1, 2, "%"),
- @TK::TkSPACE .new( 4, 1, 4, " "),
- @TK::TkIDENTIFIER.new( 5, 1, 5, "b"),
- @TK::TkNL .new( 6, 1, 6, "\n"),
- @TK::TkIDENTIFIER.new( 7, 2, 0, "a"),
- @TK::TkSPACE .new( 8, 2, 1, " "),
- @TK::TkOPASGN .new( 9, 2, 2, "/"),
- @TK::TkSPACE .new( 11, 2, 4, " "),
- @TK::TkIDENTIFIER.new( 12, 2, 5, "b"),
- @TK::TkNL .new( 13, 2, 7, "\n"),
- @TK::TkIDENTIFIER.new( 14, 3, 0, "a"),
- @TK::TkSPACE .new( 15, 3, 1, " "),
- @TK::TkOPASGN .new( 16, 3, 2, "-"),
- @TK::TkSPACE .new( 18, 3, 4, " "),
- @TK::TkIDENTIFIER.new( 19, 3, 5, "b"),
- @TK::TkNL .new( 20, 3, 14, "\n"),
- @TK::TkIDENTIFIER.new( 21, 4, 0, "a"),
- @TK::TkSPACE .new( 22, 4, 1, " "),
- @TK::TkOPASGN .new( 23, 4, 2, "+"),
- @TK::TkSPACE .new( 25, 4, 4, " "),
- @TK::TkIDENTIFIER.new( 26, 4, 5, "b"),
- @TK::TkNL .new( 27, 4, 21, "\n"),
- @TK::TkIDENTIFIER.new( 28, 5, 0, "a"),
- @TK::TkSPACE .new( 29, 5, 1, " "),
- @TK::TkOPASGN .new( 30, 5, 2, "|"),
- @TK::TkSPACE .new( 32, 5, 4, " "),
- @TK::TkIDENTIFIER.new( 33, 5, 5, "b"),
- @TK::TkNL .new( 34, 5, 28, "\n"),
- @TK::TkIDENTIFIER.new( 35, 6, 0, "a"),
- @TK::TkSPACE .new( 36, 6, 1, " "),
- @TK::TkOPASGN .new( 37, 6, 2, "&"),
- @TK::TkSPACE .new( 39, 6, 4, " "),
- @TK::TkIDENTIFIER.new( 40, 6, 5, "b"),
- @TK::TkNL .new( 41, 6, 35, "\n"),
- @TK::TkIDENTIFIER.new( 42, 7, 0, "a"),
- @TK::TkSPACE .new( 43, 7, 1, " "),
- @TK::TkOPASGN .new( 44, 7, 2, ">>"),
- @TK::TkSPACE .new( 47, 7, 5, " "),
- @TK::TkIDENTIFIER.new( 48, 7, 6, "b"),
- @TK::TkNL .new( 49, 7, 42, "\n"),
- @TK::TkIDENTIFIER.new( 50, 8, 0, "a"),
- @TK::TkSPACE .new( 51, 8, 1, " "),
- @TK::TkOPASGN .new( 52, 8, 2, "<<"),
- @TK::TkSPACE .new( 55, 8, 5, " "),
- @TK::TkIDENTIFIER.new( 56, 8, 6, "b"),
- @TK::TkNL .new( 57, 8, 50, "\n"),
- @TK::TkIDENTIFIER.new( 58, 9, 0, "a"),
- @TK::TkSPACE .new( 59, 9, 1, " "),
- @TK::TkOPASGN .new( 60, 9, 2, "*"),
- @TK::TkSPACE .new( 62, 9, 4, " "),
- @TK::TkIDENTIFIER.new( 63, 9, 5, "b"),
- @TK::TkNL .new( 64, 9, 58, "\n"),
- @TK::TkIDENTIFIER.new( 65, 10, 0, "a"),
- @TK::TkSPACE .new( 66, 10, 1, " "),
- @TK::TkOPASGN .new( 67, 10, 2, "&&"),
- @TK::TkSPACE .new( 70, 10, 5, " "),
- @TK::TkIDENTIFIER.new( 71, 10, 6, "b"),
- @TK::TkNL .new( 72, 10, 65, "\n"),
- @TK::TkIDENTIFIER.new( 73, 11, 0, "a"),
- @TK::TkSPACE .new( 74, 11, 1, " "),
- @TK::TkOPASGN .new( 75, 11, 2, "||"),
- @TK::TkSPACE .new( 78, 11, 5, " "),
- @TK::TkIDENTIFIER.new( 79, 11, 6, "b"),
- @TK::TkNL .new( 80, 11, 73, "\n"),
- @TK::TkIDENTIFIER.new( 81, 12, 0, "a"),
- @TK::TkSPACE .new( 82, 12, 1, " "),
- @TK::TkOPASGN .new( 83, 12, 2, "**"),
- @TK::TkSPACE .new( 86, 12, 5, " "),
- @TK::TkIDENTIFIER.new( 87, 12, 6, "b"),
- @TK::TkNL .new( 88, 12, 81, "\n"),
- ]
-
- assert_equal expected, tokens
- end
-
- def test_class_tokenize_heredoc_call
- tokens = RDoc::RubyLex.tokenize <<-'RUBY', nil
-string = <<-STRING.chomp
-Line 1
-Line 2
- STRING
- RUBY
-
- expected = [
- @TK::TkIDENTIFIER.new( 0, 1, 0, 'string'),
- @TK::TkSPACE .new( 6, 1, 6, ' '),
- @TK::TkASSIGN .new( 7, 1, 7, '='),
- @TK::TkSPACE .new( 8, 1, 8, ' '),
- @TK::TkHEREDOCBEG.new( 9, 1, 9, '<<-STRING'),
- @TK::TkDOT .new(18, 1, 18, '.'),
- @TK::TkIDENTIFIER.new(19, 1, 19, 'chomp'),
- @TK::TkNL .new(24, 1, 24, "\n"),
- @TK::TkHEREDOC .new(24, 1, 24, "Line 1\nLine 2\n"),
- @TK::TkHEREDOCEND.new(47, 4, 39, " STRING\n"),
- ]
-
- assert_equal expected, tokens
- end
-
- def test_class_tokenize_heredoc_indent
- tokens = RDoc::RubyLex.tokenize <<-'RUBY', nil
-string = <<-STRING
-Line 1
-Line 2
- STRING
- RUBY
-
- expected = [
- @TK::TkIDENTIFIER.new( 0, 1, 0, 'string'),
- @TK::TkSPACE .new( 6, 1, 6, ' '),
- @TK::TkASSIGN .new( 7, 1, 7, '='),
- @TK::TkSPACE .new( 8, 1, 8, ' '),
-
-
- @TK::TkHEREDOCBEG.new( 9, 1, 9, '<<-STRING'),
- @TK::TkNL .new(18, 1, 18, "\n"),
- @TK::TkHEREDOC .new(18, 1, 18, "Line 1\nLine 2\n"),
- @TK::TkHEREDOCEND.new(41, 4, 33, " STRING\n")
- ]
-
- assert_equal expected, tokens
- end
-
- def test_class_tokenize_heredoc_missing_end
- e = assert_raises RDoc::RubyLex::Error do
- RDoc::RubyLex.tokenize <<-'RUBY', nil
->> string1 = <<-TXT
->" That's swell
->" TXT
- RUBY
- end
-
- assert_equal 'Missing terminating TXT for string', e.message
- end
-
- def test_class_tokenize_heredoc_percent_N
- tokens = RDoc::RubyLex.tokenize <<-'RUBY', nil
-a b <<-U
-%N
-U
- RUBY
-
- expected = [
- @TK::TkIDENTIFIER.new( 0, 1, 0, 'a'),
- @TK::TkSPACE .new( 1, 1, 1, ' '),
- @TK::TkIDENTIFIER.new( 2, 1, 2, 'b'),
- @TK::TkSPACE .new( 3, 1, 3, ' '),
- @TK::TkHEREDOCBEG.new( 4, 1, 4, '<<-U'),
- @TK::TkNL .new( 8, 1, 8, "\n"),
- @TK::TkHEREDOC .new( 8, 1, 8, "%N\n"),
- @TK::TkHEREDOCEND.new(13, 3, 12, "U\n")
- ]
-
- assert_equal expected, tokens
- end
-
- def test_class_tokenize_identifier_high_unicode
- tokens = RDoc::RubyLex.tokenize '𝖒', nil
-
- expected = @TK::TkIDENTIFIER.new(0, 1, 0, '𝖒')
-
- assert_equal expected, tokens.first
- end
-
- def test_class_tokenize_lambda
- tokens = RDoc::RubyLex.tokenize 'a = -> x, y { x + y }', nil
-
- expected = [
- @TK::TkIDENTIFIER.new( 0, 1, 0, 'a'),
- @TK::TkSPACE .new( 1, 1, 1, ' '),
- @TK::TkASSIGN .new( 2, 1, 2, '='),
- @TK::TkSPACE .new( 3, 1, 3, ' '),
- @TK::TkLAMBDA .new( 4, 1, 4, '->'),
- @TK::TkSPACE .new( 6, 1, 6, ' '),
- @TK::TkIDENTIFIER.new( 7, 1, 7, 'x'),
- @TK::TkCOMMA .new( 8, 1, 8, ','),
- @TK::TkSPACE .new( 9, 1, 9, ' '),
- @TK::TkIDENTIFIER.new(10, 1, 10, 'y'),
- @TK::TkSPACE .new(11, 1, 11, ' '),
- @TK::TkfLBRACE .new(12, 1, 12, '{'),
- @TK::TkSPACE .new(13, 1, 13, ' '),
- @TK::TkIDENTIFIER.new(14, 1, 14, 'x'),
- @TK::TkSPACE .new(15, 1, 15, ' '),
- @TK::TkPLUS .new(16, 1, 16, '+'),
- @TK::TkSPACE .new(17, 1, 17, ' '),
- @TK::TkIDENTIFIER.new(18, 1, 18, 'y'),
- @TK::TkSPACE .new(19, 1, 19, ' '),
- @TK::TkRBRACE .new(20, 1, 20, '}'),
- @TK::TkNL .new(21, 1, 21, "\n")
- ]
-
- assert_equal expected, tokens
- end
-
- def test_class_tokenize_percent_1
- tokens = RDoc::RubyLex.tokenize 'v%10==10', nil
-
- expected = [
- @TK::TkIDENTIFIER.new(0, 1, 0, 'v'),
- @TK::TkMOD.new( 1, 1, 1, '%'),
- @TK::TkINTEGER.new( 2, 1, 2, '10'),
- @TK::TkEQ.new( 4, 1, 4, '=='),
- @TK::TkINTEGER.new( 6, 1, 6, '10'),
- @TK::TkNL.new( 8, 1, 8, "\n"),
- ]
-
- assert_equal expected, tokens
- end
-
- def test_class_tokenize_percent_r
- tokens = RDoc::RubyLex.tokenize '%r[hi]', nil
-
- expected = [
- @TK::TkREGEXP.new( 0, 1, 0, '%r[hi]'),
- @TK::TkNL .new( 6, 1, 6, "\n"),
- ]
-
- assert_equal expected, tokens
- end
-
- def test_class_tokenize_percent_r_with_slash
- tokens = RDoc::RubyLex.tokenize '%r/hi/', nil
-
- expected = [
- @TK::TkREGEXP.new( 0, 1, 0, '%r/hi/'),
- @TK::TkNL .new( 6, 1, 6, "\n"),
- ]
-
- assert_equal expected, tokens
- end
-
- def test_class_tokenize_percent_large_q
- tokens = RDoc::RubyLex.tokenize '%Q/hi/', nil
-
- expected = [
- @TK::TkSTRING.new( 0, 1, 0, '%Q/hi/'),
- @TK::TkNL .new( 6, 1, 6, "\n"),
- ]
-
- assert_equal expected, tokens
- end
-
- def test_class_tokenize_percent_large_q_with_double_quote
- tokens = RDoc::RubyLex.tokenize '%Q"hi"', nil
-
- expected = [
- @TK::TkSTRING.new( 0, 1, 0, '%Q"hi"'),
- @TK::TkNL .new( 6, 1, 6, "\n"),
- ]
-
- assert_equal expected, tokens
- end
-
- def test_class_tokenize_percent_w
- tokens = RDoc::RubyLex.tokenize '%w[hi]', nil
-
- expected = [
- @TK::TkDSTRING.new( 0, 1, 0, '%w[hi]'),
- @TK::TkNL .new( 6, 1, 6, "\n"),
- ]
-
- assert_equal expected, tokens
- end
-
- def test_class_tokenize_percent_w_quote
- tokens = RDoc::RubyLex.tokenize '%w"hi"', nil
-
- expected = [
- @TK::TkDSTRING.new( 0, 1, 0, '%w"hi"'),
- @TK::TkNL .new( 6, 1, 6, "\n"),
- ]
-
- assert_equal expected, tokens
- end
-
- def test_class_tokenize_hash_rocket
- tokens = RDoc::RubyLex.tokenize "{ :foo=> 1 }", nil
-
- expected = [
- @TK::TkLBRACE .new( 0, 1, 0, '{'),
- @TK::TkSPACE .new( 1, 1, 1, ' '),
- @TK::TkSYMBOL .new( 2, 1, 2, ':foo'),
- @TK::TkHASHROCKET.new( 6, 1, 6, '=>'),
- @TK::TkSPACE .new( 8, 1, 8, ' '),
- @TK::TkINTEGER .new( 9, 1, 9, '1'),
- @TK::TkSPACE .new(10, 1, 10, ' '),
- @TK::TkRBRACE .new(11, 1, 11, '}'),
- @TK::TkNL .new(12, 1, 12, "\n")
- ]
-
- assert_equal expected, tokens
- end
-
- def test_class_tokenize_percent_sign_quote
- tokens = RDoc::RubyLex.tokenize '%%hi%', nil
-
- expected = [
- @TK::TkSTRING.new( 0, 1, 0, '%%hi%'),
- @TK::TkNL .new( 5, 1, 5, "\n"),
- ]
-
- assert_equal expected, tokens
- end
-
- def test_class_tokenize_regexp
- tokens = RDoc::RubyLex.tokenize "/hay/", nil
-
- expected = [
- @TK::TkREGEXP.new( 0, 1, 0, "/hay/"),
- @TK::TkNL .new( 5, 1, 5, "\n"),
- ]
-
- assert_equal expected, tokens
- end
-
- def test_class_tokenize_regexp_options
- tokens = RDoc::RubyLex.tokenize "/hAY/i", nil
-
- expected = [
- @TK::TkREGEXP.new( 0, 1, 0, "/hAY/i"),
- @TK::TkNL .new( 6, 1, 6, "\n"),
- ]
-
- assert_equal expected, tokens
-
- tokens = RDoc::RubyLex.tokenize "/hAY/ix", nil
-
- expected = [
- @TK::TkREGEXP.new( 0, 1, 0, "/hAY/ix"),
- @TK::TkNL .new( 7, 1, 7, "\n"),
- ]
-
- assert_equal expected, tokens
- end
-
- def test_class_tokenize_regexp_backref
- tokens = RDoc::RubyLex.tokenize "/[csh](..) [csh]\\1 in/", nil
-
- expected = [
- @TK::TkREGEXP.new( 0, 1, 0, "/[csh](..) [csh]\\1 in/"),
- @TK::TkNL .new(22, 1, 22, "\n"),
- ]
-
- assert_equal expected, tokens
- end
-
- def test_class_tokenize_regexp_escape
- tokens = RDoc::RubyLex.tokenize "/\\//", nil
-
- expected = [
- @TK::TkREGEXP.new( 0, 1, 0, "/\\//"),
- @TK::TkNL .new( 4, 1, 4, "\n"),
- ]
-
- assert_equal expected, tokens
- end
-
- def test_class_tokenize_number_with_sign_character
- tokens = RDoc::RubyLex.tokenize "+3--3r", nil
-
- expected = [
- @TK::TkINTEGER .new(0, 1, 0, "+3"),
- @TK::TkMINUS .new(2, 1, 2, "-"),
- @TK::TkRATIONAL.new(3, 1, 3, "-3r"),
- @TK::TkNL .new(6, 1, 6, "\n"),
- ]
-
- assert_equal expected, tokens
- end
-
- def test_class_tokenize_regexp_continuing_backslash
- tokens = RDoc::RubyLex.tokenize "/(?<!\\\\)\\n\z/", nil
-
- expected = [
- @TK::TkREGEXP.new( 0, 1, 0, "/(?<!\\\\)\\n\z/"),
- @TK::TkNL .new(12, 1, 12, "\n"),
- ]
-
- assert_equal expected, tokens
- end
-
- def test_class_tokenize_single_quote_escape
- tokens = RDoc::RubyLex.tokenize %q{'\\\\ \\' \\&'}, nil
-
- expected = [
- @TK::TkSTRING.new( 0, 1, 0, %q{'\\\\ \\' \\&'}),
- @TK::TkNL .new(10, 1, 10, "\n"),
- ]
-
- assert_equal expected, tokens
- end
-
- def test_class_tokenize_string
- tokens = RDoc::RubyLex.tokenize "'hi'", nil
-
- expected = [
- @TK::TkSTRING.new( 0, 1, 0, "'hi'"),
- @TK::TkNL .new( 4, 1, 4, "\n"),
- ]
-
- assert_equal expected, tokens
- end
-
- def test_class_tokenize_string_with_escape
- tokens = RDoc::RubyLex.tokenize <<'RUBY', nil
-[
- '\\',
- '\'',
- "'",
- "\'\"\`",
- "\#",
- "\#{}",
- "#",
- "#{}",
- /'"/,
- /\'\"/,
- /\//,
- /\\/,
- /\#/,
- /\#{}/,
- /#/,
- /#{}/
-]
-RUBY
-
- expected = [
- @TK::TkLBRACK .new( 0, 1, 0, "["),
- @TK::TkNL .new( 1, 1, 1, "\n"),
- @TK::TkSPACE .new( 2, 2, 0, " "),
- @TK::TkSTRING .new( 4, 2, 2, "'\\\\'"),
- @TK::TkCOMMA .new( 8, 2, 6, ","),
- @TK::TkNL .new( 9, 2, 2, "\n"),
- @TK::TkSPACE .new( 10, 3, 0, " "),
- @TK::TkSTRING .new( 12, 3, 2, "'\\''"),
- @TK::TkCOMMA .new( 16, 3, 6, ","),
- @TK::TkNL .new( 17, 3, 10, "\n"),
- @TK::TkSPACE .new( 18, 4, 0, " "),
- @TK::TkSTRING .new( 20, 4, 2, "\"'\""),
- @TK::TkCOMMA .new( 23, 4, 5, ","),
- @TK::TkNL .new( 24, 4, 18, "\n"),
- @TK::TkSPACE .new( 25, 5, 0, " "),
- @TK::TkSTRING .new( 27, 5, 2, "\"\\'\\\"\\`\""),
- @TK::TkCOMMA .new( 35, 5, 10, ","),
- @TK::TkNL .new( 36, 5, 25, "\n"),
- @TK::TkSPACE .new( 37, 6, 0, " "),
- @TK::TkSTRING .new( 39, 6, 2, "\"\\#\""),
- @TK::TkCOMMA .new( 43, 6, 6, ","),
- @TK::TkNL .new( 44, 6, 37, "\n"),
- @TK::TkSPACE .new( 45, 7, 0, " "),
- @TK::TkSTRING .new( 47, 7, 2, "\"\\\#{}\""),
- @TK::TkCOMMA .new( 53, 7, 8, ","),
- @TK::TkNL .new( 54, 7, 45, "\n"),
- @TK::TkSPACE .new( 55, 8, 0, " "),
- @TK::TkSTRING .new( 57, 8, 2, "\"#\""),
- @TK::TkCOMMA .new( 60, 8, 5, ","),
- @TK::TkNL .new( 61, 8, 55, "\n"),
- @TK::TkSPACE .new( 62, 9, 0, " "),
- @TK::TkDSTRING.new( 64, 9, 2, "\"\#{}\""),
- @TK::TkCOMMA .new( 69, 9, 7, ","),
- @TK::TkNL .new( 70, 9, 62, "\n"),
- @TK::TkSPACE .new( 71, 10, 0, " "),
- @TK::TkREGEXP .new( 73, 10, 2, "/'\"/"),
- @TK::TkCOMMA .new( 77, 10, 6, ","),
- @TK::TkNL .new( 78, 10, 71, "\n"),
- @TK::TkSPACE .new( 79, 11, 0, " "),
- @TK::TkREGEXP .new( 81, 11, 2, "/\\'\\\"/"),
- @TK::TkCOMMA .new( 87, 11, 8, ","),
- @TK::TkNL .new( 88, 11, 79, "\n"),
- @TK::TkSPACE .new( 89, 12, 0, " "),
- @TK::TkREGEXP .new( 91, 12, 2, "/\\//"),
- @TK::TkCOMMA .new( 95, 12, 6, ","),
- @TK::TkNL .new( 96, 12, 89, "\n"),
- @TK::TkSPACE .new( 97, 13, 0, " "),
- @TK::TkREGEXP .new( 99, 13, 2, "/\\\\/"),
- @TK::TkCOMMA .new(103, 13, 6, ","),
- @TK::TkNL .new(104, 13, 97, "\n"),
- @TK::TkSPACE .new(105, 14, 0, " "),
- @TK::TkREGEXP .new(107, 14, 2, "/\\#/"),
- @TK::TkCOMMA .new(111, 14, 6, ","),
- @TK::TkNL .new(112, 14, 105, "\n"),
- @TK::TkSPACE .new(113, 15, 0, " "),
- @TK::TkREGEXP .new(115, 15, 2, "/\\\#{}/"),
- @TK::TkCOMMA .new(121, 15, 8, ","),
- @TK::TkNL .new(122, 15, 113, "\n"),
- @TK::TkSPACE .new(123, 16, 0, " "),
- @TK::TkREGEXP .new(125, 16, 2, "/#/"),
- @TK::TkCOMMA .new(128, 16, 5, ","),
- @TK::TkNL .new(129, 16, 123, "\n"),
- @TK::TkSPACE .new(130, 17, 0, " "),
- @TK::TkDREGEXP.new(132, 17, 2, "/\#{}/"),
- @TK::TkNL .new(137, 17, 7, "\n"),
- @TK::TkRBRACK .new(138, 18, 0, "]"),
- @TK::TkNL .new(139, 18, 138, "\n")
- ]
-
- assert_equal expected, tokens
- end
-
- def test_class_tokenize_postfix_if_after_escaped_newline
- tokens = RDoc::RubyLex.tokenize <<'RUBY', nil
-def a
- 1 if true
- 1 \
- if true
-end
-RUBY
-
- expected = [
- @TK::TkDEF .new( 0, 1, 0, "def"),
- @TK::TkSPACE .new( 3, 1, 3, " "),
- @TK::TkIDENTIFIER.new( 4, 1, 4, "a"),
- @TK::TkNL .new( 5, 1, 5, "\n"),
- @TK::TkSPACE .new( 6, 2, 0, " "),
- @TK::TkINTEGER .new( 8, 2, 2, "1"),
- @TK::TkSPACE .new( 9, 2, 3, " "),
- @TK::TkIF_MOD .new(10, 2, 4, "if"),
- @TK::TkSPACE .new(12, 2, 6, " "),
- @TK::TkTRUE .new(13, 2, 7, "true"),
- @TK::TkNL .new(17, 2, 6, "\n"),
- @TK::TkSPACE .new(18, 3, 0, " "),
- @TK::TkINTEGER .new(20, 3, 2, "1"),
- @TK::TkSPACE .new(21, 3, 3, " "),
- @TK::TkBACKSLASH .new(22, 3, 4, "\\"),
- @TK::TkNL .new(23, 3, 18, "\n"),
- @TK::TkSPACE .new(24, 4, 0, " "),
- @TK::TkIF_MOD .new(28, 4, 4, "if"),
- @TK::TkSPACE .new(30, 4, 6, " "),
- @TK::TkTRUE .new(31, 4, 7, "true"),
- @TK::TkNL .new(35, 4, 24, "\n"),
- @TK::TkEND .new(36, 5, 0, "end"),
- @TK::TkNL .new(39, 5, 36, "\n")
- ]
-
- assert_equal expected, tokens
- end
-
- def test_class_tokenize_backtick_with_escape
- tokens = RDoc::RubyLex.tokenize <<'RUBY', nil
-[
- `\\`,
- `\'\"\``,
- `\#`,
- `\#{}`,
- `#`,
- `#{}`
-]
-RUBY
-
- expected = [
- @TK::TkLBRACK .new( 0, 1, 0, "["),
- @TK::TkNL .new( 1, 1, 1, "\n"),
- @TK::TkSPACE .new( 2, 2, 0, " "),
- @TK::TkXSTRING .new( 4, 2, 2, "`\\\\`"),
- @TK::TkCOMMA .new( 8, 2, 6, ","),
- @TK::TkNL .new( 9, 2, 2, "\n"),
- @TK::TkSPACE .new(10, 3, 0, " "),
- @TK::TkXSTRING .new(12, 3, 2, "`\\'\\\"\\``"),
- @TK::TkCOMMA .new(20, 3, 10, ","),
- @TK::TkNL .new(21, 3, 10, "\n"),
- @TK::TkSPACE .new(22, 4, 0, " "),
- @TK::TkXSTRING .new(24, 4, 2, "`\\#`"),
- @TK::TkCOMMA .new(28, 4, 6, ","),
- @TK::TkNL .new(29, 4, 22, "\n"),
- @TK::TkSPACE .new(30, 5, 0, " "),
- @TK::TkXSTRING .new(32, 5, 2, "`\\\#{}`"),
- @TK::TkCOMMA .new(38, 5, 8, ","),
- @TK::TkNL .new(39, 5, 30, "\n"),
- @TK::TkSPACE .new(40, 6, 0, " "),
- @TK::TkXSTRING .new(42, 6, 2, "`#`"),
- @TK::TkCOMMA .new(45, 6, 5, ","),
- @TK::TkNL .new(46, 6, 40, "\n"),
- @TK::TkSPACE .new(47, 7, 0, " "),
- @TK::TkDXSTRING.new(49, 7, 2, "`\#{}`"),
- @TK::TkNL .new(54, 7, 7, "\n"),
- @TK::TkRBRACK .new(55, 8, 0, "]"),
- @TK::TkNL .new(56, 8, 55, "\n")
- ]
-
- assert_equal expected, tokens
- end
-
- def test_class_tokenize_string_escape
- tokens = RDoc::RubyLex.tokenize '"\\n"', nil
- assert_equal @TK::TkSTRING.new( 0, 1, 0, "\"\\n\""), tokens.first
-
- tokens = RDoc::RubyLex.tokenize '"\\r"', nil
- assert_equal @TK::TkSTRING.new( 0, 1, 0, "\"\\r\""), tokens.first
-
- tokens = RDoc::RubyLex.tokenize '"\\f"', nil
- assert_equal @TK::TkSTRING.new( 0, 1, 0, "\"\\f\""), tokens.first
-
- tokens = RDoc::RubyLex.tokenize '"\\\\"', nil
- assert_equal @TK::TkSTRING.new( 0, 1, 0, "\"\\\\\""), tokens.first
-
- tokens = RDoc::RubyLex.tokenize '"\\t"', nil
- assert_equal @TK::TkSTRING.new( 0, 1, 0, "\"\\t\""), tokens.first
-
- tokens = RDoc::RubyLex.tokenize '"\\v"', nil
- assert_equal @TK::TkSTRING.new( 0, 1, 0, "\"\\v\""), tokens.first
-
- tokens = RDoc::RubyLex.tokenize '"\\a"', nil
- assert_equal @TK::TkSTRING.new( 0, 1, 0, "\"\\a\""), tokens.first
-
- tokens = RDoc::RubyLex.tokenize '"\\e"', nil
- assert_equal @TK::TkSTRING.new( 0, 1, 0, "\"\\e\""), tokens.first
-
- tokens = RDoc::RubyLex.tokenize '"\\b"', nil
- assert_equal @TK::TkSTRING.new( 0, 1, 0, "\"\\b\""), tokens.first
-
- tokens = RDoc::RubyLex.tokenize '"\\s"', nil
- assert_equal @TK::TkSTRING.new( 0, 1, 0, "\"\\s\""), tokens.first
-
- tokens = RDoc::RubyLex.tokenize '"\\d"', nil
- assert_equal @TK::TkSTRING.new( 0, 1, 0, "\"\\d\""), tokens.first
-
- end
-
- def test_class_tokenize_string_escape_control
- tokens = RDoc::RubyLex.tokenize '"\\C-a"', nil
- assert_equal @TK::TkSTRING.new( 0, 1, 0, "\"\\C-a\""), tokens.first
-
- tokens = RDoc::RubyLex.tokenize '"\\c\\a"', nil
- assert_equal @TK::TkSTRING.new( 0, 1, 0, "\"\\c\\a\""), tokens.first
-
- tokens = RDoc::RubyLex.tokenize '"\\C-\\M-a"', nil
- assert_equal @TK::TkSTRING.new( 0, 1, 0, "\"\\C-\\M-a\""), tokens.first
- end
-
- def test_class_tokenize_string_escape_meta
- tokens = RDoc::RubyLex.tokenize '"\\M-a"', nil
- assert_equal @TK::TkSTRING.new( 0, 1, 0, "\"\\M-a\""), tokens.first
-
- tokens = RDoc::RubyLex.tokenize '"\\M-\\C-a"', nil
- assert_equal @TK::TkSTRING.new( 0, 1, 0, "\"\\M-\\C-a\""), tokens.first
- end
-
- def test_class_tokenize_string_escape_hexadecimal
- tokens = RDoc::RubyLex.tokenize '"\\x0"', nil
- assert_equal @TK::TkSTRING.new( 0, 1, 0, "\"\\x0\""), tokens.first
-
- tokens = RDoc::RubyLex.tokenize '"\\x00"', nil
- assert_equal @TK::TkSTRING.new( 0, 1, 0, "\"\\x00\""), tokens.first
-
- tokens = RDoc::RubyLex.tokenize '"\\x000"', nil
- assert_equal @TK::TkSTRING.new( 0, 1, 0, "\"\\x000\""), tokens.first
- end
-
- def test_class_tokenize_string_escape_octal
- tokens = RDoc::RubyLex.tokenize '"\\0"', nil
- assert_equal @TK::TkSTRING.new( 0, 1, 0, "\"\\0\""), tokens.first
-
- tokens = RDoc::RubyLex.tokenize '"\\00"', nil
- assert_equal @TK::TkSTRING.new( 0, 1, 0, "\"\\00\""), tokens.first
-
- tokens = RDoc::RubyLex.tokenize '"\\000"', nil
- assert_equal @TK::TkSTRING.new( 0, 1, 0, "\"\\000\""), tokens.first
- end
-
- def test_class_tokenize_symbol
- tokens = RDoc::RubyLex.tokenize 'scope module: :v1', nil
-
- expected = [
- @TK::TkIDENTIFIER.new( 0, 1, 0, 'scope'),
- @TK::TkSPACE .new( 5, 1, 5, ' '),
- @TK::TkSYMBOL .new( 6, 1, 6, 'module:'),
- @TK::TkSPACE .new(13, 1, 13, ' '),
- @TK::TkSYMBOL .new(14, 1, 14, ':v1'),
- @TK::TkNL .new(17, 1, 17, "\n"),
- ]
-
- assert_equal expected, tokens
- end
-
- def test_class_tokenize_particular_kind_of_symbols
- tokens = RDoc::RubyLex.tokenize '{ Thomas: :Thomas, Dave!: :Dave!, undef: :undef }', nil
-
- expected = [
- @TK::TkLBRACE.new( 0, 1, 0, "{"),
- @TK::TkSPACE .new( 1, 1, 1, " "),
- @TK::TkSYMBOL.new( 2, 1, 2, "Thomas:"),
- @TK::TkSPACE .new( 9, 1, 9, " "),
- @TK::TkSYMBOL.new(10, 1, 10, ":Thomas"),
- @TK::TkCOMMA .new(17, 1, 17, ","),
- @TK::TkSPACE .new(18, 1, 18, " "),
- @TK::TkSYMBOL.new(19, 1, 19, "Dave!:"),
- @TK::TkSPACE .new(25, 1, 25, " "),
- @TK::TkSYMBOL.new(26, 1, 26, ":Dave!"),
- @TK::TkCOMMA .new(32, 1, 32, ","),
- @TK::TkSPACE .new(33, 1, 33, " "),
- @TK::TkSYMBOL.new(34, 1, 34, "undef:"),
- @TK::TkSPACE .new(40, 1, 40, " "),
- @TK::TkSYMBOL.new(41, 1, 41, ":undef"),
- @TK::TkSPACE .new(47, 1, 47, " "),
- @TK::TkRBRACE.new(48, 1, 48, "}"),
- @TK::TkNL .new(49, 1, 49, "\n"),
- ]
-
- assert_equal expected, tokens
- end
-
- def test_class_tokenize_symbol_for_nested_method
- tokens = RDoc::RubyLex.tokenize 'return untrace_var :name', nil
-
- expected = [
- @TK::TkRETURN .new( 0, 1, 0, "return"),
- @TK::TkSPACE .new( 6, 1, 6, " "),
- @TK::TkIDENTIFIER.new( 7, 1, 7, "untrace_var"),
- @TK::TkSPACE .new(18, 1, 18, " "),
- @TK::TkSYMBOL .new(19, 1, 19, ":name"),
- @TK::TkNL .new(24, 1, 24, "\n"),
- ]
-
- assert_equal expected, tokens
- end
-
- def test_class_tokenize_symbol_with_quote
- tokens = RDoc::RubyLex.tokenize <<RUBY, nil
-a.include?()?"a":"b"
-{"t":1,'t2':2}
-RUBY
-
- expected = [
- @TK::TkIDENTIFIER.new( 0, 1, 0, "a"),
- @TK::TkDOT .new( 1, 1, 1, "."),
- @TK::TkFID .new( 2, 1, 2, "include?"),
- @TK::TkLPAREN .new(10, 1, 10, "("),
- @TK::TkRPAREN .new(11, 1, 11, ")"),
- @TK::TkQUESTION .new(12, 1, 12, "?"),
- @TK::TkSTRING .new(13, 1, 13, "\"a\""),
- @TK::TkCOLON .new(16, 1, 16, ":"),
- @TK::TkSTRING .new(17, 1, 17, "\"b\""),
- @TK::TkNL .new(20, 1, 20, "\n"),
- @TK::TkLBRACE .new(21, 2, 0, "{"),
- @TK::TkSYMBOL .new(22, 2, 1, "\"t\":"),
- @TK::TkINTEGER .new(26, 2, 5, "1"),
- @TK::TkCOMMA .new(27, 2, 6, ","),
- @TK::TkSYMBOL .new(28, 2, 7, "'t2':"),
- @TK::TkINTEGER .new(33, 2, 12, "2"),
- @TK::TkRBRACE .new(34, 2, 13, "}"),
- @TK::TkNL .new(35, 2, 21, "\n"),
- ]
-
- assert_equal expected, tokens
- end
-
- def test_unary_minus
- ruby_lex = RDoc::RubyLex.new("-1", nil)
- assert_equal("-1", ruby_lex.token.value)
-
- ruby_lex = RDoc::RubyLex.new("a[-2]", nil)
- 2.times { ruby_lex.token } # skip "a" and "["
- assert_equal("-2", ruby_lex.token.value)
-
- ruby_lex = RDoc::RubyLex.new("a[0..-12]", nil)
- 4.times { ruby_lex.token } # skip "a", "[", "0", and ".."
- assert_equal("-12", ruby_lex.token.value)
-
- ruby_lex = RDoc::RubyLex.new("0+-0.1", nil)
- 2.times { ruby_lex.token } # skip "0" and "+"
- assert_equal("-0.1", ruby_lex.token.value)
- end
-
- def test_rational_imaginary_tokenize
- tokens = RDoc::RubyLex.tokenize '1.11r + 2.34i + 5.55ri + 0i', nil
-
- expected = [
- @TK::TkRATIONAL .new( 0, 1, 0, '1.11r'),
- @TK::TkSPACE .new( 5, 1, 5, ' '),
- @TK::TkPLUS .new( 6, 1, 6, '+'),
- @TK::TkSPACE .new( 7, 1, 7, ' '),
- @TK::TkIMAGINARY.new( 8, 1, 8, '2.34i'),
- @TK::TkSPACE .new(13, 1, 13, ' '),
- @TK::TkPLUS .new(14, 1, 14, '+'),
- @TK::TkSPACE .new(15, 1, 15, ' '),
- @TK::TkIMAGINARY.new(16, 1, 16, '5.55ri'),
- @TK::TkSPACE .new(22, 1, 22, ' '),
- @TK::TkPLUS .new(23, 1, 23, '+'),
- @TK::TkSPACE .new(24, 1, 24, ' '),
- @TK::TkIMAGINARY.new(25, 1, 25, '0i'),
- @TK::TkNL .new(27, 1, 27, "\n"),
- ]
-
- assert_equal expected, tokens
- end
-
- def test_class_tokenize_square_bracket_as_method
- tokens = RDoc::RubyLex.tokenize "Array.[](1, 2)", nil
-
- expected = [
- @TK::TkCONSTANT .new(0, 1, 0, "Array"),
- @TK::TkDOT .new(5, 1, 5, "."),
- @TK::TkIDENTIFIER.new(6, 1, 6, "[]"),
- @TK::TkfLPAREN .new(8, 1, 8, "("),
- @TK::TkINTEGER .new(9, 1, 9, "1"),
- @TK::TkCOMMA .new(10, 1, 10, ","),
- @TK::TkSPACE .new(11, 1, 11, " "),
- @TK::TkINTEGER .new(12, 1, 12, "2"),
- @TK::TkRPAREN .new(13, 1, 13, ")"),
- @TK::TkNL .new(14, 1, 14, "\n")
- ]
-
- assert_equal expected, tokens
- end
-
- def test_class_tokenize_constant_with_exclamation
- tokens = RDoc::RubyLex.tokenize "Hello there, Dave!", nil
-
- expected = [
- @TK::TkCONSTANT .new( 0, 1, 0, "Hello"),
- @TK::TkSPACE .new( 5, 1, 5, " "),
- @TK::TkIDENTIFIER.new( 6, 1, 6, "there"),
- @TK::TkCOMMA .new(11, 1, 11, ","),
- @TK::TkSPACE .new(12, 1, 12, " "),
- @TK::TkIDENTIFIER.new(13, 1, 13, "Dave!"),
- @TK::TkNL .new(18, 1, 18, "\n")
- ]
-
- assert_equal expected, tokens
- end
-
- def test_class_tokenize_identifer_not_equal
- tokens = RDoc::RubyLex.tokenize "foo!=bar\nfoo?=bar", nil
-
- expected = [
- @TK::TkIDENTIFIER.new( 0, 1, 0, "foo"),
- @TK::TkNEQ .new( 3, 1, 3, "!="),
- @TK::TkIDENTIFIER.new( 5, 1, 5, "bar"),
- @TK::TkNL .new( 8, 1, 8, "\n"),
- @TK::TkFID .new( 9, 2, 0, "foo?"),
- @TK::TkASSIGN .new(13, 2, 4, "="),
- @TK::TkIDENTIFIER.new(14, 2, 5, "bar"),
- @TK::TkNL .new(17, 2, 9, "\n"),
- ]
-
- assert_equal expected, tokens
- end
-
-end
-
generated by cgit v1.2.3 (git 2.25.1) at 2024-04-26 03:01:08 +0000