r/org.eclipse.statet.r.core-tests/src/org/eclipse/statet/r/core/rsource/RLexerTextEncodingTest.java

/*=============================================================================#
 # 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.jupiter.api.Assertions.assertEquals;

import static org.eclipse.statet.r.core.rsource.RSourceConstants.STATUS123_SYNTAX_TEXT_ESCAPE_SEQ_HEX_DIGIT_MISSING;
import static org.eclipse.statet.r.core.rsource.RSourceConstants.STATUS123_SYNTAX_TEXT_ESCAPE_SEQ_NOT_CLOSED;
import static org.eclipse.statet.r.core.rsource.RSourceConstants.STATUS123_SYNTAX_TEXT_ESCAPE_SEQ_UNEXPECTED;
import static org.eclipse.statet.r.core.rsource.RSourceConstants.STATUS123_SYNTAX_TEXT_ESCAPE_SEQ_UNKOWN;
import static org.eclipse.statet.r.core.rsource.RSourceConstants.STATUS123_SYNTAX_TEXT_NULLCHAR;

import org.junit.jupiter.api.Test;

import org.eclipse.statet.jcommons.text.core.input.StringParserInput;

import org.eclipse.statet.ltk.ast.core.StatusDetail;
import org.eclipse.statet.r.core.rlang.RTerminal;


public class RLexerTextEncodingTest {
	
	
	private static void assertDetail(final int expectedOffset, final int expectedLength,
			final String expectedText, final StatusDetail actual) {
		assertEquals(expectedOffset, actual.getStartOffset());
		assertEquals(expectedLength, actual.getLength());
		assertEquals(expectedText, actual.getText());
	}
	
	
	private final StringParserInput input= new StringParserInput();
	
	
	public RLexerTextEncodingTest() {
	}
	
	
	@Test
	public void matchStringS_with_SpecialCharEscape() {
		final RLexer lexer= new RLexer(RLexer.SKIP_WHITESPACE);
		lexer.reset(this.input.reset(" 'abc \\\' \\\" \\` \\a \\b \\f \\n \\r \\t \\v \\\\ \\\n e' ").init());
		
		assertEquals(RTerminal.STRING_S, lexer.next());
		assertEquals(0, lexer.getFlags());
		assertEquals("abc \' \" ` \u0007 \u0008 \f \n \r \t \u000B \\ \n e", lexer.getText());
		
		assertEquals(RTerminal.EOF, lexer.next());
	}
	
	@Test
	public void matchStringS_with_OctalEscapeSequence() {
		final RLexer lexer= new RLexer(RLexer.SKIP_WHITESPACE);
		lexer.reset(this.input.reset(" 'abc \\1 \\02 \\003 \\777 \\7777 e' ").init());
		
		assertEquals(RTerminal.STRING_S, lexer.next());
		assertEquals(0, lexer.getFlags());
		assertEquals("abc \u0001 \u0002 \u0003 \u01FF \u01FF7 e", lexer.getText());
		
		assertEquals(RTerminal.EOF, lexer.next());
	}
	
	@Test
	public void matchStringS_with_xHexEscapeSequence() {
		final RLexer lexer= new RLexer(RLexer.SKIP_WHITESPACE);
		lexer.reset(this.input.reset(" 'abc \\x1 \\x02 \\xAA \\xff \\x0ff e' ").init());
		
		assertEquals(RTerminal.STRING_S, lexer.next());
		assertEquals(0, lexer.getFlags());
		assertEquals("abc \u0001 \u0002 \u00AA \u00FF \u000Ff e", lexer.getText());
		
		assertEquals(RTerminal.EOF, lexer.next());
	}
	
	@Test
	public void matchStringS_with_xHexEscapeSequence_missingDigit() {
		final RLexer lexer= new RLexer(RLexer.SKIP_WHITESPACE);
		lexer.reset(this.input.reset(" 'abc \\x e' ").init());
		
		assertEquals(RTerminal.STRING_S, lexer.next());
		assertEquals(STATUS123_SYNTAX_TEXT_ESCAPE_SEQ_HEX_DIGIT_MISSING, lexer.getFlags());
		assertEquals("abc \\x e", lexer.getText());
		assertDetail(6, 2, "\\x", lexer.getStatusDetail());
		
		assertEquals(RTerminal.EOF, lexer.next());
	}
	
	@Test
	public void matchStringS_with_uHexEscapeSequence() {
		final RLexer lexer= new RLexer(RLexer.SKIP_WHITESPACE);
		lexer.reset(this.input.reset(" 'abc \\u1 \\u02 \\u003 \\uAAAA \\ufffa \\u0fffa e' ").init());
		
		assertEquals(RTerminal.STRING_S, lexer.next());
		assertEquals(0, lexer.getFlags());
		assertEquals("abc \u0001 \u0002 \u0003 \uAAAA \uFFFa \u0FFFa e", lexer.getText());
		
		assertEquals(RTerminal.EOF, lexer.next());
	}
	
	@Test
	public void matchStringS_with_uHexEscapeSequence_missingDigit() {
		final RLexer lexer= new RLexer(RLexer.SKIP_WHITESPACE);
		lexer.reset(this.input.reset(" 'abc \\u e' ").init());
		
		assertEquals(RTerminal.STRING_S, lexer.next());
		assertEquals(STATUS123_SYNTAX_TEXT_ESCAPE_SEQ_HEX_DIGIT_MISSING, lexer.getFlags());
		assertEquals("abc \\u e", lexer.getText());
		assertDetail(6, 2, "\\uxxxx", lexer.getStatusDetail());
		
		assertEquals(RTerminal.EOF, lexer.next());
	}
	
	@Test
	public void matchStringS_with_uHexBracketEscapeSequence() {
		final RLexer lexer= new RLexer(RLexer.SKIP_WHITESPACE);
		lexer.reset(this.input.reset(" 'abc \\u{1} \\u{02} \\u{003} \\u{AAAA} \\u{FFF0} e' ").init());
		
		assertEquals(RTerminal.STRING_S, lexer.next());
		assertEquals(0, lexer.getFlags());
		assertEquals("abc \u0001 \u0002 \u0003 \uAAAA \uFFF0 e", lexer.getText());
		
		assertEquals(RTerminal.EOF, lexer.next());
	}
	
	@Test
	public void matchStringS_with_uHexBracketEscapeSequence_missingDigit() {
		final RLexer lexer= new RLexer(RLexer.SKIP_WHITESPACE);
		lexer.reset(this.input.reset(" 'abc \\u{} e' ").init());
		
		assertEquals(RTerminal.STRING_S, lexer.next());
		assertEquals(STATUS123_SYNTAX_TEXT_ESCAPE_SEQ_HEX_DIGIT_MISSING, lexer.getFlags());
		assertEquals("abc \\u{} e", lexer.getText());
		assertDetail(6, 4, "\\u{xxxx}", lexer.getStatusDetail());
		
		assertEquals(RTerminal.EOF, lexer.next());
	}
	
	@Test
	public void matchStringS_with_uHexBracketEscapeSequence_notClosed() {
		final RLexer lexer= new RLexer(RLexer.SKIP_WHITESPACE);
		lexer.reset(this.input.reset(" 'abc \\u{1 e' ").init());
		
		assertEquals(RTerminal.STRING_S, lexer.next());
		assertEquals(STATUS123_SYNTAX_TEXT_ESCAPE_SEQ_NOT_CLOSED, lexer.getFlags());
		assertEquals("abc \\u{1 e", lexer.getText());
		assertDetail(6, 4, "\\u{xxxx}", lexer.getStatusDetail());
		
		lexer.reset(this.input.reset(" 'abc \\u{FFFFF} e' ").init());
		
		assertEquals(RTerminal.STRING_S, lexer.next());
		assertEquals(STATUS123_SYNTAX_TEXT_ESCAPE_SEQ_NOT_CLOSED, lexer.getFlags());
		assertEquals("abc \\u{FFFFF} e", lexer.getText());
		assertDetail(6, 7, "\\u{xxxx}", lexer.getStatusDetail());
		
		assertEquals(RTerminal.EOF, lexer.next());
	}
	
	@Test
	public void matchStringS_with_UHexEscapeSequence() {
		final RLexer lexer= new RLexer(RLexer.SKIP_WHITESPACE);
		lexer.reset(this.input.reset(" 'abc \\U1 \\U02 \\U003 \\UAAAA \\UFFF0 \\U1D11E \\U24F5C \\U00000aaaa e' ").init());
		
		assertEquals(RTerminal.STRING_S, lexer.next());
		assertEquals(0, lexer.getFlags());
		assertEquals("abc \u0001 \u0002 \u0003 \uAAAA \uFFF0 \uD834\uDD1E \uD853\uDF5C \u0AAAa e", lexer.getText());
		
		assertEquals(RTerminal.EOF, lexer.next());
	}
	
	@Test
	public void matchStringS_with_UHexEscapeSequence_missingDigit() {
		final RLexer lexer= new RLexer(RLexer.SKIP_WHITESPACE);
		lexer.reset(this.input.reset(" 'abc \\U e' ").init());
		
		assertEquals(RTerminal.STRING_S, lexer.next());
		assertEquals(STATUS123_SYNTAX_TEXT_ESCAPE_SEQ_HEX_DIGIT_MISSING, lexer.getFlags());
		assertEquals("abc \\U e", lexer.getText());
		assertDetail(6, 2, "\\Uxxxxxxxx", lexer.getStatusDetail());
		
		assertEquals(RTerminal.EOF, lexer.next());
	}
	
	@Test
	public void matchStringS_with_UHexBracketEscapeSequence() {
		final RLexer lexer= new RLexer(RLexer.SKIP_WHITESPACE);
		lexer.reset(this.input.reset(" 'abc \\U{1} \\U{02} \\U{003} \\U{AAAA} \\U{FFF0} \\U{1D11E} \\U{24F5C} e' ").init());
		
		assertEquals(RTerminal.STRING_S, lexer.next());
		assertEquals(0, lexer.getFlags());
		assertEquals("abc \u0001 \u0002 \u0003 \uAAAA \uFFF0 \uD834\uDD1E \uD853\uDF5C e", lexer.getText());
		
		assertEquals(RTerminal.EOF, lexer.next());
	}
	
	@Test
	public void matchStringS_with_UHexBracketEscapeSequence_missingDigit() {
		final RLexer lexer= new RLexer(RLexer.SKIP_WHITESPACE);
		lexer.reset(this.input.reset(" 'abc \\U{} e' ").init());
		
		assertEquals(RTerminal.STRING_S, lexer.next());
		assertEquals(STATUS123_SYNTAX_TEXT_ESCAPE_SEQ_HEX_DIGIT_MISSING, lexer.getFlags());
		assertEquals("abc \\U{} e", lexer.getText());
		assertDetail(6, 4, "\\U{xxxxxxxx}", lexer.getStatusDetail());
		
		assertEquals(RTerminal.EOF, lexer.next());
	}
	
	@Test
	public void matchStringS_with_UHexBracketEscapeSequence_notClosed() {
		final RLexer lexer= new RLexer(RLexer.SKIP_WHITESPACE);
		lexer.reset(this.input.reset(" 'abc \\U{1 e' ").init());
		
		assertEquals(RTerminal.STRING_S, lexer.next());
		assertEquals(STATUS123_SYNTAX_TEXT_ESCAPE_SEQ_NOT_CLOSED, lexer.getFlags());
		assertEquals("abc \\U{1 e", lexer.getText());
		assertDetail(6, 4, "\\U{xxxxxxxx}", lexer.getStatusDetail());
		
		lexer.reset(this.input.reset(" 'abc \\U{FFFFFFFFF} e' ").init());
		
		assertEquals(RTerminal.STRING_S, lexer.next());
		assertEquals(STATUS123_SYNTAX_TEXT_ESCAPE_SEQ_NOT_CLOSED, lexer.getFlags());
		assertEquals("abc \\U{FFFFFFFFF} e", lexer.getText());
		assertDetail(6, 11, "\\U{xxxxxxxx}", lexer.getStatusDetail());
		
		assertEquals(RTerminal.EOF, lexer.next());
	}
	
	@Test
	public void matchStringS_with_NullChar() {
		final RLexer lexer= new RLexer(RLexer.SKIP_WHITESPACE);
		lexer.reset(this.input.reset(" 'abc \u0000 e' ").init());
		
		assertEquals(RTerminal.STRING_S, lexer.next());
		assertEquals(STATUS123_SYNTAX_TEXT_NULLCHAR, lexer.getFlags());
		assertEquals("abc \u0000 e", lexer.getText());
		assertDetail(6, 1, null, lexer.getStatusDetail());
		
		lexer.reset(this.input.reset(" 'abc \\0 e' ").init());
		
		assertEquals(RTerminal.STRING_S, lexer.next());
		assertEquals(STATUS123_SYNTAX_TEXT_NULLCHAR, lexer.getFlags());
		assertEquals("abc \\0 e", lexer.getText());
		assertDetail(6, 2, null, lexer.getStatusDetail());
		
		lexer.reset(this.input.reset(" 'abc \\x00 e' ").init());
		
		assertEquals(RTerminal.STRING_S, lexer.next());
		assertEquals(STATUS123_SYNTAX_TEXT_NULLCHAR, lexer.getFlags());
		assertEquals("abc \\x00 e", lexer.getText());
		assertDetail(6, 4, null, lexer.getStatusDetail());
		
		lexer.reset(this.input.reset(" 'abc \\u0 e' ").init());
		
		assertEquals(RTerminal.STRING_S, lexer.next());
		assertEquals(STATUS123_SYNTAX_TEXT_NULLCHAR, lexer.getFlags());
		assertEquals("abc \\u0 e", lexer.getText());
		assertDetail(6, 3, null, lexer.getStatusDetail());
		
		lexer.reset(this.input.reset(" 'abc \\u{0} e' ").init());
		
		assertEquals(RTerminal.STRING_S, lexer.next());
		assertEquals(STATUS123_SYNTAX_TEXT_NULLCHAR, lexer.getFlags());
		assertEquals("abc \\u{0} e", lexer.getText());
		assertDetail(6, 5, null, lexer.getStatusDetail());
		
		lexer.reset(this.input.reset(" 'abc \\U0 e' ").init());
		
		assertEquals(RTerminal.STRING_S, lexer.next());
		assertEquals(STATUS123_SYNTAX_TEXT_NULLCHAR, lexer.getFlags());
		assertEquals("abc \\U0 e", lexer.getText());
		assertDetail(6, 3, null, lexer.getStatusDetail());
		
		lexer.reset(this.input.reset(" 'abc \\U{0000} e' ").init());
		
		assertEquals(RTerminal.STRING_S, lexer.next());
		assertEquals(STATUS123_SYNTAX_TEXT_NULLCHAR, lexer.getFlags());
		assertEquals("abc \\U{0000} e", lexer.getText());
		assertDetail(6, 8, null, lexer.getStatusDetail());
		
		assertEquals(RTerminal.EOF, lexer.next());
	}
	
	@Test
	public void matchStringS_with_Escape_unknown() {
		final RLexer lexer= new RLexer(RLexer.SKIP_WHITESPACE);
		lexer.reset(this.input.reset(" 'abc \\c' ").init());
		
		assertEquals(RTerminal.STRING_S, lexer.next());
		assertEquals(STATUS123_SYNTAX_TEXT_ESCAPE_SEQ_UNKOWN, lexer.getFlags());
		assertEquals("abc \\c", lexer.getText());
		assertDetail(6, 2, "\\c", lexer.getStatusDetail());
		
		assertEquals(RTerminal.EOF, lexer.next());
	}
	
	
	@Test
	public void matchStringD_with_SpecialCharEscape() {
		final RLexer lexer= new RLexer(RLexer.SKIP_WHITESPACE);
		lexer.reset(this.input.reset(" \"abc \\\' \\\" \\` \\a \\b \\f \\n \\r \\t \\v \\\\ \\\n e\" ").init());
		
		assertEquals(RTerminal.STRING_D, lexer.next());
		assertEquals(0, lexer.getFlags());
		assertEquals("abc \' \" ` \u0007 \u0008 \f \n \r \t \u000B \\ \n e", lexer.getText());
		
		assertEquals(RTerminal.EOF, lexer.next());
	}
	
	
	@Test
	public void matchSymbolG_with_SingleCharEscape() {
		final RLexer lexer= new RLexer(RLexer.SKIP_WHITESPACE);
		lexer.reset(this.input.reset(" `abc \\\' \\\" \\` \\a \\b \\f \\n \\r \\t \\v \\\\ \\\n e` ").init());
		
		assertEquals(RTerminal.SYMBOL_G, lexer.next());
		assertEquals(0, lexer.getFlags());
		assertEquals("abc \' \" ` \u0007 \u0008 \f \n \r \t \u000B \\ \n e", lexer.getText());
		
		assertEquals(RTerminal.EOF, lexer.next());
	}
	
	@Test
	public void matchSymbolG_with_OctalEscapeSequence() {
		final RLexer lexer= new RLexer(RLexer.SKIP_WHITESPACE);
		lexer.reset(this.input.reset(" `abc \\1 \\02 \\003 \\777 e` ").init());
		
		assertEquals(RTerminal.SYMBOL_G, lexer.next());
		assertEquals(0, lexer.getFlags());
		assertEquals("abc \u0001 \u0002 \u0003 \u01FF e", lexer.getText());
		
		assertEquals(RTerminal.EOF, lexer.next());
	}
	
	@Test
	public void matchSymbolG_with_xHexEscapeSequence() {
		final RLexer lexer= new RLexer(RLexer.SKIP_WHITESPACE);
		lexer.reset(this.input.reset(" `abc \\x1 \\x02 \\xAA \\xff e` ").init());
		
		assertEquals(RTerminal.SYMBOL_G, lexer.next());
		assertEquals(0, lexer.getFlags());
		assertEquals("abc \u0001 \u0002 \u00AA \u00FF e", lexer.getText());
		
		assertEquals(RTerminal.EOF, lexer.next());
	}
	
	@Test
	public void matchSymbolG_with_uHexEscapeSequence_unexpected() {
		final RLexer lexer= new RLexer(RLexer.SKIP_WHITESPACE);
		lexer.reset(this.input.reset(" `abc \\u1 \\u02 \\u003 \\uAAAA \\uFFF0 e` ").init());
		
		assertEquals(RTerminal.SYMBOL_G, lexer.next());
		assertEquals(STATUS123_SYNTAX_TEXT_ESCAPE_SEQ_UNEXPECTED, lexer.getFlags());
		assertEquals("abc \\u1 \\u02 \\u003 \\uAAAA \\uFFF0 e", lexer.getText());
		assertDetail(6, 3, "\\uxxxx", lexer.getStatusDetail());
		
		assertEquals(RTerminal.EOF, lexer.next());
	}
	
	@Test
	public void matchSymbolG_with_uHexBracketEscapeSequence_unexpected() {
		final RLexer lexer= new RLexer(RLexer.SKIP_WHITESPACE);
		lexer.reset(this.input.reset(" `abc \\u{1} \\u{02} \\u{003} \\u{AAAA} \\u{FFF0} e` ").init());
		
		assertEquals(RTerminal.SYMBOL_G, lexer.next());
		assertEquals(STATUS123_SYNTAX_TEXT_ESCAPE_SEQ_UNEXPECTED, lexer.getFlags());
		assertEquals("abc \\u{1} \\u{02} \\u{003} \\u{AAAA} \\u{FFF0} e", lexer.getText());
		assertDetail(6, 5, "\\u{xxxx}", lexer.getStatusDetail());
		
		assertEquals(RTerminal.EOF, lexer.next());
	}
	
	@Test
	public void matchSymbolG_with_uHexBracketEscapeSequence_notClosed() {
		final RLexer lexer= new RLexer(RLexer.SKIP_WHITESPACE);
		lexer.reset(this.input.reset(" `abc \\u{1 e` ").init());
		
		assertEquals(RTerminal.SYMBOL_G, lexer.next());
		assertEquals(STATUS123_SYNTAX_TEXT_ESCAPE_SEQ_UNEXPECTED, lexer.getFlags());
		assertEquals("abc \\u{1 e", lexer.getText());
		assertDetail(6, 4, "\\u{xxxx}", lexer.getStatusDetail());
		
		lexer.reset(this.input.reset(" `abc \\u{FFFFF} e` ").init());
		
		assertEquals(RTerminal.SYMBOL_G, lexer.next());
		assertEquals(STATUS123_SYNTAX_TEXT_ESCAPE_SEQ_UNEXPECTED, lexer.getFlags());
		assertEquals("abc \\u{FFFFF} e", lexer.getText());
		assertDetail(6, 7, "\\u{xxxx}", lexer.getStatusDetail());
		
		assertEquals(RTerminal.EOF, lexer.next());
	}
	
	@Test
	public void matchSymbolG_with_UHexEscapeSequence() {
		final RLexer lexer= new RLexer(RLexer.SKIP_WHITESPACE);
		lexer.reset(this.input.reset(" `abc \\U1 \\U02 \\U003 \\UAAAA \\UFFF0 \\U1D11E \\U24F5C e` ").init());
		
		assertEquals(RTerminal.SYMBOL_G, lexer.next());
		assertEquals(STATUS123_SYNTAX_TEXT_ESCAPE_SEQ_UNEXPECTED, lexer.getFlags());
		assertEquals("abc \\U1 \\U02 \\U003 \\UAAAA \\UFFF0 \\U1D11E \\U24F5C e", lexer.getText());
		assertDetail(6, 3, "\\Uxxxxxxxx", lexer.getStatusDetail());
		
		assertEquals(RTerminal.EOF, lexer.next());
	}
	
	@Test
	public void matchSymbolG_with_UHexBracketEscapeSequence() {
		final RLexer lexer= new RLexer(RLexer.SKIP_WHITESPACE);
		lexer.reset(this.input.reset(" `abc \\U{1} \\U{02} \\U{003} \\U{AAAA} \\U{FFF0} \\U{1D11E} \\U{24F5C} e` ").init());
		
		assertEquals(RTerminal.SYMBOL_G, lexer.next());
		assertEquals(STATUS123_SYNTAX_TEXT_ESCAPE_SEQ_UNEXPECTED, lexer.getFlags());
		assertEquals("abc \\U{1} \\U{02} \\U{003} \\U{AAAA} \\U{FFF0} \\U{1D11E} \\U{24F5C} e", lexer.getText());
		assertDetail(6, 5, "\\U{xxxxxxxx}", lexer.getStatusDetail());
		
		assertEquals(RTerminal.EOF, lexer.next());
	}
	
	@Test
	public void matchSymbolG_with_UHexBracketEscapeSequence_notClosed() {
		final RLexer lexer= new RLexer(RLexer.SKIP_WHITESPACE);
		lexer.reset(this.input.reset(" `abc \\U{1 e` ").init());
		
		assertEquals(RTerminal.SYMBOL_G, lexer.next());
		assertEquals(STATUS123_SYNTAX_TEXT_ESCAPE_SEQ_UNEXPECTED, lexer.getFlags());
		assertEquals("abc \\U{1 e", lexer.getText());
		assertDetail(6, 4, "\\U{xxxxxxxx}", lexer.getStatusDetail());
		
		lexer.reset(this.input.reset(" `abc \\U{FFFFFFFFF} e` ").init());
		
		assertEquals(RTerminal.SYMBOL_G, lexer.next());
		assertEquals(STATUS123_SYNTAX_TEXT_ESCAPE_SEQ_UNEXPECTED, lexer.getFlags());
		assertEquals("abc \\U{FFFFFFFFF} e", lexer.getText());
		assertDetail(6, 11, "\\U{xxxxxxxx}", lexer.getStatusDetail());
		
		assertEquals(RTerminal.EOF, lexer.next());
	}
	
	@Test
	public void matchSymbolG_with_NullChar() {
		final RLexer lexer= new RLexer(RLexer.SKIP_WHITESPACE);
		lexer.reset(this.input.reset(" `abc \u0000 e` ").init());
		
		assertEquals(RTerminal.SYMBOL_G, lexer.next());
		assertEquals(STATUS123_SYNTAX_TEXT_NULLCHAR, lexer.getFlags());
		assertEquals("abc \u0000 e", lexer.getText());
		assertDetail(6, 1, null, lexer.getStatusDetail());
		
		lexer.reset(this.input.reset(" `abc \\0 e` ").init());
		
		assertEquals(RTerminal.SYMBOL_G, lexer.next());
		assertEquals(STATUS123_SYNTAX_TEXT_NULLCHAR, lexer.getFlags());
		assertEquals("abc \\0 e", lexer.getText());
		assertDetail(6, 2, null, lexer.getStatusDetail());
		
		lexer.reset(this.input.reset(" `abc \\x00 e` ").init());
		
		assertEquals(RTerminal.SYMBOL_G, lexer.next());
		assertEquals(STATUS123_SYNTAX_TEXT_NULLCHAR, lexer.getFlags());
		assertEquals("abc \\x00 e", lexer.getText());
		assertDetail(6, 4, null, lexer.getStatusDetail());
		
		lexer.reset(this.input.reset(" `abc \\u0 e` ").init());
		
		assertEquals(RTerminal.SYMBOL_G, lexer.next());
		assertEquals(STATUS123_SYNTAX_TEXT_ESCAPE_SEQ_UNEXPECTED, lexer.getFlags());
		assertEquals("abc \\u0 e", lexer.getText());
		assertDetail(6, 3, "\\uxxxx", lexer.getStatusDetail());
		
		lexer.reset(this.input.reset(" `abc \\u{0} e` ").init());
		
		assertEquals(RTerminal.SYMBOL_G, lexer.next());
		assertEquals(STATUS123_SYNTAX_TEXT_ESCAPE_SEQ_UNEXPECTED, lexer.getFlags());
		assertEquals("abc \\u{0} e", lexer.getText());
		assertDetail(6, 5, "\\u{xxxx}", lexer.getStatusDetail());
		
		lexer.reset(this.input.reset(" `abc \\U0 e` ").init());
		
		assertEquals(RTerminal.SYMBOL_G, lexer.next());
		assertEquals(STATUS123_SYNTAX_TEXT_ESCAPE_SEQ_UNEXPECTED, lexer.getFlags());
		assertEquals("abc \\U0 e", lexer.getText());
		assertDetail(6, 3, "\\Uxxxxxxxx", lexer.getStatusDetail());
		
		lexer.reset(this.input.reset(" `abc \\U{0000} e` ").init());
		
		assertEquals(RTerminal.SYMBOL_G, lexer.next());
		assertEquals(STATUS123_SYNTAX_TEXT_ESCAPE_SEQ_UNEXPECTED, lexer.getFlags());
		assertEquals("abc \\U{0000} e", lexer.getText());
		assertDetail(6, 8, "\\U{xxxxxxxx}", lexer.getStatusDetail());
		
		assertEquals(RTerminal.EOF, lexer.next());
	}
	
	@Test
	public void matchSymbolG_with_Escape_unknown() {
		final RLexer lexer= new RLexer(RLexer.SKIP_WHITESPACE);
		lexer.reset(this.input.reset(" `abc \\c` ").init());
		
		assertEquals(RTerminal.SYMBOL_G, lexer.next());
		assertEquals(STATUS123_SYNTAX_TEXT_ESCAPE_SEQ_UNKOWN, lexer.getFlags());
		assertEquals("abc \\c", lexer.getText());
		assertDetail(6, 2, "\\c", lexer.getStatusDetail());
		
		assertEquals(RTerminal.EOF, lexer.next());
	}
	
	
}