| /*=============================================================================# |
| # Copyright (c) 2015, 2020 Stephan Wahlbrink and others. |
| # |
| # This program and the accompanying materials are made available under the |
| # terms of the Eclipse Public License 2.0 which is available at |
| # https://www.eclipse.org/legal/epl-2.0, or the Apache License, Version 2.0 |
| # which is available at https://www.apache.org/licenses/LICENSE-2.0. |
| # |
| # SPDX-License-Identifier: EPL-2.0 OR Apache-2.0 |
| # |
| # Contributors: |
| # Stephan Wahlbrink <sw@wahlbrink.eu> - initial API and implementation |
| #=============================================================================*/ |
| |
| package org.eclipse.statet.r.core.rsource; |
| |
| import static org.junit.Assert.assertEquals; |
| |
| import static org.eclipse.statet.r.core.rsource.IRSourceConstants.STATUS123_SYNTAX_NUMBER_EXP_DIGIT_MISSING; |
| import static org.eclipse.statet.r.core.rsource.IRSourceConstants.STATUS123_SYNTAX_NUMBER_HEX_DIGIT_MISSING; |
| import static org.eclipse.statet.r.core.rsource.IRSourceConstants.STATUS123_SYNTAX_NUMBER_HEX_FLOAT_EXP_MISSING; |
| import static org.eclipse.statet.r.core.rsource.IRSourceConstants.STATUS123_SYNTAX_NUMBER_INT_WITH_DEC_POINT; |
| import static org.eclipse.statet.r.core.rsource.IRSourceConstants.STATUS123_SYNTAX_NUMBER_NON_INT_WITH_L; |
| import static org.eclipse.statet.r.core.rsource.IRSourceConstants.STATUS12_SYNTAX_TOKEN_NOT_CLOSED; |
| |
| import org.junit.FixMethodOrder; |
| import org.junit.Test; |
| |
| import org.eclipse.statet.jcommons.text.core.input.StringParserInput; |
| |
| import org.eclipse.statet.r.core.rlang.RTerminal; |
| |
| |
| @FixMethodOrder |
| public class RLexerTerminalTest { |
| |
| |
| private final StringParserInput input= new StringParserInput(); |
| |
| |
| protected int getConfig() { |
| return 0; |
| } |
| |
| |
| @Test |
| public void empty() { |
| final RLexer lexer= new RLexer(getConfig()); |
| lexer.reset(this.input.reset("").init()); |
| |
| assertEquals(RTerminal.EOF, lexer.next()); |
| } |
| |
| @Test |
| public void matchWhitespace() { |
| final RLexer lexer= new RLexer(getConfig()); |
| lexer.reset(this.input.reset(" \t").init()); |
| |
| assertEquals(RTerminal.BLANK, lexer.next()); |
| assertEquals(0, lexer.getFlags()); |
| |
| assertEquals(RTerminal.EOF, lexer.next()); |
| } |
| |
| @Test |
| public void skipWhitespace() { |
| final RLexer lexer= new RLexer(getConfig() | RLexer.SKIP_WHITESPACE); |
| lexer.reset(this.input.reset(" \t").init()); |
| |
| assertEquals(RTerminal.EOF, lexer.next()); |
| } |
| |
| @Test |
| public void matchLinebreak() { |
| final RLexer lexer= new RLexer(getConfig() | RLexer.SKIP_WHITESPACE); |
| lexer.reset(this.input.reset(" \n ").init()); |
| |
| assertEquals(RTerminal.LINEBREAK, lexer.next()); |
| |
| assertEquals(RTerminal.EOF, lexer.next()); |
| } |
| |
| @Test |
| public void matchComment() { |
| final RLexer lexer= new RLexer(getConfig() | RLexer.SKIP_WHITESPACE); |
| lexer.reset(this.input.reset(" # comment").init()); |
| |
| assertEquals(RTerminal.COMMENT, lexer.next()); |
| assertEquals(0, lexer.getFlags()); |
| |
| assertEquals(RTerminal.EOF, lexer.next()); |
| } |
| |
| @Test |
| public void matchComment_Linebreak() { |
| final RLexer lexer= new RLexer(getConfig() | RLexer.SKIP_WHITESPACE); |
| lexer.reset(this.input.reset(" # comment\n ").init()); |
| |
| assertEquals(RTerminal.COMMENT, lexer.next()); |
| assertEquals(0, lexer.getFlags()); |
| assertEquals(RTerminal.LINEBREAK, lexer.next()); |
| |
| assertEquals(RTerminal.EOF, lexer.next()); |
| } |
| |
| @Test |
| public void matchRoxygenComment() { |
| final RLexer lexer= new RLexer(getConfig() | RLexer.SKIP_WHITESPACE); |
| lexer.reset(this.input.reset("#' comment").init()); |
| |
| assertEquals(RTerminal.ROXYGEN_COMMENT, lexer.next()); |
| assertEquals(0, lexer.getFlags()); |
| |
| assertEquals(RTerminal.EOF, lexer.next()); |
| } |
| |
| @Test |
| public void skipComment() { |
| final RLexer lexer= new RLexer(getConfig() | RLexer.SKIP_WHITESPACE | RLexer.SKIP_COMMENT); |
| lexer.reset(this.input.reset(" # comment\n ").init()); |
| |
| assertEquals(RTerminal.LINEBREAK, lexer.next()); |
| assertEquals(RTerminal.EOF, lexer.next()); |
| |
| lexer.reset(this.input.reset(" #' comment").init()); |
| |
| assertEquals(RTerminal.EOF, lexer.next()); |
| } |
| |
| |
| @Test |
| public void matchBlockOpen() { |
| final RLexer lexer= new RLexer(getConfig() | RLexer.SKIP_WHITESPACE); |
| lexer.reset(this.input.reset(" { ").init()); |
| |
| assertEquals(RTerminal.BLOCK_OPEN, lexer.next()); |
| assertEquals(0, lexer.getFlags()); |
| |
| assertEquals(RTerminal.EOF, lexer.next()); |
| } |
| |
| @Test |
| public void matchBlockClose() { |
| final RLexer lexer= new RLexer(getConfig() | RLexer.SKIP_WHITESPACE); |
| lexer.reset(this.input.reset(" } ").init()); |
| |
| assertEquals(RTerminal.BLOCK_CLOSE, lexer.next()); |
| assertEquals(0, lexer.getFlags()); |
| |
| assertEquals(RTerminal.EOF, lexer.next()); |
| } |
| |
| @Test |
| public void matchGroupOpen() { |
| final RLexer lexer= new RLexer(getConfig() | RLexer.SKIP_WHITESPACE); |
| lexer.reset(this.input.reset(" ( ").init()); |
| |
| assertEquals(RTerminal.GROUP_OPEN, lexer.next()); |
| assertEquals(0, lexer.getFlags()); |
| |
| assertEquals(RTerminal.EOF, lexer.next()); |
| } |
| |
| @Test |
| public void matchGroupClose() { |
| final RLexer lexer= new RLexer(getConfig() | RLexer.SKIP_WHITESPACE); |
| lexer.reset(this.input.reset(" ) ").init()); |
| |
| assertEquals(RTerminal.GROUP_CLOSE, lexer.next()); |
| assertEquals(0, lexer.getFlags()); |
| |
| assertEquals(RTerminal.EOF, lexer.next()); |
| } |
| |
| @Test |
| public void matchSubIndexedSOpen() { |
| final RLexer lexer= new RLexer(getConfig() | RLexer.SKIP_WHITESPACE); |
| lexer.reset(this.input.reset(" [ ").init()); |
| |
| assertEquals(RTerminal.SUB_INDEXED_S_OPEN, lexer.next()); |
| assertEquals(0, lexer.getFlags()); |
| |
| assertEquals(RTerminal.EOF, lexer.next()); |
| } |
| |
| @Test |
| public void matchSubIndexedDOpen() { |
| final RLexer lexer= new RLexer(getConfig() | RLexer.SKIP_WHITESPACE); |
| lexer.reset(this.input.reset(" [[ ").init()); |
| |
| assertEquals(RTerminal.SUB_INDEXED_D_OPEN, lexer.next()); |
| assertEquals(0, lexer.getFlags()); |
| |
| assertEquals(RTerminal.EOF, lexer.next()); |
| } |
| |
| @Test |
| public void matchSubIndexedClose() { |
| final RLexer lexer= new RLexer(getConfig() | RLexer.SKIP_WHITESPACE); |
| lexer.reset(this.input.reset(" ] ").init()); |
| |
| assertEquals(RTerminal.SUB_INDEXED_CLOSE, lexer.next()); |
| assertEquals(0, lexer.getFlags()); |
| |
| assertEquals(RTerminal.EOF, lexer.next()); |
| } |
| |
| @Test |
| public void matchSubNamedPart() { |
| final RLexer lexer= new RLexer(getConfig() | RLexer.SKIP_WHITESPACE); |
| lexer.reset(this.input.reset(" $ ").init()); |
| |
| assertEquals(RTerminal.SUB_NAMED_PART, lexer.next()); |
| assertEquals(0, lexer.getFlags()); |
| |
| assertEquals(RTerminal.EOF, lexer.next()); |
| } |
| |
| @Test |
| public void matchSubSlotPart() { |
| final RLexer lexer= new RLexer(getConfig() | RLexer.SKIP_WHITESPACE); |
| lexer.reset(this.input.reset(" @ ").init()); |
| |
| assertEquals(RTerminal.SUB_NAMED_SLOT, lexer.next()); |
| assertEquals(0, lexer.getFlags()); |
| |
| assertEquals(RTerminal.EOF, lexer.next()); |
| } |
| |
| @Test |
| public void matchNsGet() { |
| final RLexer lexer= new RLexer(getConfig() | RLexer.SKIP_WHITESPACE); |
| lexer.reset(this.input.reset(" :: ").init()); |
| |
| assertEquals(RTerminal.NS_GET, lexer.next()); |
| assertEquals(0, lexer.getFlags()); |
| |
| assertEquals(RTerminal.EOF, lexer.next()); |
| } |
| |
| @Test |
| public void matchNsGetInt() { |
| final RLexer lexer= new RLexer(getConfig() | RLexer.SKIP_WHITESPACE); |
| lexer.reset(this.input.reset(" ::: ").init()); |
| |
| assertEquals(RTerminal.NS_GET_INT, lexer.next()); |
| assertEquals(0, lexer.getFlags()); |
| |
| assertEquals(RTerminal.EOF, lexer.next()); |
| } |
| |
| @Test |
| public void matchPlus() { |
| final RLexer lexer= new RLexer(getConfig() | RLexer.SKIP_WHITESPACE); |
| lexer.reset(this.input.reset(" + ").init()); |
| |
| assertEquals(RTerminal.PLUS, lexer.next()); |
| assertEquals(0, lexer.getFlags()); |
| |
| assertEquals(RTerminal.EOF, lexer.next()); |
| } |
| |
| @Test |
| public void matchMinus() { |
| final RLexer lexer= new RLexer(getConfig() | RLexer.SKIP_WHITESPACE); |
| lexer.reset(this.input.reset(" - ").init()); |
| |
| assertEquals(RTerminal.MINUS, lexer.next()); |
| assertEquals(0, lexer.getFlags()); |
| |
| assertEquals(RTerminal.EOF, lexer.next()); |
| } |
| |
| @Test |
| public void matchMult() { |
| final RLexer lexer= new RLexer(getConfig() | RLexer.SKIP_WHITESPACE); |
| lexer.reset(this.input.reset(" * ").init()); |
| |
| assertEquals(RTerminal.MULT, lexer.next()); |
| assertEquals(0, lexer.getFlags()); |
| |
| assertEquals(RTerminal.EOF, lexer.next()); |
| } |
| |
| @Test |
| public void matchDiv() { |
| final RLexer lexer= new RLexer(getConfig() | RLexer.SKIP_WHITESPACE); |
| lexer.reset(this.input.reset(" / ").init()); |
| |
| assertEquals(RTerminal.DIV, lexer.next()); |
| assertEquals(0, lexer.getFlags()); |
| |
| assertEquals(RTerminal.EOF, lexer.next()); |
| } |
| |
| @Test |
| public void matchOr() { |
| final RLexer lexer= new RLexer(getConfig() | RLexer.SKIP_WHITESPACE); |
| lexer.reset(this.input.reset(" | ").init()); |
| |
| assertEquals(RTerminal.OR, lexer.next()); |
| assertEquals(0, lexer.getFlags()); |
| |
| assertEquals(RTerminal.EOF, lexer.next()); |
| } |
| |
| @Test |
| public void matchOrD() { |
| final RLexer lexer= new RLexer(getConfig() | RLexer.SKIP_WHITESPACE); |
| lexer.reset(this.input.reset(" || ").init()); |
| |
| assertEquals(RTerminal.OR_D, lexer.next()); |
| assertEquals(0, lexer.getFlags()); |
| |
| assertEquals(RTerminal.EOF, lexer.next()); |
| } |
| |
| @Test |
| public void matchAnd() { |
| final RLexer lexer= new RLexer(getConfig() | RLexer.SKIP_WHITESPACE); |
| lexer.reset(this.input.reset(" & ").init()); |
| |
| assertEquals(RTerminal.AND, lexer.next()); |
| assertEquals(0, lexer.getFlags()); |
| |
| assertEquals(RTerminal.EOF, lexer.next()); |
| } |
| |
| @Test |
| public void matchAndD() { |
| final RLexer lexer= new RLexer(getConfig() | RLexer.SKIP_WHITESPACE); |
| lexer.reset(this.input.reset(" && ").init()); |
| |
| assertEquals(RTerminal.AND_D, lexer.next()); |
| assertEquals(0, lexer.getFlags()); |
| |
| assertEquals(RTerminal.EOF, lexer.next()); |
| } |
| |
| @Test |
| public void matchNot() { |
| final RLexer lexer= new RLexer(getConfig() | RLexer.SKIP_WHITESPACE); |
| lexer.reset(this.input.reset(" ! ").init()); |
| |
| assertEquals(RTerminal.NOT, lexer.next()); |
| assertEquals(0, lexer.getFlags()); |
| |
| assertEquals(RTerminal.EOF, lexer.next()); |
| } |
| |
| @Test |
| public void matchPower() { |
| final RLexer lexer= new RLexer(getConfig() | RLexer.SKIP_WHITESPACE); |
| lexer.reset(this.input.reset(" ^ ").init()); |
| |
| assertEquals(RTerminal.POWER, lexer.next()); |
| assertEquals(0, lexer.getFlags()); |
| |
| assertEquals(RTerminal.EOF, lexer.next()); |
| } |
| |
| @Test |
| public void matchSeq() { |
| final RLexer lexer= new RLexer(getConfig() | RLexer.SKIP_WHITESPACE); |
| lexer.reset(this.input.reset(" : ").init()); |
| |
| assertEquals(RTerminal.SEQ, lexer.next()); |
| assertEquals(0, lexer.getFlags()); |
| |
| assertEquals(RTerminal.EOF, lexer.next()); |
| } |
| |
| @Test |
| public void matchSpecial() { |
| final RLexer lexer= new RLexer(getConfig() | RLexer.SKIP_WHITESPACE); |
| lexer.reset(this.input.reset(" %/% ").init()); |
| |
| assertEquals(RTerminal.SPECIAL, lexer.next()); |
| assertEquals(0, lexer.getFlags()); |
| assertEquals("/", lexer.getText()); |
| |
| assertEquals(RTerminal.EOF, lexer.next()); |
| } |
| |
| @Test |
| public void matchSpecial_empty() { |
| final RLexer lexer= new RLexer(getConfig() | RLexer.SKIP_WHITESPACE); |
| lexer.reset(this.input.reset(" %% ").init()); |
| |
| assertEquals(RTerminal.SPECIAL, lexer.next()); |
| assertEquals(0, lexer.getFlags()); |
| assertEquals("", lexer.getText()); |
| |
| assertEquals(RTerminal.EOF, lexer.next()); |
| } |
| |
| @Test |
| public void matchSpecial_notClosed() { |
| final RLexer lexer= new RLexer(getConfig() | RLexer.SKIP_WHITESPACE); |
| lexer.reset(this.input.reset(" %/ ").init()); |
| |
| assertEquals(RTerminal.SPECIAL, lexer.next()); |
| assertEquals(STATUS12_SYNTAX_TOKEN_NOT_CLOSED, lexer.getFlags()); |
| |
| assertEquals(RTerminal.EOF, lexer.next()); |
| |
| lexer.reset(this.input.reset(" %/ \n%").init()); |
| |
| assertEquals(RTerminal.SPECIAL, lexer.next()); |
| assertEquals(STATUS12_SYNTAX_TOKEN_NOT_CLOSED, lexer.getFlags()); |
| |
| assertEquals(RTerminal.LINEBREAK, lexer.next()); |
| } |
| |
| @Test |
| public void matchQuestionmark() { |
| final RLexer lexer= new RLexer(getConfig() | RLexer.SKIP_WHITESPACE); |
| lexer.reset(this.input.reset(" ? ").init()); |
| |
| assertEquals(RTerminal.QUESTIONMARK, lexer.next()); |
| assertEquals(0, lexer.getFlags()); |
| |
| assertEquals(RTerminal.EOF, lexer.next()); |
| } |
| |
| @Test |
| public void matchComma() { |
| final RLexer lexer= new RLexer(getConfig() | RLexer.SKIP_WHITESPACE); |
| lexer.reset(this.input.reset(" , ").init()); |
| |
| assertEquals(RTerminal.COMMA, lexer.next()); |
| assertEquals(0, lexer.getFlags()); |
| |
| assertEquals(RTerminal.EOF, lexer.next()); |
| } |
| |
| @Test |
| public void matchSemi() { |
| final RLexer lexer= new RLexer(getConfig() | RLexer.SKIP_WHITESPACE); |
| lexer.reset(this.input.reset(" ; ").init()); |
| |
| assertEquals(RTerminal.SEMI, lexer.next()); |
| assertEquals(0, lexer.getFlags()); |
| |
| assertEquals(RTerminal.EOF, lexer.next()); |
| } |
| |
| @Test |
| public void matchArrowLeftS() { |
| final RLexer lexer= new RLexer(getConfig() | RLexer.SKIP_WHITESPACE); |
| lexer.reset(this.input.reset(" <- ").init()); |
| |
| assertEquals(RTerminal.ARROW_LEFT_S, lexer.next()); |
| assertEquals(0, lexer.getFlags()); |
| |
| assertEquals(RTerminal.EOF, lexer.next()); |
| } |
| |
| @Test |
| public void matchArrowLeftD() { |
| final RLexer lexer= new RLexer(getConfig() | RLexer.SKIP_WHITESPACE); |
| lexer.reset(this.input.reset(" <<- ").init()); |
| |
| assertEquals(RTerminal.ARROW_LEFT_D, lexer.next()); |
| assertEquals(0, lexer.getFlags()); |
| |
| assertEquals(RTerminal.EOF, lexer.next()); |
| } |
| |
| @Test |
| public void matchArrowRightS() { |
| final RLexer lexer= new RLexer(getConfig() | RLexer.SKIP_WHITESPACE); |
| lexer.reset(this.input.reset(" -> ").init()); |
| |
| assertEquals(RTerminal.ARROW_RIGHT_S, lexer.next()); |
| assertEquals(0, lexer.getFlags()); |
| |
| assertEquals(RTerminal.EOF, lexer.next()); |
| } |
| |
| @Test |
| public void matchArrowRightD() { |
| final RLexer lexer= new RLexer(getConfig() | RLexer.SKIP_WHITESPACE); |
| lexer.reset(this.input.reset(" ->> ").init()); |
| |
| assertEquals(RTerminal.ARROW_RIGHT_D, lexer.next()); |
| assertEquals(0, lexer.getFlags()); |
| |
| assertEquals(RTerminal.EOF, lexer.next()); |
| } |
| |
| @Test |
| public void matchEqual() { |
| final RLexer lexer= new RLexer(getConfig() | RLexer.SKIP_WHITESPACE); |
| lexer.reset(this.input.reset(" = ").init()); |
| |
| assertEquals(RTerminal.EQUAL, lexer.next()); |
| assertEquals(0, lexer.getFlags()); |
| |
| assertEquals(RTerminal.EOF, lexer.next()); |
| } |
| |
| @Test |
| public void matchColonEqual() { |
| final RLexer lexer= new RLexer(getConfig() | RLexer.SKIP_WHITESPACE | RLexer.ENABLE_COLON_EQUAL); |
| lexer.reset(this.input.reset(" := ").init()); |
| |
| assertEquals(RTerminal.COLON_EQUAL, lexer.next()); |
| assertEquals(0, lexer.getFlags()); |
| |
| assertEquals(RTerminal.EOF, lexer.next()); |
| } |
| |
| @Test |
| public void matchColonEqual_disabled() { |
| final RLexer lexer= new RLexer(getConfig() | RLexer.SKIP_WHITESPACE); |
| lexer.reset(this.input.reset(" := ").init()); |
| |
| assertEquals(RTerminal.SEQ, lexer.next()); |
| assertEquals(RTerminal.EQUAL, lexer.next()); |
| |
| assertEquals(RTerminal.EOF, lexer.next()); |
| } |
| |
| @Test |
| public void matchTilde() { |
| final RLexer lexer= new RLexer(getConfig() | RLexer.SKIP_WHITESPACE); |
| lexer.reset(this.input.reset(" ~ ").init()); |
| |
| assertEquals(RTerminal.TILDE, lexer.next()); |
| assertEquals(0, lexer.getFlags()); |
| |
| assertEquals(RTerminal.EOF, lexer.next()); |
| } |
| |
| @Test |
| public void matchRelNE() { |
| final RLexer lexer= new RLexer(getConfig() | RLexer.SKIP_WHITESPACE); |
| lexer.reset(this.input.reset(" != ").init()); |
| |
| assertEquals(RTerminal.REL_NE, lexer.next()); |
| assertEquals(0, lexer.getFlags()); |
| |
| assertEquals(RTerminal.EOF, lexer.next()); |
| } |
| |
| @Test |
| public void matchRelEQ() { |
| final RLexer lexer= new RLexer(getConfig() | RLexer.SKIP_WHITESPACE); |
| lexer.reset(this.input.reset(" == ").init()); |
| |
| assertEquals(RTerminal.REL_EQ, lexer.next()); |
| assertEquals(0, lexer.getFlags()); |
| |
| assertEquals(RTerminal.EOF, lexer.next()); |
| } |
| |
| @Test |
| public void matchRelLT() { |
| final RLexer lexer= new RLexer(getConfig() | RLexer.SKIP_WHITESPACE); |
| lexer.reset(this.input.reset(" < ").init()); |
| |
| assertEquals(RTerminal.REL_LT, lexer.next()); |
| assertEquals(0, lexer.getFlags()); |
| |
| assertEquals(RTerminal.EOF, lexer.next()); |
| } |
| |
| @Test |
| public void matchRelLE() { |
| final RLexer lexer= new RLexer(getConfig() | RLexer.SKIP_WHITESPACE); |
| lexer.reset(this.input.reset(" <= ").init()); |
| |
| assertEquals(RTerminal.REL_LE, lexer.next()); |
| assertEquals(0, lexer.getFlags()); |
| |
| assertEquals(RTerminal.EOF, lexer.next()); |
| } |
| |
| @Test |
| public void matchRelGT() { |
| final RLexer lexer= new RLexer(getConfig() | RLexer.SKIP_WHITESPACE); |
| lexer.reset(this.input.reset(" > ").init()); |
| |
| assertEquals(RTerminal.REL_GT, lexer.next()); |
| assertEquals(0, lexer.getFlags()); |
| |
| assertEquals(RTerminal.EOF, lexer.next()); |
| } |
| |
| @Test |
| public void matchRelGE() { |
| final RLexer lexer= new RLexer(getConfig() | RLexer.SKIP_WHITESPACE); |
| lexer.reset(this.input.reset(" >= ").init()); |
| |
| assertEquals(RTerminal.REL_GE, lexer.next()); |
| assertEquals(0, lexer.getFlags()); |
| |
| assertEquals(RTerminal.EOF, lexer.next()); |
| } |
| |
| |
| @Test |
| public void matchKey_if() { |
| final RLexer lexer= new RLexer(getConfig() | RLexer.SKIP_WHITESPACE); |
| lexer.reset(this.input.reset(" if ").init()); |
| |
| assertEquals(RTerminal.IF, lexer.next()); |
| assertEquals(0, lexer.getFlags()); |
| |
| assertEquals(RTerminal.EOF, lexer.next()); |
| } |
| |
| @Test |
| public void matchKey_else() { |
| final RLexer lexer= new RLexer(getConfig() | RLexer.SKIP_WHITESPACE); |
| lexer.reset(this.input.reset(" else ").init()); |
| |
| assertEquals(RTerminal.ELSE, lexer.next()); |
| assertEquals(0, lexer.getFlags()); |
| |
| assertEquals(RTerminal.EOF, lexer.next()); |
| } |
| |
| @Test |
| public void matchKey_for() { |
| final RLexer lexer= new RLexer(getConfig() | RLexer.SKIP_WHITESPACE); |
| lexer.reset(this.input.reset(" for ").init()); |
| |
| assertEquals(RTerminal.FOR, lexer.next()); |
| assertEquals(0, lexer.getFlags()); |
| |
| assertEquals(RTerminal.EOF, lexer.next()); |
| } |
| |
| @Test |
| public void matchKey_in() { |
| final RLexer lexer= new RLexer(getConfig() | RLexer.SKIP_WHITESPACE); |
| lexer.reset(this.input.reset(" in ").init()); |
| |
| assertEquals(RTerminal.IN, lexer.next()); |
| assertEquals(0, lexer.getFlags()); |
| |
| assertEquals(RTerminal.EOF, lexer.next()); |
| } |
| |
| @Test |
| public void matchKey_while() { |
| final RLexer lexer= new RLexer(getConfig() | RLexer.SKIP_WHITESPACE); |
| lexer.reset(this.input.reset(" while ").init()); |
| |
| assertEquals(RTerminal.WHILE, lexer.next()); |
| assertEquals(0, lexer.getFlags()); |
| |
| assertEquals(RTerminal.EOF, lexer.next()); |
| } |
| |
| @Test |
| public void matchKey_repeat() { |
| final RLexer lexer= new RLexer(getConfig() | RLexer.SKIP_WHITESPACE); |
| lexer.reset(this.input.reset(" repeat ").init()); |
| |
| assertEquals(RTerminal.REPEAT, lexer.next()); |
| assertEquals(0, lexer.getFlags()); |
| |
| assertEquals(RTerminal.EOF, lexer.next()); |
| } |
| |
| @Test |
| public void matchKey_next() { |
| final RLexer lexer= new RLexer(getConfig() | RLexer.SKIP_WHITESPACE); |
| lexer.reset(this.input.reset(" next ").init()); |
| |
| assertEquals(RTerminal.NEXT, lexer.next()); |
| assertEquals(0, lexer.getFlags()); |
| |
| assertEquals(RTerminal.EOF, lexer.next()); |
| } |
| |
| @Test |
| public void matchKey_break() { |
| final RLexer lexer= new RLexer(getConfig() | RLexer.SKIP_WHITESPACE); |
| lexer.reset(this.input.reset(" break ").init()); |
| |
| assertEquals(RTerminal.BREAK, lexer.next()); |
| assertEquals(0, lexer.getFlags()); |
| |
| assertEquals(RTerminal.EOF, lexer.next()); |
| } |
| |
| @Test |
| public void matchKey_function() { |
| final RLexer lexer= new RLexer(getConfig() | RLexer.SKIP_WHITESPACE); |
| lexer.reset(this.input.reset(" function ").init()); |
| |
| assertEquals(RTerminal.FUNCTION, lexer.next()); |
| assertEquals(0, lexer.getFlags()); |
| |
| assertEquals(RTerminal.EOF, lexer.next()); |
| } |
| |
| @Test |
| public void matchKey_TRUE() { |
| final RLexer lexer= new RLexer(getConfig() | RLexer.SKIP_WHITESPACE); |
| lexer.reset(this.input.reset(" TRUE ").init()); |
| |
| assertEquals(RTerminal.TRUE, lexer.next()); |
| assertEquals(0, lexer.getFlags()); |
| |
| assertEquals(RTerminal.EOF, lexer.next()); |
| } |
| |
| @Test |
| public void matchKey_FALSE() { |
| final RLexer lexer= new RLexer(getConfig() | RLexer.SKIP_WHITESPACE); |
| lexer.reset(this.input.reset(" FALSE ").init()); |
| |
| assertEquals(RTerminal.FALSE, lexer.next()); |
| assertEquals(0, lexer.getFlags()); |
| |
| assertEquals(RTerminal.EOF, lexer.next()); |
| } |
| |
| @Test |
| public void matchKey_NA() { |
| final RLexer lexer= new RLexer(getConfig() | RLexer.SKIP_WHITESPACE); |
| lexer.reset(this.input.reset(" NA ").init()); |
| |
| assertEquals(RTerminal.NA, lexer.next()); |
| assertEquals(0, lexer.getFlags()); |
| |
| assertEquals(RTerminal.EOF, lexer.next()); |
| } |
| |
| @Test |
| public void matchKey_NA_real() { |
| final RLexer lexer= new RLexer(getConfig() | RLexer.SKIP_WHITESPACE); |
| lexer.reset(this.input.reset(" NA_real_ ").init()); |
| |
| assertEquals(RTerminal.NA_REAL, lexer.next()); |
| assertEquals(0, lexer.getFlags()); |
| |
| assertEquals(RTerminal.EOF, lexer.next()); |
| } |
| |
| @Test |
| public void matchKey_NA_integer() { |
| final RLexer lexer= new RLexer(getConfig() | RLexer.SKIP_WHITESPACE); |
| lexer.reset(this.input.reset(" NA_integer_ ").init()); |
| |
| assertEquals(RTerminal.NA_INT, lexer.next()); |
| assertEquals(0, lexer.getFlags()); |
| |
| assertEquals(RTerminal.EOF, lexer.next()); |
| } |
| |
| @Test |
| public void matchKey_NA_complex() { |
| final RLexer lexer= new RLexer(getConfig() | RLexer.SKIP_WHITESPACE); |
| lexer.reset(this.input.reset(" NA_complex_ ").init()); |
| |
| assertEquals(RTerminal.NA_CPLX, lexer.next()); |
| assertEquals(0, lexer.getFlags()); |
| |
| assertEquals(RTerminal.EOF, lexer.next()); |
| } |
| |
| @Test |
| public void matchKey_NA_character() { |
| final RLexer lexer= new RLexer(getConfig() | RLexer.SKIP_WHITESPACE); |
| lexer.reset(this.input.reset(" NA_character_ ").init()); |
| |
| assertEquals(RTerminal.NA_CHAR, lexer.next()); |
| assertEquals(0, lexer.getFlags()); |
| |
| assertEquals(RTerminal.EOF, lexer.next()); |
| } |
| |
| @Test |
| public void matchKey_NULL() { |
| final RLexer lexer= new RLexer(getConfig() | RLexer.SKIP_WHITESPACE); |
| lexer.reset(this.input.reset(" NULL ").init()); |
| |
| assertEquals(RTerminal.NULL, lexer.next()); |
| assertEquals(0, lexer.getFlags()); |
| |
| assertEquals(RTerminal.EOF, lexer.next()); |
| } |
| |
| @Test |
| public void matchKey_NaN() { |
| final RLexer lexer= new RLexer(getConfig() | RLexer.SKIP_WHITESPACE); |
| lexer.reset(this.input.reset(" NaN ").init()); |
| |
| assertEquals(RTerminal.NAN, lexer.next()); |
| assertEquals(0, lexer.getFlags()); |
| |
| assertEquals(RTerminal.EOF, lexer.next()); |
| } |
| |
| @Test |
| public void matchKey_Inf() { |
| final RLexer lexer= new RLexer(getConfig() | RLexer.SKIP_WHITESPACE); |
| lexer.reset(this.input.reset(" Inf ").init()); |
| |
| assertEquals(RTerminal.INF, lexer.next()); |
| assertEquals(0, lexer.getFlags()); |
| |
| assertEquals(RTerminal.EOF, lexer.next()); |
| } |
| |
| |
| @Test |
| public void matchStringS() { |
| final RLexer lexer= new RLexer(getConfig() | RLexer.SKIP_WHITESPACE); |
| lexer.reset(this.input.reset(" 'abc' ").init()); |
| |
| assertEquals(RTerminal.STRING_S, lexer.next()); |
| assertEquals(0, lexer.getFlags()); |
| assertEquals("abc", lexer.getText()); |
| |
| assertEquals(RTerminal.EOF, lexer.next()); |
| } |
| |
| @Test |
| public void matchStringS_notClosed() { |
| final RLexer lexer= new RLexer(getConfig() | RLexer.SKIP_WHITESPACE); |
| lexer.reset(this.input.reset(" 'abc ").init()); |
| |
| assertEquals(RTerminal.STRING_S, lexer.next()); |
| assertEquals(STATUS12_SYNTAX_TOKEN_NOT_CLOSED, lexer.getFlags()); |
| assertEquals("abc ", lexer.getText()); |
| |
| assertEquals(RTerminal.EOF, lexer.next()); |
| } |
| |
| @Test |
| public void matchStringS_with_Linebreak() { |
| final RLexer lexer= new RLexer(getConfig() | RLexer.SKIP_WHITESPACE); |
| lexer.reset(this.input.reset(" 'abc\nefg' ").init()); |
| |
| assertEquals(RTerminal.STRING_S, lexer.next()); |
| assertEquals(0, lexer.getFlags()); |
| assertEquals("abc\nefg", lexer.getText()); |
| |
| assertEquals(RTerminal.EOF, lexer.next()); |
| } |
| |
| @Test |
| public void matchStringD() { |
| final RLexer lexer= new RLexer(getConfig() | RLexer.SKIP_WHITESPACE); |
| lexer.reset(this.input.reset(" \"abc\" ").init()); |
| |
| assertEquals(RTerminal.STRING_D, lexer.next()); |
| assertEquals(0, lexer.getFlags()); |
| assertEquals("abc", lexer.getText()); |
| |
| assertEquals(RTerminal.EOF, lexer.next()); |
| } |
| |
| @Test |
| public void matchStringD_notClosed() { |
| final RLexer lexer= new RLexer(getConfig() | RLexer.SKIP_WHITESPACE); |
| lexer.reset(this.input.reset(" \"abc ").init()); |
| |
| assertEquals(RTerminal.STRING_D, lexer.next()); |
| assertEquals(STATUS12_SYNTAX_TOKEN_NOT_CLOSED, lexer.getFlags()); |
| assertEquals("abc ", lexer.getText()); |
| |
| assertEquals(RTerminal.EOF, lexer.next()); |
| } |
| |
| @Test |
| public void matchStringD_with_Linebreak() { |
| final RLexer lexer= new RLexer(getConfig() | RLexer.SKIP_WHITESPACE); |
| lexer.reset(this.input.reset(" \"abc\nefg\" ").init()); |
| |
| assertEquals(RTerminal.STRING_D, lexer.next()); |
| assertEquals(0, lexer.getFlags()); |
| assertEquals("abc\nefg", lexer.getText()); |
| |
| assertEquals(RTerminal.EOF, lexer.next()); |
| } |
| |
| |
| @Test |
| public void matchSymbol() { |
| final RLexer lexer= new RLexer(getConfig() | RLexer.SKIP_WHITESPACE); |
| lexer.reset(this.input.reset(" abc ").init()); |
| |
| assertEquals(RTerminal.SYMBOL, lexer.next()); |
| assertEquals(0, lexer.getFlags()); |
| assertEquals("abc", lexer.getText()); |
| |
| assertEquals(RTerminal.EOF, lexer.next()); |
| } |
| |
| @Test |
| public void matchSymbol_Dot() { |
| final RLexer lexer= new RLexer(getConfig() | RLexer.SKIP_WHITESPACE); |
| lexer.reset(this.input.reset(" . ").init()); |
| |
| assertEquals(RTerminal.SYMBOL, lexer.next()); |
| assertEquals(0, lexer.getFlags()); |
| assertEquals(".", lexer.getText()); |
| |
| assertEquals(RTerminal.EOF, lexer.next()); |
| } |
| |
| @Test |
| public void matchSymbol_contains_Dot() { |
| final RLexer lexer= new RLexer(getConfig() | RLexer.SKIP_WHITESPACE); |
| lexer.reset(this.input.reset(" abc.efg ").init()); |
| |
| assertEquals(RTerminal.SYMBOL, lexer.next()); |
| assertEquals(0, lexer.getFlags()); |
| |
| assertEquals(RTerminal.EOF, lexer.next()); |
| } |
| |
| @Test |
| public void matchSymbol_Ellipsis() { |
| final RLexer lexer= new RLexer(getConfig() | RLexer.SKIP_WHITESPACE); |
| lexer.reset(this.input.reset(" ... ").init()); |
| |
| assertEquals(RTerminal.SYMBOL, lexer.next()); |
| assertEquals(0, lexer.getFlags()); |
| assertEquals("...", lexer.getText()); |
| |
| assertEquals(RTerminal.EOF, lexer.next()); |
| } |
| |
| @Test |
| public void matchSymbol_contains_Dots() { |
| final RLexer lexer= new RLexer(getConfig() | RLexer.SKIP_WHITESPACE); |
| lexer.reset(this.input.reset(" abc...efg ").init()); |
| |
| assertEquals(RTerminal.SYMBOL, lexer.next()); |
| assertEquals(0, lexer.getFlags()); |
| assertEquals("abc...efg", lexer.getText()); |
| |
| assertEquals(RTerminal.EOF, lexer.next()); |
| } |
| |
| @Test |
| public void matchSymbol_beginsWith_Dots() { |
| final RLexer lexer= new RLexer(getConfig() | RLexer.SKIP_WHITESPACE); |
| lexer.reset(this.input.reset(" ...abc ").init()); |
| |
| assertEquals(RTerminal.SYMBOL, lexer.next()); |
| assertEquals(0, lexer.getFlags()); |
| assertEquals("...abc", lexer.getText()); |
| |
| assertEquals(RTerminal.EOF, lexer.next()); |
| } |
| |
| @Test |
| public void matchSymbol_endsWith_Dots() { |
| final RLexer lexer= new RLexer(getConfig() | RLexer.SKIP_WHITESPACE); |
| lexer.reset(this.input.reset(" abc... ").init()); |
| |
| assertEquals(RTerminal.SYMBOL, lexer.next()); |
| assertEquals(0, lexer.getFlags()); |
| assertEquals("abc...", lexer.getText()); |
| |
| assertEquals(RTerminal.EOF, lexer.next()); |
| } |
| |
| @Test |
| public void matchSymbol_beginWith_Underscore() { |
| final RLexer lexer= new RLexer(getConfig() | RLexer.SKIP_WHITESPACE); |
| lexer.reset(this.input.reset(" _abc ").init()); |
| |
| assertEquals(RTerminal.UNKNOWN, lexer.next()); |
| assertEquals(0, lexer.getFlags()); |
| assertEquals(RTerminal.SYMBOL, lexer.next()); |
| assertEquals("abc", lexer.getText()); |
| assertEquals(0, lexer.getFlags()); |
| |
| assertEquals(RTerminal.EOF, lexer.next()); |
| } |
| |
| @Test |
| public void matchSymbol_contains_Underscore() { |
| final RLexer lexer= new RLexer(getConfig() | RLexer.SKIP_WHITESPACE); |
| lexer.reset(this.input.reset(" abc_efg ").init()); |
| |
| assertEquals(RTerminal.SYMBOL, lexer.next()); |
| assertEquals(0, lexer.getFlags()); |
| assertEquals("abc_efg", lexer.getText()); |
| |
| assertEquals(RTerminal.EOF, lexer.next()); |
| } |
| |
| @Test |
| public void matchSymbol_contains_Underscores() { |
| final RLexer lexer= new RLexer(getConfig() | RLexer.SKIP_WHITESPACE); |
| lexer.reset(this.input.reset(" abc___efg ").init()); |
| |
| assertEquals(RTerminal.SYMBOL, lexer.next()); |
| assertEquals(0, lexer.getFlags()); |
| assertEquals("abc___efg", lexer.getText()); |
| |
| assertEquals(RTerminal.EOF, lexer.next()); |
| } |
| |
| @Test |
| public void matchSymbol_endsWith_Underscores() { |
| final RLexer lexer= new RLexer(getConfig() | RLexer.SKIP_WHITESPACE); |
| lexer.reset(this.input.reset(" abc___ ").init()); |
| |
| assertEquals(RTerminal.SYMBOL, lexer.next()); |
| assertEquals(0, lexer.getFlags()); |
| assertEquals("abc___", lexer.getText()); |
| |
| assertEquals(RTerminal.EOF, lexer.next()); |
| } |
| |
| @Test |
| public void matchSymbolG() { |
| final RLexer lexer= new RLexer(getConfig() | RLexer.SKIP_WHITESPACE); |
| lexer.reset(this.input.reset(" `abc` ").init()); |
| |
| assertEquals(RTerminal.SYMBOL_G, lexer.next()); |
| assertEquals(0, lexer.getFlags()); |
| assertEquals("abc", lexer.getText()); |
| |
| assertEquals(RTerminal.EOF, lexer.next()); |
| } |
| |
| @Test |
| public void matchSymbolG_notClosed() { |
| final RLexer lexer= new RLexer(getConfig() | RLexer.SKIP_WHITESPACE); |
| lexer.reset(this.input.reset(" `abc ").init()); |
| |
| assertEquals(RTerminal.SYMBOL_G, lexer.next()); |
| assertEquals(STATUS12_SYNTAX_TOKEN_NOT_CLOSED, lexer.getFlags()); |
| assertEquals("abc ", lexer.getText()); |
| |
| assertEquals(RTerminal.EOF, lexer.next()); |
| } |
| |
| @Test |
| public void matchSymbolG_with_Linebreak() { |
| final RLexer lexer= new RLexer(getConfig() | RLexer.SKIP_WHITESPACE); |
| lexer.reset(this.input.reset(" `abc\nefg` ").init()); |
| |
| assertEquals(RTerminal.SYMBOL_G, lexer.next()); |
| assertEquals(0, lexer.getFlags()); |
| assertEquals("abc\nefg", lexer.getText()); |
| |
| assertEquals(RTerminal.EOF, lexer.next()); |
| } |
| |
| |
| @Test |
| public void matchNumReal_Dec() { |
| final RLexer lexer= new RLexer(getConfig() | RLexer.SKIP_WHITESPACE); |
| lexer.reset(this.input.reset(" 01234567890 ").init()); |
| |
| assertEquals(RTerminal.NUM_NUM, lexer.next()); |
| assertEquals(0, lexer.getFlags()); |
| assertEquals("01234567890", lexer.getText()); |
| |
| assertEquals(RTerminal.EOF, lexer.next()); |
| } |
| |
| @Test |
| public void matchNumReal_Dec_1_0() { |
| final RLexer lexer= new RLexer(getConfig() | RLexer.SKIP_WHITESPACE); |
| lexer.reset(this.input.reset(" 1 2 3 4 5 6 7 8 9 0 ").init()); |
| |
| assertEquals(RTerminal.NUM_NUM, lexer.next()); |
| assertEquals(0, lexer.getFlags()); |
| assertEquals("1", lexer.getText()); |
| |
| assertEquals(RTerminal.NUM_NUM, lexer.next()); |
| assertEquals(0, lexer.getFlags()); |
| assertEquals("2", lexer.getText()); |
| |
| assertEquals(RTerminal.NUM_NUM, lexer.next()); |
| assertEquals(0, lexer.getFlags()); |
| assertEquals("3", lexer.getText()); |
| |
| assertEquals(RTerminal.NUM_NUM, lexer.next()); |
| assertEquals(0, lexer.getFlags()); |
| assertEquals("4", lexer.getText()); |
| |
| assertEquals(RTerminal.NUM_NUM, lexer.next()); |
| assertEquals(0, lexer.getFlags()); |
| assertEquals("5", lexer.getText()); |
| |
| assertEquals(RTerminal.NUM_NUM, lexer.next()); |
| assertEquals(0, lexer.getFlags()); |
| assertEquals("6", lexer.getText()); |
| |
| assertEquals(RTerminal.NUM_NUM, lexer.next()); |
| assertEquals(0, lexer.getFlags()); |
| assertEquals("7", lexer.getText()); |
| |
| assertEquals(RTerminal.NUM_NUM, lexer.next()); |
| assertEquals(0, lexer.getFlags()); |
| assertEquals("8", lexer.getText()); |
| |
| assertEquals(RTerminal.NUM_NUM, lexer.next()); |
| assertEquals(0, lexer.getFlags()); |
| assertEquals("9", lexer.getText()); |
| |
| assertEquals(RTerminal.NUM_NUM, lexer.next()); |
| assertEquals(0, lexer.getFlags()); |
| assertEquals("0", lexer.getText()); |
| |
| assertEquals(RTerminal.EOF, lexer.next()); |
| } |
| |
| @Test |
| public void matchNumReal_Dec_with_Point() { |
| final RLexer lexer= new RLexer(getConfig() | RLexer.SKIP_WHITESPACE); |
| lexer.reset(this.input.reset(" 123.456 ").init()); |
| |
| assertEquals(RTerminal.NUM_NUM, lexer.next()); |
| assertEquals(0, lexer.getFlags()); |
| assertEquals("123.456", lexer.getText()); |
| |
| assertEquals(RTerminal.EOF, lexer.next()); |
| } |
| |
| @Test |
| public void matchNumReal_Dec_startsWith_Point() { |
| final RLexer lexer= new RLexer(getConfig() | RLexer.SKIP_WHITESPACE); |
| lexer.reset(this.input.reset(" .123 ").init()); |
| |
| assertEquals(RTerminal.NUM_NUM, lexer.next()); |
| assertEquals(0, lexer.getFlags()); |
| assertEquals(".123", lexer.getText()); |
| |
| assertEquals(RTerminal.EOF, lexer.next()); |
| } |
| |
| @Test |
| public void matchNumReal_Dec_endsWith_Point() { |
| final RLexer lexer= new RLexer(getConfig() | RLexer.SKIP_WHITESPACE); |
| lexer.reset(this.input.reset(" 123. ").init()); |
| |
| assertEquals(RTerminal.NUM_NUM, lexer.next()); |
| assertEquals(0, lexer.getFlags()); |
| assertEquals("123.", lexer.getText()); |
| |
| assertEquals(RTerminal.EOF, lexer.next()); |
| } |
| |
| @Test |
| public void matchNumReal_Dec_withExp() { |
| final RLexer lexer= new RLexer(getConfig() | RLexer.SKIP_WHITESPACE); |
| lexer.reset(this.input.reset(" 123.4e0 123.e10 ").init()); |
| |
| assertEquals(RTerminal.NUM_NUM, lexer.next()); |
| assertEquals(0, lexer.getFlags()); |
| assertEquals("123.4e0", lexer.getText()); |
| |
| assertEquals(RTerminal.NUM_NUM, lexer.next()); |
| assertEquals(0, lexer.getFlags()); |
| assertEquals("123.e10", lexer.getText()); |
| |
| assertEquals(RTerminal.EOF, lexer.next()); |
| } |
| |
| @Test |
| public void matchNumReal_Dec_withExp_withSign() { |
| final RLexer lexer= new RLexer(getConfig() | RLexer.SKIP_WHITESPACE); |
| lexer.reset(this.input.reset(" 123.4e+1 123.4e-1 ").init()); |
| |
| assertEquals(RTerminal.NUM_NUM, lexer.next()); |
| assertEquals(0, lexer.getFlags()); |
| assertEquals("123.4e+1", lexer.getText()); |
| |
| assertEquals(RTerminal.NUM_NUM, lexer.next()); |
| assertEquals(0, lexer.getFlags()); |
| assertEquals("123.4e-1", lexer.getText()); |
| |
| assertEquals(RTerminal.EOF, lexer.next()); |
| } |
| |
| @Test |
| public void matchNumReal_Dec_withExp_missingExpDigit() { |
| final RLexer lexer= new RLexer(getConfig() | RLexer.SKIP_WHITESPACE); |
| lexer.reset(this.input.reset(" 123.4e 123.4e+ 123e- ").init()); |
| |
| assertEquals(RTerminal.NUM_NUM, lexer.next()); |
| assertEquals(STATUS123_SYNTAX_NUMBER_EXP_DIGIT_MISSING, lexer.getFlags()); |
| |
| assertEquals(RTerminal.NUM_NUM, lexer.next()); |
| assertEquals(STATUS123_SYNTAX_NUMBER_EXP_DIGIT_MISSING, lexer.getFlags()); |
| |
| assertEquals(RTerminal.NUM_NUM, lexer.next()); |
| assertEquals(STATUS123_SYNTAX_NUMBER_EXP_DIGIT_MISSING, lexer.getFlags()); |
| |
| assertEquals(RTerminal.EOF, lexer.next()); |
| } |
| |
| @Test |
| public void matchNumReal_Hex() { |
| final RLexer lexer= new RLexer(getConfig() | RLexer.SKIP_WHITESPACE); |
| lexer.reset(this.input.reset(" 0x01234567890 0xabcdef 0xABCDEF ").init()); |
| |
| assertEquals(RTerminal.NUM_NUM, lexer.next()); |
| assertEquals(0, lexer.getFlags()); |
| assertEquals("0x01234567890", lexer.getText()); |
| |
| assertEquals(RTerminal.NUM_NUM, lexer.next()); |
| assertEquals(0, lexer.getFlags()); |
| assertEquals("0xabcdef", lexer.getText()); |
| |
| assertEquals(RTerminal.NUM_NUM, lexer.next()); |
| assertEquals(0, lexer.getFlags()); |
| assertEquals("0xABCDEF", lexer.getText()); |
| |
| assertEquals(RTerminal.EOF, lexer.next()); |
| } |
| |
| @Test |
| public void matchNumReal_Hex_0_F() { |
| final RLexer lexer= new RLexer(getConfig() | RLexer.SKIP_WHITESPACE); |
| lexer.reset(this.input.reset(" 0x0 0x1 0x2 0x3 0x4 0x5 0x6 0x7 0x8 0x9 0xA 0xB 0xC 0xD 0xE 0xF 0xa 0xb 0xc 0xd 0xe 0xf ").init()); |
| |
| assertEquals(RTerminal.NUM_NUM, lexer.next()); |
| assertEquals(0, lexer.getFlags()); |
| assertEquals("0x0", lexer.getText()); |
| |
| assertEquals(RTerminal.NUM_NUM, lexer.next()); |
| assertEquals(0, lexer.getFlags()); |
| assertEquals("0x1", lexer.getText()); |
| |
| assertEquals(RTerminal.NUM_NUM, lexer.next()); |
| assertEquals(0, lexer.getFlags()); |
| assertEquals("0x2", lexer.getText()); |
| |
| assertEquals(RTerminal.NUM_NUM, lexer.next()); |
| assertEquals(0, lexer.getFlags()); |
| assertEquals("0x3", lexer.getText()); |
| |
| assertEquals(RTerminal.NUM_NUM, lexer.next()); |
| assertEquals(0, lexer.getFlags()); |
| assertEquals("0x4", lexer.getText()); |
| |
| assertEquals(RTerminal.NUM_NUM, lexer.next()); |
| assertEquals(0, lexer.getFlags()); |
| assertEquals("0x5", lexer.getText()); |
| |
| assertEquals(RTerminal.NUM_NUM, lexer.next()); |
| assertEquals(0, lexer.getFlags()); |
| assertEquals("0x6", lexer.getText()); |
| |
| assertEquals(RTerminal.NUM_NUM, lexer.next()); |
| assertEquals(0, lexer.getFlags()); |
| assertEquals("0x7", lexer.getText()); |
| |
| assertEquals(RTerminal.NUM_NUM, lexer.next()); |
| assertEquals(0, lexer.getFlags()); |
| assertEquals("0x8", lexer.getText()); |
| |
| assertEquals(RTerminal.NUM_NUM, lexer.next()); |
| assertEquals(0, lexer.getFlags()); |
| assertEquals("0x9", lexer.getText()); |
| |
| assertEquals(RTerminal.NUM_NUM, lexer.next()); |
| assertEquals(0, lexer.getFlags()); |
| assertEquals("0xA", lexer.getText()); |
| |
| assertEquals(RTerminal.NUM_NUM, lexer.next()); |
| assertEquals(0, lexer.getFlags()); |
| assertEquals("0xB", lexer.getText()); |
| |
| assertEquals(RTerminal.NUM_NUM, lexer.next()); |
| assertEquals(0, lexer.getFlags()); |
| assertEquals("0xC", lexer.getText()); |
| |
| assertEquals(RTerminal.NUM_NUM, lexer.next()); |
| assertEquals(0, lexer.getFlags()); |
| assertEquals("0xD", lexer.getText()); |
| |
| assertEquals(RTerminal.NUM_NUM, lexer.next()); |
| assertEquals(0, lexer.getFlags()); |
| assertEquals("0xE", lexer.getText()); |
| |
| assertEquals(RTerminal.NUM_NUM, lexer.next()); |
| assertEquals(0, lexer.getFlags()); |
| assertEquals("0xF", lexer.getText()); |
| |
| assertEquals(RTerminal.NUM_NUM, lexer.next()); |
| assertEquals(0, lexer.getFlags()); |
| assertEquals("0xa", lexer.getText()); |
| |
| assertEquals(RTerminal.NUM_NUM, lexer.next()); |
| assertEquals(0, lexer.getFlags()); |
| assertEquals("0xb", lexer.getText()); |
| |
| assertEquals(RTerminal.NUM_NUM, lexer.next()); |
| assertEquals(0, lexer.getFlags()); |
| assertEquals("0xc", lexer.getText()); |
| |
| assertEquals(RTerminal.NUM_NUM, lexer.next()); |
| assertEquals(0, lexer.getFlags()); |
| assertEquals("0xd", lexer.getText()); |
| |
| assertEquals(RTerminal.NUM_NUM, lexer.next()); |
| assertEquals(0, lexer.getFlags()); |
| assertEquals("0xe", lexer.getText()); |
| |
| assertEquals(RTerminal.NUM_NUM, lexer.next()); |
| assertEquals(0, lexer.getFlags()); |
| assertEquals("0xf", lexer.getText()); |
| |
| assertEquals(RTerminal.EOF, lexer.next()); |
| } |
| |
| @Test |
| public void matchNumReal_Hex_missingDigit() { |
| final RLexer lexer= new RLexer(getConfig() | RLexer.SKIP_WHITESPACE); |
| lexer.reset(this.input.reset(" 0x 0xp ").init()); |
| |
| assertEquals(RTerminal.NUM_NUM, lexer.next()); |
| assertEquals(STATUS123_SYNTAX_NUMBER_HEX_DIGIT_MISSING, lexer.getFlags()); |
| |
| assertEquals(RTerminal.NUM_NUM, lexer.next()); |
| assertEquals(STATUS123_SYNTAX_NUMBER_HEX_DIGIT_MISSING, lexer.getFlags()); |
| } |
| |
| @Test |
| public void matchNumReal_HexFloat_withoutPoint() { |
| final RLexer lexer= new RLexer(getConfig() | RLexer.SKIP_WHITESPACE); |
| lexer.reset(this.input.reset(" 0x123ABCp10 0x0FFp01 ").init()); |
| |
| assertEquals(RTerminal.NUM_NUM, lexer.next()); |
| assertEquals(0, lexer.getFlags()); |
| assertEquals("0x123ABCp10", lexer.getText()); |
| |
| assertEquals(RTerminal.NUM_NUM, lexer.next()); |
| assertEquals(0, lexer.getFlags()); |
| assertEquals("0x0FFp01", lexer.getText()); |
| |
| assertEquals(RTerminal.EOF, lexer.next()); |
| } |
| |
| @Test |
| public void matchNumReal_HexFloat_with_Point() { |
| final RLexer lexer= new RLexer(getConfig() | RLexer.SKIP_WHITESPACE); |
| lexer.reset(this.input.reset(" 0x123.456p0 0x.ABCDEFp10 0x123.456 0xA.A ").init()); |
| |
| assertEquals(RTerminal.NUM_NUM, lexer.next()); |
| assertEquals(0, lexer.getFlags()); |
| assertEquals("0x123.456p0", lexer.getText()); |
| |
| assertEquals(RTerminal.NUM_NUM, lexer.next()); |
| assertEquals(0, lexer.getFlags()); |
| assertEquals("0x.ABCDEFp10", lexer.getText()); |
| |
| assertEquals(RTerminal.NUM_NUM, lexer.next()); |
| assertEquals(STATUS123_SYNTAX_NUMBER_HEX_FLOAT_EXP_MISSING, lexer.getFlags()); |
| assertEquals("0x123.456", lexer.getText()); |
| |
| assertEquals(RTerminal.NUM_NUM, lexer.next()); |
| assertEquals(STATUS123_SYNTAX_NUMBER_HEX_FLOAT_EXP_MISSING, lexer.getFlags()); |
| assertEquals("0xA.A", lexer.getText()); |
| |
| assertEquals(RTerminal.EOF, lexer.next()); |
| } |
| |
| @Test |
| public void matchNumReal_HexFloat_startsWith_Point() { |
| final RLexer lexer= new RLexer(getConfig() | RLexer.SKIP_WHITESPACE); |
| lexer.reset(this.input.reset(" 0x.123p0 0x.123 ").init()); |
| |
| assertEquals(RTerminal.NUM_NUM, lexer.next()); |
| assertEquals(0, lexer.getFlags()); |
| assertEquals("0x.123p0", lexer.getText()); |
| |
| assertEquals(RTerminal.NUM_NUM, lexer.next()); |
| assertEquals(STATUS123_SYNTAX_NUMBER_HEX_FLOAT_EXP_MISSING, lexer.getFlags()); |
| assertEquals("0x.123", lexer.getText()); |
| |
| assertEquals(RTerminal.EOF, lexer.next()); |
| } |
| |
| @Test |
| public void matchNumReal_HexFloat_endsWith_Point() { |
| final RLexer lexer= new RLexer(getConfig() | RLexer.SKIP_WHITESPACE); |
| lexer.reset(this.input.reset(" 0x123.p0 0x123. ").init()); |
| |
| assertEquals(RTerminal.NUM_NUM, lexer.next()); |
| assertEquals(0, lexer.getFlags()); |
| assertEquals("0x123.p0", lexer.getText()); |
| |
| assertEquals(RTerminal.NUM_NUM, lexer.next()); |
| assertEquals(STATUS123_SYNTAX_NUMBER_HEX_FLOAT_EXP_MISSING, lexer.getFlags()); |
| assertEquals("0x123.", lexer.getText()); |
| |
| assertEquals(RTerminal.EOF, lexer.next()); |
| } |
| |
| @Test |
| public void matchNumReal_HexFloat_withExpSign() { |
| final RLexer lexer= new RLexer(getConfig() | RLexer.SKIP_WHITESPACE); |
| lexer.reset(this.input.reset(" 0x123.4p+10 0x123.4p-01 ").init()); |
| |
| assertEquals(RTerminal.NUM_NUM, lexer.next()); |
| assertEquals(0, lexer.getFlags()); |
| assertEquals("0x123.4p+10", lexer.getText()); |
| |
| assertEquals(RTerminal.NUM_NUM, lexer.next()); |
| assertEquals(0, lexer.getFlags()); |
| assertEquals("0x123.4p-01", lexer.getText()); |
| |
| assertEquals(RTerminal.EOF, lexer.next()); |
| } |
| |
| @Test |
| public void matchNumReal_HexFloat_missingExpDigit() { |
| final RLexer lexer= new RLexer(getConfig() | RLexer.SKIP_WHITESPACE); |
| lexer.reset(this.input.reset(" 0x123.4p 0x123.4p+ 0x123p- 0x123.4pA ").init()); |
| |
| assertEquals(RTerminal.NUM_NUM, lexer.next()); |
| assertEquals(STATUS123_SYNTAX_NUMBER_EXP_DIGIT_MISSING, lexer.getFlags()); |
| |
| assertEquals(RTerminal.NUM_NUM, lexer.next()); |
| assertEquals(STATUS123_SYNTAX_NUMBER_EXP_DIGIT_MISSING, lexer.getFlags()); |
| |
| assertEquals(RTerminal.NUM_NUM, lexer.next()); |
| assertEquals(STATUS123_SYNTAX_NUMBER_EXP_DIGIT_MISSING, lexer.getFlags()); |
| |
| assertEquals(RTerminal.NUM_NUM, lexer.next()); |
| assertEquals(STATUS123_SYNTAX_NUMBER_EXP_DIGIT_MISSING, lexer.getFlags()); |
| |
| assertEquals(RTerminal.SYMBOL, lexer.next()); |
| assertEquals(0, lexer.getFlags()); |
| assertEquals("A", lexer.getText()); |
| |
| assertEquals(RTerminal.EOF, lexer.next()); |
| } |
| |
| |
| @Test |
| public void matchNumInt_Dec() { |
| final RLexer lexer= new RLexer(getConfig() | RLexer.SKIP_WHITESPACE); |
| lexer.reset(this.input.reset(" 123L ").init()); |
| |
| assertEquals(RTerminal.NUM_INT, lexer.next()); |
| assertEquals(0, lexer.getFlags()); |
| assertEquals("123L", lexer.getText()); |
| |
| assertEquals(RTerminal.EOF, lexer.next()); |
| } |
| |
| @Test |
| public void matchNumInt_Dec_check() { |
| final RLexer lexer= new RLexer(getConfig() | RLexer.SKIP_WHITESPACE); |
| lexer.reset(this.input.reset(" 2147483647L 2147483648L ").init()); |
| |
| assertEquals(RTerminal.NUM_INT, lexer.next()); |
| assertEquals(0, lexer.getFlags()); |
| |
| assertEquals(RTerminal.NUM_NUM, lexer.next()); |
| assertEquals(STATUS123_SYNTAX_NUMBER_NON_INT_WITH_L, lexer.getFlags()); |
| |
| assertEquals(RTerminal.EOF, lexer.next()); |
| } |
| |
| @Test |
| public void matchNumInt_Dec_with_Point() { |
| final RLexer lexer= new RLexer(getConfig() | RLexer.SKIP_WHITESPACE); |
| lexer.reset(this.input.reset(" 2147483647.0L .1L ").init()); |
| |
| assertEquals(RTerminal.NUM_INT, lexer.next()); |
| assertEquals(STATUS123_SYNTAX_NUMBER_INT_WITH_DEC_POINT, lexer.getFlags()); |
| |
| assertEquals(RTerminal.NUM_NUM, lexer.next()); |
| assertEquals(STATUS123_SYNTAX_NUMBER_NON_INT_WITH_L, lexer.getFlags()); |
| |
| assertEquals(RTerminal.EOF, lexer.next()); |
| } |
| |
| @Test |
| public void matchNumInt_Dec_withExp() { |
| final RLexer lexer= new RLexer(getConfig() | RLexer.SKIP_WHITESPACE); |
| lexer.reset(this.input.reset(" 1e9L 1.5e9L ").init()); |
| |
| assertEquals(RTerminal.NUM_INT, lexer.next()); |
| assertEquals(0, lexer.getFlags()); |
| assertEquals("1e9L", lexer.getText()); |
| |
| assertEquals(RTerminal.NUM_INT, lexer.next()); |
| assertEquals(0, lexer.getFlags()); |
| assertEquals("1.5e9L", lexer.getText()); |
| |
| assertEquals(RTerminal.EOF, lexer.next()); |
| } |
| |
| @Test |
| public void matchNumInt_Dec_withExpSign() { |
| final RLexer lexer= new RLexer(getConfig() | RLexer.SKIP_WHITESPACE); |
| lexer.reset(this.input.reset(" 0.5e+9L 100e-1L ").init()); |
| |
| assertEquals(RTerminal.NUM_INT, lexer.next()); |
| assertEquals(0, lexer.getFlags()); |
| assertEquals("0.5e+9L", lexer.getText()); |
| |
| assertEquals(RTerminal.NUM_INT, lexer.next()); |
| assertEquals(0, lexer.getFlags()); |
| assertEquals("100e-1L", lexer.getText()); |
| |
| assertEquals(RTerminal.EOF, lexer.next()); |
| } |
| |
| @Test |
| public void matchNumInt_Dec_withExp_check() { |
| final RLexer lexer= new RLexer(getConfig() | RLexer.SKIP_WHITESPACE); |
| lexer.reset(this.input.reset(" 2147483647e0L 2147483647.0e0L 2147483648.0e0L 1e10L ").init()); |
| |
| assertEquals(RTerminal.NUM_INT, lexer.next()); |
| assertEquals(0, lexer.getFlags()); |
| |
| assertEquals(RTerminal.NUM_INT, lexer.next()); |
| assertEquals(0, lexer.getFlags()); |
| |
| assertEquals(RTerminal.NUM_NUM, lexer.next()); |
| assertEquals(STATUS123_SYNTAX_NUMBER_NON_INT_WITH_L, lexer.getFlags()); |
| |
| assertEquals(RTerminal.NUM_NUM, lexer.next()); |
| assertEquals(STATUS123_SYNTAX_NUMBER_NON_INT_WITH_L, lexer.getFlags()); |
| |
| assertEquals(RTerminal.EOF, lexer.next()); |
| } |
| |
| @Test |
| public void matchNumInt_Dec_missingExpDigit() { |
| final RLexer lexer= new RLexer(getConfig() | RLexer.SKIP_WHITESPACE); |
| lexer.reset(this.input.reset(" 123.4eL 123e+L 123e-L ").init()); |
| |
| assertEquals(RTerminal.NUM_INT, lexer.next()); |
| assertEquals(STATUS123_SYNTAX_NUMBER_EXP_DIGIT_MISSING, lexer.getFlags()); |
| |
| assertEquals(RTerminal.NUM_INT, lexer.next()); |
| assertEquals(STATUS123_SYNTAX_NUMBER_EXP_DIGIT_MISSING, lexer.getFlags()); |
| |
| assertEquals(RTerminal.NUM_INT, lexer.next()); |
| assertEquals(STATUS123_SYNTAX_NUMBER_EXP_DIGIT_MISSING, lexer.getFlags()); |
| |
| assertEquals(RTerminal.EOF, lexer.next()); |
| } |
| |
| @Test |
| public void matchNumInt_Hex() { |
| final RLexer lexer= new RLexer(getConfig() | RLexer.SKIP_WHITESPACE); |
| lexer.reset(this.input.reset(" 0x0123ABCL ").init()); |
| |
| assertEquals(RTerminal.NUM_INT, lexer.next()); |
| assertEquals(0, lexer.getFlags()); |
| assertEquals("0x0123ABCL", lexer.getText()); |
| |
| assertEquals(RTerminal.EOF, lexer.next()); |
| } |
| |
| @Test |
| public void matchNumInt_Hex_check() { |
| final RLexer lexer= new RLexer(getConfig() | RLexer.SKIP_WHITESPACE); |
| lexer.reset(this.input.reset(" 0x7FFFFFFFL 0x8FFFFFFFL 0xfffffffffffffffffffffffffffffffffffffffL ").init()); |
| |
| assertEquals(RTerminal.NUM_INT, lexer.next()); |
| assertEquals(0, lexer.getFlags()); |
| |
| assertEquals(RTerminal.NUM_NUM, lexer.next()); |
| assertEquals(STATUS123_SYNTAX_NUMBER_NON_INT_WITH_L, lexer.getFlags()); |
| |
| assertEquals(RTerminal.NUM_NUM, lexer.next()); |
| assertEquals(STATUS123_SYNTAX_NUMBER_NON_INT_WITH_L, lexer.getFlags()); |
| |
| assertEquals(RTerminal.EOF, lexer.next()); |
| } |
| |
| @Test |
| public void matchNumInt_Hex_missingDigit() { |
| final RLexer lexer= new RLexer(getConfig() | RLexer.SKIP_WHITESPACE); |
| lexer.reset(this.input.reset(" 0xL ").init()); |
| |
| assertEquals(RTerminal.NUM_INT, lexer.next()); |
| assertEquals(STATUS123_SYNTAX_NUMBER_HEX_DIGIT_MISSING, lexer.getFlags()); |
| |
| assertEquals(RTerminal.EOF, lexer.next()); |
| } |
| |
| @Test |
| public void matchNumInt_HexFloat() { |
| final RLexer lexer= new RLexer(getConfig() | RLexer.SKIP_WHITESPACE); |
| lexer.reset(this.input.reset(" 0x123p0L 0x.Ap10L 0x123.456L 0xA.AL ").init()); |
| |
| assertEquals(RTerminal.NUM_INT, lexer.next()); |
| assertEquals(0, lexer.getFlags()); |
| assertEquals("0x123p0L", lexer.getText()); |
| |
| assertEquals(RTerminal.NUM_INT, lexer.next()); |
| assertEquals(0, lexer.getFlags()); |
| assertEquals("0x.Ap10L", lexer.getText()); |
| |
| assertEquals(RTerminal.NUM_INT, lexer.next()); |
| assertEquals(STATUS123_SYNTAX_NUMBER_HEX_FLOAT_EXP_MISSING, lexer.getFlags()); |
| assertEquals("0x123.456L", lexer.getText()); |
| |
| assertEquals(RTerminal.NUM_INT, lexer.next()); |
| assertEquals(STATUS123_SYNTAX_NUMBER_HEX_FLOAT_EXP_MISSING, lexer.getFlags()); |
| assertEquals("0xA.AL", lexer.getText()); |
| |
| assertEquals(RTerminal.EOF, lexer.next()); |
| } |
| |
| @Test |
| public void matchNumInt_HexFloat_check() { |
| final RLexer lexer= new RLexer(getConfig() | RLexer.SKIP_WHITESPACE); |
| lexer.reset(this.input.reset(" 0x123.4p0L 0x.ABCEp10L ").init()); |
| |
| assertEquals(RTerminal.NUM_NUM, lexer.next()); |
| assertEquals(STATUS123_SYNTAX_NUMBER_NON_INT_WITH_L, lexer.getFlags()); |
| assertEquals("0x123.4p0L", lexer.getText()); |
| |
| assertEquals(RTerminal.NUM_NUM, lexer.next()); |
| assertEquals(STATUS123_SYNTAX_NUMBER_NON_INT_WITH_L, lexer.getFlags()); |
| assertEquals("0x.ABCEp10L", lexer.getText()); |
| |
| assertEquals(RTerminal.EOF, lexer.next()); |
| } |
| |
| @Test |
| public void matchNumInt_HexFloat_withExpSign() { |
| final RLexer lexer= new RLexer(getConfig() | RLexer.SKIP_WHITESPACE); |
| lexer.reset(this.input.reset(" 0x123.4p+10L 0x1200p-01L ").init()); |
| |
| assertEquals(RTerminal.NUM_INT, lexer.next()); |
| assertEquals(0, lexer.getFlags()); |
| assertEquals("0x123.4p+10L", lexer.getText()); |
| |
| assertEquals(RTerminal.NUM_INT, lexer.next()); |
| assertEquals(0, lexer.getFlags()); |
| assertEquals("0x1200p-01L", lexer.getText()); |
| |
| assertEquals(RTerminal.EOF, lexer.next()); |
| } |
| |
| @Test |
| public void matchNumInt_HexFloat_missingExpDigit() { |
| final RLexer lexer= new RLexer(getConfig() | RLexer.SKIP_WHITESPACE); |
| lexer.reset(this.input.reset(" 0x123.4pL 0x123.4p+L 0x123p-L ").init()); |
| |
| assertEquals(RTerminal.NUM_INT, lexer.next()); |
| assertEquals(STATUS123_SYNTAX_NUMBER_EXP_DIGIT_MISSING, lexer.getFlags()); |
| |
| assertEquals(RTerminal.NUM_INT, lexer.next()); |
| assertEquals(STATUS123_SYNTAX_NUMBER_EXP_DIGIT_MISSING, lexer.getFlags()); |
| |
| assertEquals(RTerminal.NUM_INT, lexer.next()); |
| assertEquals(STATUS123_SYNTAX_NUMBER_EXP_DIGIT_MISSING, lexer.getFlags()); |
| |
| assertEquals(RTerminal.EOF, lexer.next()); |
| } |
| |
| |
| @Test |
| public void matchNumCplx() { |
| final RLexer lexer= new RLexer(getConfig() | RLexer.SKIP_WHITESPACE); |
| lexer.reset(this.input.reset(" 123i ").init()); |
| |
| assertEquals(RTerminal.NUM_CPLX, lexer.next()); |
| assertEquals(0, lexer.getFlags()); |
| assertEquals("123i", lexer.getText()); |
| |
| assertEquals(RTerminal.EOF, lexer.next()); |
| } |
| |
| @Test |
| public void matchNumCplx_Dec() { |
| final RLexer lexer= new RLexer(getConfig() | RLexer.SKIP_WHITESPACE); |
| lexer.reset(this.input.reset(" 123.456i .456i 123.i").init()); |
| |
| assertEquals(RTerminal.NUM_CPLX, lexer.next()); |
| assertEquals(0, lexer.getFlags()); |
| assertEquals("123.456i", lexer.getText()); |
| |
| assertEquals(RTerminal.NUM_CPLX, lexer.next()); |
| assertEquals(0, lexer.getFlags()); |
| assertEquals(".456i", lexer.getText()); |
| |
| assertEquals(RTerminal.NUM_CPLX, lexer.next()); |
| assertEquals(0, lexer.getFlags()); |
| assertEquals("123.i", lexer.getText()); |
| |
| assertEquals(RTerminal.EOF, lexer.next()); |
| } |
| |
| @Test |
| public void matchNumCplx_Hex() { |
| final RLexer lexer= new RLexer(getConfig() | RLexer.SKIP_WHITESPACE); |
| lexer.reset(this.input.reset(" 0x0123ABCi ").init()); |
| |
| assertEquals(RTerminal.NUM_CPLX, lexer.next()); |
| assertEquals(0, lexer.getFlags()); |
| assertEquals("0x0123ABCi", lexer.getText()); |
| |
| assertEquals(RTerminal.EOF, lexer.next()); |
| } |
| |
| @Test |
| public void matchNumCplx_Hex_missingDigit() { |
| final RLexer lexer= new RLexer(getConfig() | RLexer.SKIP_WHITESPACE); |
| lexer.reset(this.input.reset(" 0xi ").init()); |
| |
| assertEquals(RTerminal.NUM_CPLX, lexer.next()); |
| assertEquals(STATUS123_SYNTAX_NUMBER_HEX_DIGIT_MISSING, lexer.getFlags()); |
| |
| assertEquals(RTerminal.EOF, lexer.next()); |
| } |
| |
| @Test |
| public void matchNumCplx_HexFloat() { |
| final RLexer lexer= new RLexer(getConfig() | RLexer.SKIP_WHITESPACE); |
| lexer.reset(this.input.reset(" 0x0123A.BCp0i ").init()); |
| |
| assertEquals(RTerminal.NUM_CPLX, lexer.next()); |
| assertEquals(0, lexer.getFlags()); |
| assertEquals("0x0123A.BCp0i", lexer.getText()); |
| |
| assertEquals(RTerminal.EOF, lexer.next()); |
| } |
| |
| @Test |
| public void matchNumCplx_HexFloat_missingExp() { |
| final RLexer lexer= new RLexer(getConfig() | RLexer.SKIP_WHITESPACE); |
| lexer.reset(this.input.reset(" 0x0123A.BCi ").init()); |
| |
| assertEquals(RTerminal.NUM_CPLX, lexer.next()); |
| assertEquals(STATUS123_SYNTAX_NUMBER_HEX_FLOAT_EXP_MISSING, lexer.getFlags()); |
| assertEquals("0x0123A.BCi", lexer.getText()); |
| |
| assertEquals(RTerminal.EOF, lexer.next()); |
| } |
| |
| } |