| #!/usr/bin/ruby |
| # encoding: utf-8 |
| require 'antlr3/test/functional' |
| |
| class LexerTest001 < ANTLR3::Test::Functional |
| inline_grammar( <<-'END' ) |
| lexer grammar Zero; |
| options { |
| language = Ruby; |
| } |
| |
| @members { include ANTLR3::Test::RaiseErrors } |
| |
| ZERO: '0'; |
| END |
| |
| example %(lexing '0') do |
| lexer = Zero::Lexer.new( '0' ) |
| |
| token = lexer.next_token |
| token.name.should == 'ZERO' |
| |
| token = lexer.next_token |
| token.name.should == '<EOF>' |
| end |
| |
| example %(iterating over tokens) do |
| lexer = Zero::Lexer.new( '0' ) |
| |
| token_types = lexer.map { |token| token.name } |
| token_types.should == %w(ZERO) |
| end |
| |
| example "mismatched token" do |
| lexer = Zero::Lexer.new( '1' ) |
| |
| proc { |
| token = lexer.next_token |
| }.should raise_error( ANTLR3::Error::MismatchedToken ) do |e| |
| e.expecting.should == '0' |
| e.unexpected_type.should == '1' |
| end |
| end |
| end |
| |
| class LexerTest002 < ANTLR3::Test::Functional |
| inline_grammar( <<-'END' ) |
| lexer grammar Binary; |
| options { |
| language = Ruby; |
| } |
| |
| @members { include ANTLR3::Test::RaiseErrors } |
| |
| ZERO: '0'; |
| ONE: '1'; |
| END |
| |
| example "lexing '01'" do |
| lexer = Binary::Lexer.new( '01' ) |
| |
| token = lexer.next_token |
| token.name.should == 'ZERO' |
| |
| token = lexer.next_token |
| token.name.should == 'ONE' |
| |
| token = lexer.next_token |
| token.name.should == '<EOF>' |
| end |
| |
| example "no matching token rule" do |
| lexer = Binary::Lexer.new( '2' ) |
| |
| b = lambda { token = lexer.next_token } |
| b.should raise_error( ANTLR3::Error::NoViableAlternative ) do |exc| |
| exc.unexpected_type.should == '2' |
| end |
| end |
| |
| end |
| |
| class LexerTest003 < ANTLR3::Test::Functional |
| inline_grammar( <<-'END' ) |
| lexer grammar BinaryFooze; |
| options { |
| language = Ruby; |
| } |
| |
| @members { include ANTLR3::Test::RaiseErrors } |
| |
| ZERO: '0'; |
| ONE: '1'; |
| FOOZE: 'fooze'; |
| END |
| |
| example "lexing '0fooze1'" do |
| lexer = BinaryFooze::Lexer.new( '0fooze1' ) |
| |
| token = lexer.next_token |
| token.name.should == 'ZERO' |
| |
| token = lexer.next_token |
| token.name.should == 'FOOZE' |
| |
| token = lexer.next_token |
| token.name.should == 'ONE' |
| |
| token = lexer.next_token |
| token.name.should == '<EOF>' |
| end |
| |
| example "no token match" do |
| lexer = BinaryFooze::Lexer.new( '2' ) |
| |
| proc { lexer.next_token }. |
| should raise_error( ANTLR3::Error::NoViableAlternative ) do |exc| |
| exc.unexpected_type.should == '2' |
| end |
| end |
| end |
| |
| |
| class LexerTest004 < ANTLR3::Test::Functional |
| inline_grammar( <<-'END' ) |
| lexer grammar FooStar; |
| options { |
| language = Ruby; |
| } |
| |
| @members { include ANTLR3::Test::RaiseErrors } |
| |
| FOO: 'f' 'o'*; |
| END |
| |
| example "lexing 'ffofoofooo'" do |
| lexer = FooStar::Lexer.new( 'ffofoofooo' ) |
| |
| token = lexer.next_token |
| token.name.should == 'FOO' |
| token.start.should == 0 |
| token.stop.should == 0 |
| token.text.should == 'f' |
| |
| token = lexer.next_token |
| token.name.should == 'FOO' |
| token.text.should == 'fo' |
| token.start.should == 1 |
| token.stop.should == 2 |
| |
| token = lexer.next_token |
| token.name.should == 'FOO' |
| token.start.should == 3 |
| token.stop.should == 5 |
| token.text.should == 'foo' |
| |
| token = lexer.next_token |
| token.name.should == 'FOO' |
| token.start.should == 6 |
| token.stop.should == 9 |
| token.text.should == 'fooo' |
| |
| token = lexer.next_token |
| token.name.should == '<EOF>' |
| end |
| |
| example "mismatched token" do |
| lexer = FooStar::Lexer.new( '2' ) |
| |
| proc { lexer.next_token }. |
| should raise_error( ANTLR3::Error::MismatchedToken ) do |exc| |
| exc.expecting.should == 'f' |
| exc.unexpected_type.should == '2' |
| end |
| end |
| end |
| |
| class LexerTest005 < ANTLR3::Test::Functional |
| inline_grammar( <<-'END' ) |
| lexer grammar FooPlus; |
| options { |
| language = Ruby; |
| } |
| |
| @members { include ANTLR3::Test::RaiseErrors } |
| |
| FOO: 'f' 'o'+; |
| END |
| |
| example "lexing 'fofoofooo'" do |
| lexer = FooPlus::Lexer.new( 'fofoofooo' ) |
| |
| token = lexer.next_token |
| token.name.should == 'FOO' |
| token.start.should == 0 |
| token.stop.should == 1 |
| token.text.should == 'fo' |
| |
| token = lexer.next_token |
| token.name.should == 'FOO' |
| token.text.should == 'foo' |
| token.start.should == 2 |
| token.stop.should == 4 |
| |
| token = lexer.next_token |
| token.name.should == 'FOO' |
| token.start.should == 5 |
| token.stop.should == 8 |
| token.text.should == 'fooo' |
| |
| token = lexer.next_token |
| token.name.should == '<EOF>' |
| end |
| |
| example "mismatched token" do |
| lexer = FooPlus::Lexer.new( '2' ) |
| |
| proc { lexer.next_token }. |
| should raise_error( ANTLR3::Error::MismatchedToken ) do |exc| |
| exc.expecting.should == 'f' |
| exc.unexpected_type.should == '2' |
| end |
| end |
| |
| example "early exit" do |
| lexer = FooPlus::Lexer.new( 'f' ) |
| |
| proc { token = lexer.next_token }. |
| should raise_error( ANTLR3::Error::EarlyExit ) { |exc| |
| exc.unexpected_type.should == ANTLR3::Constants::EOF |
| } |
| end |
| |
| end |
| |
| class LexerTest006 < ANTLR3::Test::Functional |
| inline_grammar( <<-'END' ) |
| lexer grammar FoaStar; |
| options { |
| language = Ruby; |
| } |
| |
| @members { include ANTLR3::Test::RaiseErrors } |
| |
| FOO: 'f' ('o' | 'a')*; |
| END |
| |
| example "lexing 'fofaaooa'" do |
| lexer = FoaStar::Lexer.new( 'fofaaooa' ) |
| |
| token = lexer.next_token |
| token.name.should == 'FOO' |
| token.start.should == 0 |
| token.stop.should == 1 |
| token.text.should == 'fo' |
| |
| token = lexer.next_token |
| token.name.should == 'FOO' |
| token.text.should == 'faaooa' |
| token.start.should == 2 |
| token.stop.should == 7 |
| |
| token = lexer.next_token |
| token.name.should == '<EOF>' |
| end |
| |
| example "mismatched token" do |
| lexer = FoaStar::Lexer.new( 'fofoaooaoa2' ) |
| |
| lexer.next_token |
| lexer.next_token |
| proc { lexer.next_token }. |
| should raise_error( ANTLR3::Error::MismatchedToken ) do |exc| |
| exc.expecting.should == 'f' |
| exc.unexpected_type.should == '2' |
| exc.column.should == 10 |
| exc.line.should == 1 |
| end |
| end |
| end |
| |
| class LexerTest007 < ANTLR3::Test::Functional |
| inline_grammar( <<-'END' ) |
| lexer grammar Foab; |
| options { |
| language = Ruby; |
| } |
| |
| @members { include ANTLR3::Test::RaiseErrors } |
| |
| FOO: 'f' ('o' | 'a' 'b'+)*; |
| END |
| |
| example "lexing 'fofababbooabb'" do |
| lexer = Foab::Lexer.new( 'fofababbooabb' ) |
| |
| token = lexer.next_token |
| token.name.should == 'FOO' |
| token.start.should == 0 |
| token.stop.should == 1 |
| token.text.should == 'fo' |
| |
| token = lexer.next_token |
| token.name.should == 'FOO' |
| token.start.should == 2 |
| token.stop.should == 12 |
| token.text.should == 'fababbooabb' |
| |
| token = lexer.next_token |
| token.name.should == '<EOF>' |
| end |
| |
| example "early exit" do |
| lexer = Foab::Lexer.new( 'foaboao' ) |
| |
| proc { lexer.next_token }. |
| should raise_error( ANTLR3::Error::EarlyExit ) do |exc| |
| exc.unexpected_type.should == 'o' |
| exc.column.should == 6 |
| exc.line.should == 1 |
| end |
| end |
| end |
| |
| class LexerTest008 < ANTLR3::Test::Functional |
| inline_grammar( <<-'END' ) |
| lexer grammar Fa; |
| options { |
| language = Ruby; |
| } |
| |
| @members { include ANTLR3::Test::RaiseErrors } |
| |
| FOO: 'f' 'a'?; |
| END |
| |
| example "lexing 'ffaf'" do |
| lexer = Fa::Lexer.new( 'ffaf' ) |
| |
| token = lexer.next_token |
| token.name.should == 'FOO' |
| token.start.should == 0 |
| token.stop.should == 0 |
| token.text.should == 'f' |
| |
| token = lexer.next_token |
| token.name.should == 'FOO' |
| token.start.should == 1 |
| token.stop.should == 2 |
| token.text.should == 'fa' |
| |
| token = lexer.next_token |
| token.name.should == 'FOO' |
| token.start.should == 3 |
| token.stop.should == 3 |
| token.text.should == 'f' |
| |
| token = lexer.next_token |
| token.name.should == '<EOF>' |
| end |
| |
| example "mismatched token" do |
| lexer = Fa::Lexer.new( 'fafb' ) |
| |
| lexer.next_token |
| lexer.next_token |
| proc { lexer.next_token }. |
| should raise_error( ANTLR3::Error::MismatchedToken ) do |exc| |
| exc.unexpected_type.should == 'b' |
| exc.column.should == 3 |
| exc.line.should == 1 |
| end |
| end |
| end |
| |
| |
| class LexerTest009 < ANTLR3::Test::Functional |
| inline_grammar( <<-'END' ) |
| lexer grammar Digit; |
| options { |
| language = Ruby; |
| } |
| |
| @members { include ANTLR3::Test::RaiseErrors } |
| |
| DIGIT: '0' .. '9'; |
| END |
| |
| example "lexing '085'" do |
| lexer = Digit::Lexer.new( '085' ) |
| |
| token = lexer.next_token |
| token.name.should == 'DIGIT' |
| token.start.should == 0 |
| token.stop.should == 0 |
| token.text.should == '0' |
| |
| token = lexer.next_token |
| token.name.should == 'DIGIT' |
| token.start.should == 1 |
| token.stop.should == 1 |
| token.text.should == '8' |
| |
| token = lexer.next_token |
| token.name.should == 'DIGIT' |
| token.start.should == 2 |
| token.stop.should == 2 |
| token.text.should == '5' |
| |
| token = lexer.next_token |
| token.name.should == '<EOF>' |
| end |
| |
| example "mismatched range" do |
| lexer = Digit::Lexer.new( '2a' ) |
| |
| lexer.next_token |
| proc { lexer.next_token }. |
| should raise_error( ANTLR3::Error::MismatchedRange ) do |exc| |
| exc.min.should == '0' |
| exc.max.should == '9' |
| exc.unexpected_type.should == 'a' |
| exc.column.should == 1 |
| exc.line.should == 1 |
| end |
| end |
| end |
| |
| class LexerTest010 < ANTLR3::Test::Functional |
| inline_grammar( <<-'END' ) |
| lexer grammar IDsAndSpaces; |
| options { |
| language = Ruby; |
| } |
| |
| @members { include ANTLR3::Test::RaiseErrors } |
| |
| IDENTIFIER: ('a'..'z'|'A'..'Z'|'_') ('a'..'z'|'A'..'Z'|'0'..'9'|'_')*; |
| WS: (' ' | '\n')+; |
| END |
| |
| example "lexing 'foobar _Ab98 \n A12sdf'" do |
| lexer = IDsAndSpaces::Lexer.new( "foobar _Ab98 \n A12sdf" ) |
| |
| token = lexer.next_token |
| token.name.should == 'IDENTIFIER' |
| token.start.should == 0 |
| token.stop.should == 5 |
| token.text.should == 'foobar' |
| |
| token = lexer.next_token |
| token.name.should == 'WS' |
| token.start.should == 6 |
| token.stop.should == 6 |
| token.text.should == ' ' |
| |
| token = lexer.next_token |
| token.name.should == 'IDENTIFIER' |
| token.start.should == 7 |
| token.stop.should == 11 |
| token.text.should == '_Ab98' |
| |
| token = lexer.next_token |
| token.name.should == 'WS' |
| token.start.should == 12 |
| token.stop.should == 14 |
| token.text.should == " \n " |
| |
| token = lexer.next_token |
| token.name.should == 'IDENTIFIER' |
| token.start.should == 15 |
| token.stop.should == 20 |
| token.text.should == 'A12sdf' |
| |
| token = lexer.next_token |
| token.name.should == '<EOF>' |
| end |
| |
| example "contains characters without a matching token rule" do |
| lexer = IDsAndSpaces::Lexer.new( 'a-b' ) |
| |
| lexer.next_token |
| proc { lexer.next_token }. |
| should raise_error( ANTLR3::Error::NoViableAlternative ) do |exc| |
| exc.unexpected_type.should == '-' |
| exc.column.should == 1 |
| exc.line.should == 1 |
| end |
| end |
| end |
| |
| class LexerTest011 < ANTLR3::Test::Functional |
| inline_grammar( <<-'END' ) |
| lexer grammar IDsWithAction; |
| options {language = Ruby;} |
| |
| @members { include ANTLR3::Test::RaiseErrors } |
| |
| IDENTIFIER: |
| ('a'..'z'|'A'..'Z'|'_') |
| ('a'..'z' |
| |'A'..'Z' |
| |'0'..'9' |
| |'_' { \$action_var = '_' } |
| )* |
| ; |
| |
| WS: (' ' | '\n')+; |
| END |
| |
| example "lexing 'foobar _Ab98 \n A12sdf'" do |
| lexer = IDsWithAction::Lexer.new( "foobar _Ab98 \n A12sdf" ) |
| |
| token = lexer.next_token |
| token.name.should == 'IDENTIFIER' |
| token.start.should == 0 |
| token.stop.should == 5 |
| token.text.should == 'foobar' |
| |
| token = lexer.next_token |
| token.name.should == 'WS' |
| token.start.should == 6 |
| token.stop.should == 6 |
| token.text.should == ' ' |
| |
| token = lexer.next_token |
| token.name.should == 'IDENTIFIER' |
| token.start.should == 7 |
| token.stop.should == 11 |
| token.text.should == '_Ab98' |
| |
| token = lexer.next_token |
| token.name.should == 'WS' |
| token.start.should == 12 |
| token.stop.should == 14 |
| token.text.should == " \n " |
| |
| token = lexer.next_token |
| token.name.should == 'IDENTIFIER' |
| token.start.should == 15 |
| token.stop.should == 20 |
| token.text.should == 'A12sdf' |
| |
| token = lexer.next_token |
| token.name.should == '<EOF>' |
| end |
| |
| example "contains characters without a matching token" do |
| lexer = IDsWithAction::Lexer.new( 'a-b' ) |
| |
| lexer.next_token |
| proc { lexer.next_token }. |
| should raise_error( ANTLR3::Error::NoViableAlternative ) do |exc| |
| exc.unexpected_type.should == '-' |
| exc.column.should == 1 |
| exc.line.should == 1 |
| end |
| end |
| end |