analyses/org.eclipse.tracecompass.incubator.filters.core.tests/src/org/eclipse/tracecompass/incubator/filters/core/tests/server/ANTLRTest.java - tracecompass.incubator/org.eclipse.tracecompass.incubator - Git at Google

 /*******************************************************************************
  * Copyright (c) 2019 École Polytechnique de Montréal
  *
  * All rights reserved. This program and the accompanying materials are
  * made available under the terms of the Eclipse Public License 2.0 which
  * accompanies this distribution, and is available at
  * https://www.eclipse.org/legal/epl-2.0/
  *
  * SPDX-License-Identifier: EPL-2.0
  *******************************************************************************/

 package org.eclipse.tracecompass.incubator.filters.core.tests.server;

 import static org.junit.Assert.assertEquals;

 import java.io.IOException;
 import java.util.List;

 import org.antlr.runtime.RecognitionException;
 import org.eclipse.lsp4j.Color;
 import org.eclipse.lsp4j.ColorInformation;
 import org.eclipse.lsp4j.Diagnostic;
 import org.eclipse.lsp4j.Position;
 import org.eclipse.tracecompass.incubator.internal.filters.core.server.AutoCompletion;
 import org.eclipse.tracecompass.incubator.internal.filters.core.server.SyntaxHighlighting;
 import org.eclipse.tracecompass.incubator.internal.filters.core.server.FilterValidation;
 import org.junit.Test;

 /**
  * This class tests server-side class using antlr for syntax color, validation
  * and autocompletion
  *
  * @author Maxime Thibault
  * @author David-Alexandre Beaupre
  */
 public class ANTLRTest {

     /**
      * Checks if color information list returned by syntax highlighting module
      * has the right colors for the appropriate ranges
      */
     @Test
     public void syntaxColorTests() throws IOException {
         String text = "TID";
         String op = "==";
         String separator = "&&";
         String full = text + " " + op + " " + separator;
         List<ColorInformation> ci = SyntaxHighlighting.getColorInformationList(full);

         ColorInformation ci1 = ci.get(0);
         assertEquals(new Color(0, 0, 0, 1), ci1.getColor());
         assertEquals(0, ci1.getRange().getStart().getCharacter());
         assertEquals(2, ci1.getRange().getEnd().getCharacter());

         ColorInformation ci2 = ci.get(1);
         assertEquals(new Color(0.3, 0.3, 1, 1), ci2.getColor());
         assertEquals(4, ci2.getRange().getStart().getCharacter());
         assertEquals(5, ci2.getRange().getEnd().getCharacter());

         ColorInformation ci3 = ci.get(2);
         assertEquals(new Color(0.9, 0.5, 0.1, 1), ci3.getColor());
         assertEquals(7, ci3.getRange().getStart().getCharacter());
         assertEquals(8, ci3.getRange().getEnd().getCharacter());

     }

     /**
      * Checks the MismatchTokemException by making sure the parser finds this
      * error when the user enters an invalid operator. Also checks the range of
      * the error
      */
     @Test
     public void validationMismatchedTokenException() throws IOException, RecognitionException {

         List<Diagnostic> diagnostics = FilterValidation.validate("TID = 123");
         int lineStart = diagnostics.get(0).getRange().getStart().getLine();
         int offsetStart = diagnostics.get(0).getRange().getStart().getCharacter();
         int lineEnd = diagnostics.get(0).getRange().getEnd().getLine();
         int offsetEnd = diagnostics.get(0).getRange().getEnd().getCharacter();

         // We expect antlr to see mismatchedTokenException at range (4, 5)
         // because '=' must equals '==' instead
         int lineExpected = 0;
         int startOffsetExpected = 4;
         int endOffsetExpected = 5;
         assertEquals(lineExpected, lineStart);
         assertEquals(lineExpected, lineEnd);
         assertEquals(startOffsetExpected, offsetStart);
         assertEquals(endOffsetExpected, offsetEnd);

         // Detected by both lexer and parser. It is irrelevant, but client
         // should be able to display only one of them
         assertEquals(diagnostics.size(), 1);

     }

     /**
      * This is to verify that an incomplete filter entry, in this case lacking a
      * ending value, generates a error. Also checks the range of the error.
      */
     @Test
     public void validationNoViableAltException() throws IOException, RecognitionException {

         String str = "TID == ";

         List<Diagnostic> diagnostics = FilterValidation.validate(str);
         int lineStart = diagnostics.get(0).getRange().getStart().getLine();
         int offsetStart = diagnostics.get(0).getRange().getStart().getCharacter();
         int lineEnd = diagnostics.get(0).getRange().getEnd().getLine();
         int offsetEnd = diagnostics.get(0).getRange().getEnd().getCharacter();

         // We expect antlr to see NoViableAltException at position 6 because
         // there is no value after the ==
         int lineExpected = 0;
         int startOffsetExpected = 0;
         int endOffsetExpected = str.length();
         assertEquals(lineExpected, lineStart);
         assertEquals(lineExpected, lineEnd);
         assertEquals(startOffsetExpected, offsetStart);
         assertEquals(endOffsetExpected, offsetEnd);

         assertEquals(diagnostics.size(), 1);

     }

     /**
      * Ensures that a simple valid filter expression of the form TEXT OP TEXT
      * triggers no error.
      */
     @Test
     public void validationSimpleStringNoErrors() throws IOException, RecognitionException {
         String str = "PID == 42";
         List<Diagnostic> diagnostics = FilterValidation.validate(str);
         assertEquals(diagnostics.size(), 0);
     }

     /**
      * Also verifies that a valid filter expression triggers no error. This time
      * with a more complex entry.
      */
     @Test
     public void validationComplexStringNoErrors() throws IOException, RecognitionException {
         String str = "TID < 12 && (PID == 42 && (Ericsson > 1 || Poly matches 2))";
         List<Diagnostic> diagnostics = FilterValidation.validate(str);
         assertEquals(diagnostics.size(), 0);
     }

     /**
      * Verifies that an entry with unbalanced parentheses triggers an error.
      * Also checks the range of the error.
      */
     @Test
     public void validationMissingClosingParentheseOneChar() throws IOException, RecognitionException {
         String str = "(TID == 1";

         List<Diagnostic> diagnostics = FilterValidation.validate(str);
         int lineStart = diagnostics.get(0).getRange().getStart().getLine();
         int offsetStart = diagnostics.get(0).getRange().getStart().getCharacter();
         int lineEnd = diagnostics.get(0).getRange().getEnd().getLine();
         int offsetEnd = diagnostics.get(0).getRange().getEnd().getCharacter();

         // We expect antlr to see mismatchedTokenException at range (8, 9)
         // because there is no closing parenthese after last character
         int lineExpected = 0;
         int startOffsetExpected = 8;
         int endOffsetExpected = 9;
         assertEquals(lineExpected, lineStart);
         assertEquals(lineExpected, lineEnd);
         assertEquals(startOffsetExpected, offsetStart);
         assertEquals(endOffsetExpected, offsetEnd);

         assertEquals(diagnostics.size(), 1);

     }

     /**
      * Also checks for the error triggered when the parentheses are not
      * balanced. This time with a multiple-character value.
      */
     @Test
     public void validationMissingClosingParentheseMultipleChars() throws IOException, RecognitionException {
         String str = "(TID == 123456789";

         List<Diagnostic> diagnostics = FilterValidation.validate(str);
         int lineStart = diagnostics.get(0).getRange().getStart().getLine();
         int offsetStart = diagnostics.get(0).getRange().getStart().getCharacter();
         int lineEnd = diagnostics.get(0).getRange().getEnd().getLine();
         int offsetEnd = diagnostics.get(0).getRange().getEnd().getCharacter();

         // We expect antlr to see mismatchedTokenException at range (8, 17)
         // because there is no closing parenthese after last value
         int lineExpected = 0;
         int startOffsetExpected = 8;
         int endOffsetExpected = 17;
         assertEquals(lineExpected, lineStart);
         assertEquals(lineExpected, lineEnd);
         assertEquals(startOffsetExpected, offsetStart);
         assertEquals(endOffsetExpected, offsetEnd);

         assertEquals(diagnostics.size(), 1);

     }

     /**
      * Verifies that when the entry is TEXT, there is a list of suggestions of
      * size 9 with operators and separators proposed by the completion module.
      */
     @Test
     public void completionOperatorsSeparators() throws IOException, RecognitionException {
         String str = "TID";
         Position cursor = new Position(0, 3);

         List<String> suggestions = AutoCompletion.autoCompletion(str, cursor);
         int sizeExpected = 9;
         assertEquals(sizeExpected, suggestions.size());
     }

     /**
      * Verifies that after a closing parenthesis, the completion module proposes
      * only separators (size 2).
      */
     @Test
     public void completionSeparatorsAfterParentheses() throws IOException, RecognitionException {
         String str = "(TID == 42)";
         Position cursor = new Position(0, 11);

         List<String> suggestions = AutoCompletion.autoCompletion(str, cursor);
         int sizeExpected = 2;
         assertEquals(sizeExpected, suggestions.size());
     }

     /**
      * Verifies that operators and separators are suggested but with a more
      * complex entry.
      */
     @Test
     public void completionLongInputOperatorsSeparators() throws IOException, RecognitionException {
         String str = "(TID == 42 && PID != 12) || Poly";
         Position cursor = new Position(0, 32);

         List<String> suggestions = AutoCompletion.autoCompletion(str, cursor);
         int sizeExpected = 9;
         assertEquals(sizeExpected, suggestions.size());
     }

     /**
      * Verifies that operators and separators are suggested but with a more
      * complex entry. This time the cursor is not at the end of the entry but
      * after TID.
      */
     @Test
     public void completionLongInputOperatorsSeparatorsCursorMiddle() throws IOException, RecognitionException {
         String str = "(TID == 42 && PID != 12) || Poly";
         Position cursor = new Position(0, 5);

         List<String> suggestions = AutoCompletion.autoCompletion(str, cursor);
         int sizeExpected = 9;
         assertEquals(sizeExpected, suggestions.size());
     }

     /**
      * Verifies that no operators and separators are suggested because the
      * cursor is right after an operator (==).
      */
     @Test
     public void completionLongInputOperatorsSeparatorsCursorMiddleNoSuggestions() throws IOException, RecognitionException {
         String str = "(TID == 42 && PID != 12) || Poly";
         Position cursor = new Position(0, 7);

         List<String> suggestions = AutoCompletion.autoCompletion(str, cursor);
         int sizeExpected = 0;
         assertEquals(sizeExpected, suggestions.size());
     }

     /**
      * Verifies that only separators are suggested when the cursor is after a
      * complete simple expression (another operator would make no sens here).
      */
     @Test
     public void completionSeparatorsOnly() throws IOException, RecognitionException {
         String str = "TID == 42";
         Position cursor = new Position(0, 9);

         List<String> suggestions = AutoCompletion.autoCompletion(str, cursor);
         int sizeExpected = 2;
         assertEquals(sizeExpected, suggestions.size());
     }
 }
	/*******************************************************************************
	* Copyright (c) 2019 École Polytechnique de Montréal
	*
	* All rights reserved. This program and the accompanying materials are
	* made available under the terms of the Eclipse Public License 2.0 which
	* accompanies this distribution, and is available at
	* https://www.eclipse.org/legal/epl-2.0/
	*
	* SPDX-License-Identifier: EPL-2.0
	*******************************************************************************/

	package org.eclipse.tracecompass.incubator.filters.core.tests.server;

	import static org.junit.Assert.assertEquals;

	import java.io.IOException;
	import java.util.List;

	import org.antlr.runtime.RecognitionException;
	import org.eclipse.lsp4j.Color;
	import org.eclipse.lsp4j.ColorInformation;
	import org.eclipse.lsp4j.Diagnostic;
	import org.eclipse.lsp4j.Position;
	import org.eclipse.tracecompass.incubator.internal.filters.core.server.AutoCompletion;
	import org.eclipse.tracecompass.incubator.internal.filters.core.server.SyntaxHighlighting;
	import org.eclipse.tracecompass.incubator.internal.filters.core.server.FilterValidation;
	import org.junit.Test;

	/**
	* This class tests server-side class using antlr for syntax color, validation
	* and autocompletion
	*
	* @author Maxime Thibault
	* @author David-Alexandre Beaupre
	*/
	public class ANTLRTest {

	/**
	* Checks if color information list returned by syntax highlighting module
	* has the right colors for the appropriate ranges
	*/
	@Test
	public void syntaxColorTests() throws IOException {
	String text = "TID";
	String op = "==";
	String separator = "&&";
	String full = text + " " + op + " " + separator;
	List<ColorInformation> ci = SyntaxHighlighting.getColorInformationList(full);

	ColorInformation ci1 = ci.get(0);
	assertEquals(new Color(0, 0, 0, 1), ci1.getColor());
	assertEquals(0, ci1.getRange().getStart().getCharacter());
	assertEquals(2, ci1.getRange().getEnd().getCharacter());

	ColorInformation ci2 = ci.get(1);
	assertEquals(new Color(0.3, 0.3, 1, 1), ci2.getColor());
	assertEquals(4, ci2.getRange().getStart().getCharacter());
	assertEquals(5, ci2.getRange().getEnd().getCharacter());

	ColorInformation ci3 = ci.get(2);
	assertEquals(new Color(0.9, 0.5, 0.1, 1), ci3.getColor());
	assertEquals(7, ci3.getRange().getStart().getCharacter());
	assertEquals(8, ci3.getRange().getEnd().getCharacter());

	}

	/**
	* Checks the MismatchTokemException by making sure the parser finds this
	* error when the user enters an invalid operator. Also checks the range of
	* the error
	*/
	@Test
	public void validationMismatchedTokenException() throws IOException, RecognitionException {

	List<Diagnostic> diagnostics = FilterValidation.validate("TID = 123");
	int lineStart = diagnostics.get(0).getRange().getStart().getLine();
	int offsetStart = diagnostics.get(0).getRange().getStart().getCharacter();
	int lineEnd = diagnostics.get(0).getRange().getEnd().getLine();
	int offsetEnd = diagnostics.get(0).getRange().getEnd().getCharacter();

	// We expect antlr to see mismatchedTokenException at range (4, 5)
	// because '=' must equals '==' instead
	int lineExpected = 0;
	int startOffsetExpected = 4;
	int endOffsetExpected = 5;
	assertEquals(lineExpected, lineStart);
	assertEquals(lineExpected, lineEnd);
	assertEquals(startOffsetExpected, offsetStart);
	assertEquals(endOffsetExpected, offsetEnd);

	// Detected by both lexer and parser. It is irrelevant, but client
	// should be able to display only one of them
	assertEquals(diagnostics.size(), 1);

	}

	/**
	* This is to verify that an incomplete filter entry, in this case lacking a
	* ending value, generates a error. Also checks the range of the error.
	*/
	@Test
	public void validationNoViableAltException() throws IOException, RecognitionException {

	String str = "TID == ";

	List<Diagnostic> diagnostics = FilterValidation.validate(str);
	int lineStart = diagnostics.get(0).getRange().getStart().getLine();
	int offsetStart = diagnostics.get(0).getRange().getStart().getCharacter();
	int lineEnd = diagnostics.get(0).getRange().getEnd().getLine();
	int offsetEnd = diagnostics.get(0).getRange().getEnd().getCharacter();

	// We expect antlr to see NoViableAltException at position 6 because
	// there is no value after the ==
	int lineExpected = 0;
	int startOffsetExpected = 0;
	int endOffsetExpected = str.length();
	assertEquals(lineExpected, lineStart);
	assertEquals(lineExpected, lineEnd);
	assertEquals(startOffsetExpected, offsetStart);
	assertEquals(endOffsetExpected, offsetEnd);

	assertEquals(diagnostics.size(), 1);

	}

	/**
	* Ensures that a simple valid filter expression of the form TEXT OP TEXT
	* triggers no error.
	*/
	@Test
	public void validationSimpleStringNoErrors() throws IOException, RecognitionException {
	String str = "PID == 42";
	List<Diagnostic> diagnostics = FilterValidation.validate(str);
	assertEquals(diagnostics.size(), 0);
	}

	/**
	* Also verifies that a valid filter expression triggers no error. This time
	* with a more complex entry.
	*/
	@Test
	public void validationComplexStringNoErrors() throws IOException, RecognitionException {
	String str = "TID < 12 && (PID == 42 && (Ericsson > 1 \|\| Poly matches 2))";
	List<Diagnostic> diagnostics = FilterValidation.validate(str);
	assertEquals(diagnostics.size(), 0);
	}

	/**
	* Verifies that an entry with unbalanced parentheses triggers an error.
	* Also checks the range of the error.
	*/
	@Test
	public void validationMissingClosingParentheseOneChar() throws IOException, RecognitionException {
	String str = "(TID == 1";

	List<Diagnostic> diagnostics = FilterValidation.validate(str);
	int lineStart = diagnostics.get(0).getRange().getStart().getLine();
	int offsetStart = diagnostics.get(0).getRange().getStart().getCharacter();
	int lineEnd = diagnostics.get(0).getRange().getEnd().getLine();
	int offsetEnd = diagnostics.get(0).getRange().getEnd().getCharacter();

	// We expect antlr to see mismatchedTokenException at range (8, 9)
	// because there is no closing parenthese after last character
	int lineExpected = 0;
	int startOffsetExpected = 8;
	int endOffsetExpected = 9;
	assertEquals(lineExpected, lineStart);
	assertEquals(lineExpected, lineEnd);
	assertEquals(startOffsetExpected, offsetStart);
	assertEquals(endOffsetExpected, offsetEnd);

	assertEquals(diagnostics.size(), 1);

	}

	/**
	* Also checks for the error triggered when the parentheses are not
	* balanced. This time with a multiple-character value.
	*/
	@Test
	public void validationMissingClosingParentheseMultipleChars() throws IOException, RecognitionException {
	String str = "(TID == 123456789";

	List<Diagnostic> diagnostics = FilterValidation.validate(str);
	int lineStart = diagnostics.get(0).getRange().getStart().getLine();
	int offsetStart = diagnostics.get(0).getRange().getStart().getCharacter();
	int lineEnd = diagnostics.get(0).getRange().getEnd().getLine();
	int offsetEnd = diagnostics.get(0).getRange().getEnd().getCharacter();

	// We expect antlr to see mismatchedTokenException at range (8, 17)
	// because there is no closing parenthese after last value
	int lineExpected = 0;
	int startOffsetExpected = 8;
	int endOffsetExpected = 17;
	assertEquals(lineExpected, lineStart);
	assertEquals(lineExpected, lineEnd);
	assertEquals(startOffsetExpected, offsetStart);
	assertEquals(endOffsetExpected, offsetEnd);

	assertEquals(diagnostics.size(), 1);

	}

	/**
	* Verifies that when the entry is TEXT, there is a list of suggestions of
	* size 9 with operators and separators proposed by the completion module.
	*/
	@Test
	public void completionOperatorsSeparators() throws IOException, RecognitionException {
	String str = "TID";
	Position cursor = new Position(0, 3);

	List<String> suggestions = AutoCompletion.autoCompletion(str, cursor);
	int sizeExpected = 9;
	assertEquals(sizeExpected, suggestions.size());
	}

	/**
	* Verifies that after a closing parenthesis, the completion module proposes
	* only separators (size 2).
	*/
	@Test
	public void completionSeparatorsAfterParentheses() throws IOException, RecognitionException {
	String str = "(TID == 42)";
	Position cursor = new Position(0, 11);

	List<String> suggestions = AutoCompletion.autoCompletion(str, cursor);
	int sizeExpected = 2;
	assertEquals(sizeExpected, suggestions.size());
	}

	/**
	* Verifies that operators and separators are suggested but with a more
	* complex entry.
	*/
	@Test
	public void completionLongInputOperatorsSeparators() throws IOException, RecognitionException {
	String str = "(TID == 42 && PID != 12) \|\| Poly";
	Position cursor = new Position(0, 32);

	List<String> suggestions = AutoCompletion.autoCompletion(str, cursor);
	int sizeExpected = 9;
	assertEquals(sizeExpected, suggestions.size());
	}

	/**
	* Verifies that operators and separators are suggested but with a more
	* complex entry. This time the cursor is not at the end of the entry but
	* after TID.
	*/
	@Test
	public void completionLongInputOperatorsSeparatorsCursorMiddle() throws IOException, RecognitionException {
	String str = "(TID == 42 && PID != 12) \|\| Poly";
	Position cursor = new Position(0, 5);

	List<String> suggestions = AutoCompletion.autoCompletion(str, cursor);
	int sizeExpected = 9;
	assertEquals(sizeExpected, suggestions.size());
	}

	/**
	* Verifies that no operators and separators are suggested because the
	* cursor is right after an operator (==).
	*/
	@Test
	public void completionLongInputOperatorsSeparatorsCursorMiddleNoSuggestions() throws IOException, RecognitionException {
	String str = "(TID == 42 && PID != 12) \|\| Poly";
	Position cursor = new Position(0, 7);

	List<String> suggestions = AutoCompletion.autoCompletion(str, cursor);
	int sizeExpected = 0;
	assertEquals(sizeExpected, suggestions.size());
	}

	/**
	* Verifies that only separators are suggested when the cursor is after a
	* complete simple expression (another operator would make no sens here).
	*/
	@Test
	public void completionSeparatorsOnly() throws IOException, RecognitionException {
	String str = "TID == 42";
	Position cursor = new Position(0, 9);

	List<String> suggestions = AutoCompletion.autoCompletion(str, cursor);
	int sizeExpected = 2;
	assertEquals(sizeExpected, suggestions.size());
	}
	}