| /* |
| * Copyright (c) 2006, 2021 Oracle and/or its affiliates. All rights reserved. |
| * |
| * This program and the accompanying materials are made available under the |
| * terms of the Eclipse Public License v. 2.0 which is available at |
| * http://www.eclipse.org/legal/epl-2.0, |
| * or the Eclipse Distribution License v. 1.0 which is available at |
| * http://www.eclipse.org/org/documents/edl-v10.php. |
| * |
| * SPDX-License-Identifier: EPL-2.0 OR BSD-3-Clause |
| */ |
| |
| // Contributors: |
| // Oracle - initial API and implementation |
| // |
| package org.eclipse.persistence.jpa.tests.jpql; |
| |
| import java.util.List; |
| import org.eclipse.persistence.jpa.jpql.AbstractGrammarValidator; |
| import org.eclipse.persistence.jpa.jpql.ExpressionTools; |
| import org.eclipse.persistence.jpa.jpql.JPAVersion; |
| import org.eclipse.persistence.jpa.jpql.JPQLQueryProblem; |
| import org.eclipse.persistence.jpa.jpql.parser.AvgFunctionFactory; |
| import org.eclipse.persistence.jpa.jpql.parser.EclipseLinkJPQLGrammar2_1; |
| import org.eclipse.persistence.jpa.jpql.parser.EclipseLinkJPQLGrammar2_2; |
| import org.eclipse.persistence.jpa.jpql.parser.EclipseLinkJPQLGrammar2_3; |
| import org.eclipse.persistence.jpa.jpql.parser.EclipseLinkJPQLGrammar2_4; |
| import org.eclipse.persistence.jpa.jpql.parser.EclipseLinkJPQLGrammar2_5; |
| import org.eclipse.persistence.jpa.jpql.parser.Expression; |
| import org.eclipse.persistence.jpa.jpql.parser.InternalCountBNF; |
| import org.eclipse.persistence.jpa.jpql.parser.InternalOrderByItemBNF; |
| import org.eclipse.persistence.jpa.jpql.parser.JPQLQueryBNF; |
| import org.eclipse.persistence.jpa.jpql.parser.ScalarExpressionBNF; |
| import org.eclipse.persistence.jpa.jpql.parser.SubqueryBNF; |
| import org.eclipse.persistence.jpa.tests.jpql.parser.JPQLQueryStringFormatter; |
| import org.junit.Test; |
| import static org.eclipse.persistence.jpa.jpql.JPQLQueryProblemMessages.*; |
| |
| /** |
| * The unit-tests testing {@link AbstractGrammarValidator}. |
| * |
| * @version 2.5.2 |
| * @since 2.3 |
| * @author Pascal Filion |
| */ |
| @SuppressWarnings("nls") |
| public abstract class AbstractGrammarValidatorTest extends AbstractValidatorTest { |
| |
| private JPQLQueryStringFormatter buildFormatter_1() { |
| return new JPQLQueryStringFormatter() { |
| @Override |
| public String format(String jpqlQuery) { |
| return jpqlQuery.replace("SELECT)", "SELECT )"); |
| } |
| }; |
| } |
| |
| private JPQLQueryStringFormatter buildFormatter_10(final String jpqlQuery) { |
| return new JPQLQueryStringFormatter() { |
| @Override |
| public String format(String query) { |
| return jpqlQuery; |
| } |
| }; |
| } |
| |
| private JPQLQueryStringFormatter buildFormatter_2() { |
| return new JPQLQueryStringFormatter() { |
| @Override |
| public String format(String jpqlQuery) { |
| return jpqlQuery.replace("(DISTINCT)", "(DISTINCT )"); |
| } |
| }; |
| } |
| |
| private JPQLQueryStringFormatter buildFormatter_4() { |
| return new JPQLQueryStringFormatter() { |
| @Override |
| public String format(String jpqlQuery) { |
| return jpqlQuery.replace(",)", ", )"); |
| } |
| }; |
| } |
| |
| private JPQLQueryStringFormatter buildFormatter_5() { |
| return new JPQLQueryStringFormatter() { |
| @Override |
| public String format(String jpqlQuery) { |
| return jpqlQuery.replace(",)", ", )"); |
| } |
| }; |
| } |
| |
| private JPQLQueryStringFormatter buildFormatter_6() { |
| return new JPQLQueryStringFormatter() { |
| @Override |
| public String format(String jpqlQuery) { |
| return jpqlQuery.replace(",)", ", )"); |
| } |
| }; |
| } |
| |
| private JPQLQueryStringFormatter buildFormatter_7() { |
| return new JPQLQueryStringFormatter() { |
| @Override |
| public String format(String jpqlQuery) { |
| return jpqlQuery.replace("0,)", "0, )"); |
| } |
| }; |
| } |
| |
| private JPQLQueryStringFormatter buildFormatter_8() { |
| return new JPQLQueryStringFormatter() { |
| @Override |
| public String format(String jpqlQuery) { |
| return jpqlQuery.replace(",,", ", ,"); |
| } |
| }; |
| } |
| |
| private JPQLQueryStringFormatter buildFormatter_9() { |
| return new JPQLQueryStringFormatter() { |
| @Override |
| public String format(String query) { |
| return query.endsWith("NULLS ORDER") ? |
| query.replace("NULLS ORDER", "NULLS order") : |
| query.replace("nulls ORDER", "NULLS order"); |
| } |
| }; |
| } |
| |
| @Override |
| protected abstract AbstractGrammarValidator buildValidator(); |
| |
| @Override |
| protected AbstractGrammarValidator getValidator() { |
| return (AbstractGrammarValidator) super.getValidator(); |
| } |
| |
| protected abstract boolean isJoinFetchIdentifiable(); |
| |
| private boolean isScalarExpressionInOrderByClauseSupported() { |
| JPQLQueryBNF queryBNF = jpqlGrammar.getExpressionRegistry().getQueryBNF(InternalOrderByItemBNF.ID); |
| return queryBNF.hasChild(ScalarExpressionBNF.ID); |
| } |
| |
| protected abstract boolean isSubqueryAllowedAnywhere(); |
| |
| private boolean isSubqueryInOrderByClauseSupported() { |
| JPQLQueryBNF queryBNF = jpqlGrammar.getExpressionRegistry().getQueryBNF(InternalOrderByItemBNF.ID); |
| return queryBNF.hasChild(SubqueryBNF.ID); |
| } |
| |
| @Test |
| public final void test_AbsExpression_InvalidExpression() throws Exception { |
| |
| String jpqlQuery = "SELECT ABS(SELECT o FROM Order o) FROM Employee e"; |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| |
| if (isSubqueryAllowedAnywhere()) { |
| testDoesNotHaveProblem( |
| problems, |
| AbsExpression_InvalidExpression |
| ); |
| } |
| else { |
| int startPosition = "SELECT ABS(".length(); |
| int endPosition = "SELECT ABS(SELECT o FROM Order o".length(); |
| |
| testHasOnlyOneProblem( |
| problems, |
| AbsExpression_InvalidExpression, |
| startPosition, |
| endPosition |
| ); |
| } |
| } |
| |
| @Test |
| public final void test_AbsExpression_MissingExpression() throws Exception { |
| |
| String jpqlQuery = "SELECT ABS() FROM Employee e"; |
| int startPosition = "SELECT ABS(".length(); |
| int endPosition = startPosition; |
| |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| |
| testHasOnlyOneProblem( |
| problems, |
| AbsExpression_MissingExpression, |
| startPosition, |
| endPosition |
| ); |
| } |
| |
| @Test |
| public final void test_AbsExpression_MissingLeftParenthesis() throws Exception { |
| |
| String jpqlQuery = "SELECT ABS 4 + 5) FROM Employee e"; |
| int startPosition = "SELECT ABS".length(); |
| int endPosition = startPosition; |
| |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| |
| testHasOnlyOneProblem( |
| problems, |
| AbsExpression_MissingLeftParenthesis, |
| startPosition, |
| endPosition |
| ); |
| } |
| |
| @Test |
| public final void test_AbsExpression_MissingRightParenthesis() throws Exception { |
| |
| String jpqlQuery = "SELECT ABS(e.age + 100 FROM Employee e"; |
| int startPosition = "SELECT ABS(e.age + 100".length(); |
| int endPosition = startPosition; |
| |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| |
| testHasOnlyOneProblem( |
| problems, |
| AbsExpression_MissingRightParenthesis, |
| startPosition, |
| endPosition |
| ); |
| } |
| |
| @Test |
| public final void test_AbstractFromClause_IdentificationVariableDeclarationEndWithComma_1() throws Exception { |
| |
| String jpqlQuery = "SELECT e FROM Employee e JOIN e.managers m,"; |
| int startPosition = "SELECT e FROM Employee e JOIN e.managers m".length(); |
| int endPosition = startPosition + 1; |
| |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| |
| testHasOnlyOneProblem( |
| problems, |
| AbstractFromClause_IdentificationVariableDeclarationEndsWithComma, |
| startPosition, |
| endPosition |
| ); |
| } |
| |
| @Test |
| public final void test_AbstractFromClause_IdentificationVariableDeclarationEndWithComma_2() throws Exception { |
| |
| String jpqlQuery = "SELECT e FROM Employee e WHERE EXISTS(SELECT o FROM Order o,)"; |
| int startPosition = "SELECT e FROM Employee e WHERE EXISTS(SELECT o FROM Order o".length(); |
| int endPosition = startPosition + 1; |
| |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| |
| testHasOnlyOneProblem( |
| problems, |
| AbstractFromClause_IdentificationVariableDeclarationEndsWithComma, |
| startPosition, |
| endPosition |
| ); |
| } |
| |
| @Test |
| public final void test_AbstractFromClause_IdentificationVariableDeclarationIsMissingComma() throws Exception { |
| |
| String jpqlQuery = "SELECT e FROM Employee e Address a"; |
| int startPosition = "SELECT e FROM Employee e".length(); |
| int endPosition = startPosition + 1; |
| |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| |
| testHasOnlyOneProblem( |
| problems, |
| AbstractFromClause_IdentificationVariableDeclarationIsMissingComma, |
| startPosition, |
| endPosition |
| ); |
| } |
| |
| @Test |
| public final void test_AbstractFromClause_MissingIdentificationVariableDeclaration_1() throws Exception { |
| |
| String jpqlQuery = "SELECT e FROM"; |
| int startPosition = jpqlQuery.length(); |
| int endPosition = startPosition; |
| |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| |
| testHasOnlyOneProblem( |
| problems, |
| AbstractFromClause_MissingIdentificationVariableDeclaration, |
| startPosition, |
| endPosition |
| ); |
| } |
| |
| @Test |
| public final void test_AbstractFromClause_MissingIdentificationVariableDeclaration_2() throws Exception { |
| |
| String jpqlQuery = "SELECT e FROM "; |
| int startPosition = jpqlQuery.length(); |
| int endPosition = startPosition; |
| |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| |
| testHasOnlyOneProblem( |
| problems, |
| AbstractFromClause_MissingIdentificationVariableDeclaration, |
| startPosition, |
| endPosition |
| ); |
| } |
| |
| @Test |
| public final void test_AbstractFromClause_MissingIdentificationVariableDeclaration_3() throws Exception { |
| |
| String jpqlQuery = "SELECT e FROM WHERE e.name = 'JPQL'"; |
| int startPosition = "SELECT e FROM ".length(); |
| int endPosition = startPosition; |
| |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| |
| testHasOnlyOneProblem( |
| problems, |
| AbstractFromClause_MissingIdentificationVariableDeclaration, |
| startPosition, |
| endPosition |
| ); |
| } |
| |
| @Test |
| public final void test_AbstractFromClause_MissingIdentificationVariableDeclaration_4() throws Exception { |
| |
| String jpqlQuery = "SELECT e FROM Employee e, Order o WHERE EXISTS(SELECT o FROM)"; |
| int startPosition = "SELECT e FROM Employee e, Order o WHERE EXISTS(SELECT o FROM".length(); |
| int endPosition = startPosition; |
| |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| |
| testHasOnlyOneProblem( |
| problems, |
| AbstractFromClause_MissingIdentificationVariableDeclaration, |
| startPosition, |
| endPosition |
| ); |
| } |
| |
| @Test |
| public final void test_AbstractFromClause_MissingIdentificationVariableDeclaration_5() throws Exception { |
| |
| String jpqlQuery = "SELECT e FROM Employee e WHERE EXISTS(SELECT o FROM WHERE o.price > 2000)"; |
| int startPosition = "SELECT e FROM Employee e WHERE EXISTS(SELECT o FROM ".length(); |
| int endPosition = startPosition; |
| |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| |
| testHasOnlyOneProblem( |
| problems, |
| AbstractFromClause_MissingIdentificationVariableDeclaration, |
| startPosition, |
| endPosition |
| ); |
| } |
| |
| @Test |
| public final void test_AbstractPathExpression_CannotEndWithComma() throws Exception { |
| |
| String jpqlQuery = "SELECT e. FROM Employee e"; |
| int startPosition = "SELECT ".length(); |
| int endPosition = "SELECT e.".length(); |
| |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| |
| testHasOnlyOneProblem( |
| problems, |
| AbstractPathExpression_CannotEndWithComma, |
| startPosition, |
| endPosition |
| ); |
| } |
| |
| @Test |
| public final void test_AbstractPathExpression_InvalidIdentificationVariable_1() throws Exception { |
| |
| String jpqlQuery = "SELECT e.name FROM Employee e"; |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| testHasNoProblems(problems); |
| } |
| |
| @Test |
| public final void test_AbstractPathExpression_InvalidIdentificationVariable_2() throws Exception { |
| |
| String jpqlQuery = "SELECT KEY(e).name FROM Employee e"; |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| testHasNoProblems(problems); |
| } |
| |
| @Test |
| public final void test_AbstractPathExpression_MissingIdentificationVariable() throws Exception { |
| |
| String jpqlQuery = "SELECT .name FROM Employee e"; |
| int startPosition = "SELECT ".length(); |
| int endPosition = "SELECT .name".length(); |
| |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| |
| testHasOnlyOneProblem( |
| problems, |
| AbstractPathExpression_MissingIdentificationVariable, |
| startPosition, |
| endPosition |
| ); |
| } |
| |
| @Test |
| public final void test_AbstractSelectClause_InvalidSelectExpression_1() throws Exception { |
| |
| String jpqlQuery = "SELECT (SELECT e FROM Employee e) FROM Employee e"; |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| |
| if (isSubqueryAllowedAnywhere()) { |
| testDoesNotHaveProblem( |
| problems, |
| AbstractSelectClause_InvalidSelectExpression |
| ); |
| } |
| else { |
| int startPosition = "SELECT ".length(); |
| int endPosition = "SELECT (SELECT e FROM Employee e)".length(); |
| |
| testHasOnlyOneProblem( |
| problems, |
| AbstractSelectClause_InvalidSelectExpression, |
| startPosition, |
| endPosition |
| ); |
| } |
| } |
| |
| @Test |
| public final void test_AbstractSelectClause_InvalidSelectExpression_2() throws Exception { |
| |
| String jpqlQuery = "SELECT (SELECT e F) FROM Employee e"; |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| |
| if (isSubqueryAllowedAnywhere()) { |
| testDoesNotHaveProblem( |
| problems, |
| AbstractSelectClause_InvalidSelectExpression |
| ); |
| } |
| else { |
| int startPosition = "SELECT ".length(); |
| int endPosition = "SELECT (SELECT e F)".length(); |
| |
| testHasOnlyOneProblem( |
| problems, |
| AbstractSelectClause_InvalidSelectExpression, |
| startPosition, |
| endPosition |
| ); |
| } |
| } |
| |
| @Test |
| public final void test_AbstractSelectClause_MissingSelectExpression_1() throws Exception { |
| |
| String jpqlQuery = "SELECT"; |
| int startPosition = jpqlQuery.length(); |
| int endPosition = startPosition; |
| |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| |
| testHasProblem( |
| problems, |
| AbstractSelectClause_MissingSelectExpression, |
| startPosition, |
| endPosition |
| ); |
| } |
| |
| @Test |
| public final void test_AbstractSelectClause_MissingSelectExpression_2() throws Exception { |
| |
| String jpqlQuery = "SELECT "; |
| int startPosition = jpqlQuery.length(); |
| int endPosition = startPosition; |
| |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| |
| testHasProblem( |
| problems, |
| AbstractSelectClause_MissingSelectExpression, |
| startPosition, |
| endPosition |
| ); |
| } |
| |
| @Test |
| public final void test_AbstractSelectClause_MissingSelectExpression_3() throws Exception { |
| |
| String jpqlQuery = "SELECT FROM Employee e"; |
| int startPosition = "SELECT ".length(); |
| int endPosition = startPosition; |
| |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| |
| testHasOnlyOneProblem( |
| problems, |
| AbstractSelectClause_MissingSelectExpression, |
| startPosition, |
| endPosition |
| ); |
| } |
| |
| @Test |
| public final void test_AbstractSelectClause_MissingSelectExpression_4() throws Exception { |
| |
| String jpqlQuery = "SELECT e FROM Employee e WHERE EXISTS(SELECT )"; |
| int startPosition = "SELECT e FROM Employee e WHERE EXISTS(SELECT ".length(); |
| int endPosition = startPosition; |
| |
| List<JPQLQueryProblem> problems = validate(jpqlQuery, buildFormatter_1()); |
| |
| testHasProblem( |
| problems, |
| AbstractSelectClause_MissingSelectExpression, |
| startPosition, |
| endPosition |
| ); |
| } |
| |
| @Test |
| public final void test_AbstractSelectClause_MissingSelectExpression_5() throws Exception { |
| |
| String jpqlQuery = "SELECT e FROM Employee e WHERE EXISTS(SELECT FROM Order o)"; |
| int startPosition = "SELECT e FROM Employee e WHERE EXISTS(SELECT ".length(); |
| int endPosition = startPosition; |
| |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| |
| testHasOnlyOneProblem( |
| problems, |
| AbstractSelectClause_MissingSelectExpression, |
| startPosition, |
| endPosition |
| ); |
| } |
| |
| @Test |
| public final void test_AbstractSelectClause_SelectExpressionEndsWithComma_1() throws Exception { |
| |
| String jpqlQuery = "SELECT e, AVG(e.age), FROM Employee e"; |
| int startPosition = "SELECT e, AVG(e.age)".length(); |
| int endPosition = startPosition + 1; |
| |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| |
| testHasOnlyOneProblem( |
| problems, |
| AbstractSelectClause_SelectExpressionEndsWithComma, |
| startPosition, |
| endPosition |
| ); |
| } |
| |
| @Test |
| public final void test_AbstractSelectClause_SelectExpressionIsMissingComma_1() throws Exception { |
| |
| String jpqlQuery = "SELECT e AVG(e.age) FROM Employee e"; |
| int startPosition = "SELECT e".length(); |
| int endPosition = startPosition + 1; |
| |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| |
| testHasOnlyOneProblem( |
| problems, |
| AbstractSelectClause_SelectExpressionIsMissingComma, |
| startPosition, |
| endPosition |
| ); |
| } |
| |
| @Test |
| public final void test_AbstractSelectClause_SelectExpressionIsMissingComma_2() throws Exception { |
| |
| String jpqlQuery = "SELECT e, AVG(e.age) e.name FROM Employee e"; |
| int startPosition = "SELECT e, AVG(e.age)".length(); |
| int endPosition = startPosition + 1; |
| |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| |
| testHasOnlyOneProblem( |
| problems, |
| AbstractSelectClause_SelectExpressionIsMissingComma, |
| startPosition, |
| endPosition |
| ); |
| } |
| |
| @Test |
| public final void test_AbstractSelectStatement_FromClauseMissing_1() throws Exception { |
| |
| String jpqlQuery = "SELECT e"; |
| int startPosition = jpqlQuery.length(); |
| int endPosition = startPosition; |
| |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| |
| testHasOnlyOneProblem( |
| problems, |
| AbstractSelectStatement_FromClauseMissing, |
| startPosition, |
| endPosition |
| ); |
| } |
| |
| @Test |
| public final void test_AbstractSelectStatement_FromClauseMissing_2() throws Exception { |
| |
| String jpqlQuery = "SELECT e WHERE e.name = 'JPQL'"; |
| int startPosition = "SELECT e ".length(); |
| int endPosition = startPosition; |
| |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| |
| testHasOnlyOneProblem( |
| problems, |
| AbstractSelectStatement_FromClauseMissing, |
| startPosition, |
| endPosition |
| ); |
| } |
| |
| @Test |
| public final void test_AbstractSelectStatement_FromClauseMissing_3() throws Exception { |
| |
| String jpqlQuery = "SELECT e FROM Employee e WHERE ALL(SELECT E WHERE e.name = 'JPQL') < e"; |
| int startPosition = "SELECT e FROM Employee e WHERE ALL(SELECT E ".length(); |
| int endPosition = startPosition; |
| |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| |
| testHasOnlyOneProblem( |
| problems, |
| AbstractSelectStatement_FromClauseMissing, |
| startPosition, |
| endPosition |
| ); |
| } |
| |
| @Test |
| public final void test_AggregateFunction_WrongClause_1() throws Exception { |
| |
| String jpqlQuery = "SELECT AVG(e.age) FROM Employee e"; |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| testHasNoProblems(problems); |
| } |
| |
| @Test |
| public final void test_AggregateFunction_WrongClause_2() throws Exception { |
| |
| String jpqlQuery = "SELECT e FROM Employee e HAVING AVG(e.age) > 2"; |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| testHasNoProblems(problems); |
| } |
| |
| @Test |
| public final void test_AggregateFunction_WrongClause_3() throws Exception { |
| |
| String jpqlQuery = "SELECT e FROM Employee e WHERE AVG(e.age) > 2"; |
| int startPosition = "SELECT e FROM Employee e WHERE ".length(); |
| int endPosition = "SELECT e FROM Employee e WHERE AVG(e.age)".length(); |
| |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| testHasOnlyOneProblem(problems, AggregateFunction_WrongClause, startPosition, endPosition); |
| } |
| |
| @Test |
| public final void test_AggregateFunction_WrongClause_4() throws Exception { |
| |
| String jpqlQuery = "SELECT e FROM Employee e WHERE AVG() > 2"; |
| int startPosition = "SELECT e FROM Employee e WHERE ".length(); |
| int endPosition = "SELECT e FROM Employee e WHERE AVG()".length(); |
| |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| testHasOnlyOneProblem(problems, AggregateFunction_WrongClause, startPosition, endPosition); |
| } |
| |
| @Test |
| public final void test_AllOrAnyExpression_InvalidExpression() throws Exception { |
| |
| String jpqlQuery = "SELECT e FROM Employee e WHERE SOME(AVG(e.name)) = TRUE"; |
| int startPosition = "SELECT e FROM Employee e WHERE SOME(".length(); |
| int endPosition = "SELECT e FROM Employee e WHERE SOME(AVG(e.name)".length(); |
| |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| |
| testHasOnlyOneProblem( |
| problems, |
| AllOrAnyExpression_InvalidExpression, |
| startPosition, |
| endPosition |
| ); |
| } |
| |
| @Test |
| public final void test_AllOrAnyExpression_MissingExpression() throws Exception { |
| |
| String jpqlQuery = "SELECT e FROM Employee e JOIN e.addresses a WHERE ALL() = TRUE"; |
| int startPosition = "SELECT e FROM Employee e JOIN e.addresses a WHERE ALL(".length(); |
| int endPosition = startPosition; |
| |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| |
| testHasOnlyOneProblem( |
| problems, |
| AllOrAnyExpression_MissingExpression, |
| startPosition, |
| endPosition |
| ); |
| } |
| |
| @Test |
| public final void test_AllOrAnyExpression_MissingLeftParenthesis() throws Exception { |
| |
| String jpqlQuery = "SELECT e FROM Employee e JOIN e.addresses a WHERE SOME SELECT p FROM Order p) = TRUE"; |
| int startPosition = "SELECT e FROM Employee e JOIN e.addresses a WHERE SOME".length(); |
| int endPosition = startPosition; |
| |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| |
| testHasOnlyOneProblem( |
| problems, |
| AllOrAnyExpression_MissingLeftParenthesis, |
| startPosition, |
| endPosition |
| ); |
| } |
| |
| @Test |
| public final void test_AllOrAnyExpression_MissingRightParenthesis() throws Exception { |
| |
| String jpqlQuery = "SELECT e FROM Employee e JOIN e.addresses a WHERE SOME(SELECT p FROM Order p = TRUE"; |
| int startPosition = "SELECT e FROM Employee e JOIN e.addresses a WHERE SOME(SELECT p FROM Order p".length(); |
| int endPosition = startPosition; |
| |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| |
| testHasOnlyOneProblem( |
| problems, |
| AllOrAnyExpression_MissingRightParenthesis, |
| startPosition, |
| endPosition |
| ); |
| } |
| |
| @Test |
| public final void test_AllOrAnyExpression_NotPartOfComparisonExpression() throws Exception { |
| |
| String jpqlQuery = "SELECT e FROM Employee e WHERE ALL(SELECT a FROM Address a)"; |
| int startPosition = "SELECT e FROM Employee e WHERE ".length(); |
| int endPosition = jpqlQuery.length(); |
| |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| |
| testHasProblem( |
| problems, |
| AllOrAnyExpression_NotPartOfComparisonExpression, |
| startPosition, |
| endPosition |
| ); |
| } |
| |
| @Test |
| public final void test_ArithmeticExpression_InvalidLeftExpression() throws Exception { |
| |
| String jpqlQuery = "SELECT e FROM Employee e WHERE FROM Employee e + LENGTH(e.name) < 2"; |
| int startPosition = "SELECT e FROM Employee e WHERE ".length(); |
| int endPosition = "SELECT e FROM Employee e WHERE FROM Employee e".length(); |
| |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| |
| testHasProblem( |
| problems, |
| ArithmeticExpression_InvalidLeftExpression, |
| startPosition, |
| endPosition |
| ); |
| } |
| |
| @Test |
| public final void test_ArithmeticExpression_InvalidRightExpression() throws Exception { |
| |
| String jpqlQuery = "SELECT e FROM Employee e WHERE LENGTH(e.name) + FROM Employee e < 2"; |
| int startPosition = "SELECT e FROM Employee e WHERE LENGTH(e.name) + ".length(); |
| int endPosition = "SELECT e FROM Employee e WHERE LENGTH(e.name) + FROM Employee e".length(); |
| |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| |
| testHasProblem( |
| problems, |
| ArithmeticExpression_InvalidRightExpression, |
| startPosition, |
| endPosition |
| ); |
| } |
| |
| @Test |
| public final void test_ArithmeticExpression_MissingLeftExpression() throws Exception { |
| |
| String jpqlQuery = "SELECT e FROM Employee e WHERE + +LENGTH(e.name) < 2"; |
| int startPosition = "SELECT e FROM Employee e WHERE ".length(); |
| int endPosition = startPosition; |
| |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| |
| testHasOnlyOneProblem( |
| problems, |
| ArithmeticExpression_MissingLeftExpression, |
| startPosition, |
| endPosition |
| ); |
| } |
| |
| @Test |
| public final void test_ArithmeticExpression_MissingRightExpression_1() throws Exception { |
| |
| String jpqlQuery = "SELECT e FROM Employee e WHERE LENGTH(e.name) +"; |
| int startPosition = jpqlQuery.length(); |
| int endPosition = startPosition; |
| |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| |
| testHasProblem( |
| problems, |
| ArithmeticExpression_MissingRightExpression, |
| startPosition, |
| endPosition |
| ); |
| } |
| |
| @Test |
| public final void test_ArithmeticFactor_MissingExpression_1() throws Exception { |
| |
| String jpqlQuery = "SELECT e FROM Employee e WHERE -"; |
| int startPosition = "SELECT e FROM Employee e WHERE -".length(); |
| int endPosition = startPosition; |
| |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| |
| testHasProblem( |
| problems, |
| ArithmeticFactor_MissingExpression, |
| startPosition, |
| endPosition |
| ); |
| } |
| |
| @Test |
| public final void test_ArithmeticFactor_MissingExpression_2() throws Exception { |
| |
| String jpqlQuery = "SELECT e FROM Employee e WHERE e.age + -"; |
| int startPosition = "SELECT e FROM Employee e WHERE e.age + -".length(); |
| int endPosition = startPosition; |
| |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| |
| testHasProblem( |
| problems, |
| ArithmeticFactor_MissingExpression, |
| startPosition, |
| endPosition |
| ); |
| } |
| |
| @Test |
| public final void test_AvgFunction_InvalidExpression() throws Exception { |
| |
| String jpqlQuery = "SELECT AVG(e) FROM Employee e"; |
| int startPosition = "SELECT AVG(".length(); |
| int endPosition = "SELECT AVG(e".length(); |
| |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| |
| testHasOnlyOneProblem( |
| problems, |
| AvgFunction_InvalidExpression, |
| startPosition, |
| endPosition |
| ); |
| } |
| |
| @Test |
| public final void test_AvgFunction_MissingExpression_1() throws Exception { |
| |
| String jpqlQuery = "SELECT AVG() FROM Employee e"; |
| int startPosition = "SELECT AVG(".length(); |
| int endPosition = startPosition; |
| |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| |
| testHasOnlyOneProblem( |
| problems, |
| AvgFunction_MissingExpression, |
| startPosition, |
| endPosition |
| ); |
| } |
| |
| @Test |
| public final void test_AvgFunction_MissingExpression_2() throws Exception { |
| |
| String jpqlQuery = "SELECT AVG(DISTINCT) FROM Employee e"; |
| int startPosition = "SELECT AVG(DISTINCT".length(); |
| int endPosition = startPosition; |
| |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| |
| testHasOnlyOneProblem( |
| problems, |
| AvgFunction_MissingExpression, |
| startPosition, |
| endPosition |
| ); |
| } |
| |
| @Test |
| public final void test_AvgFunction_MissingExpression_3() throws Exception { |
| |
| String jpqlQuery = "SELECT AVG(DISTINCT ) FROM Employee e"; |
| int startPosition = "SELECT AVG(DISTINCT ".length(); |
| int endPosition = startPosition; |
| |
| List<JPQLQueryProblem> problems = validate(jpqlQuery, buildFormatter_2()); |
| |
| testHasOnlyOneProblem( |
| problems, |
| AvgFunction_MissingExpression, |
| startPosition, |
| endPosition |
| ); |
| } |
| |
| @Test |
| public final void test_AvgFunction_MissingLeftParenthesis_1() throws Exception { |
| |
| String jpqlQuery = "SELECT AVG e.age) FROM Employee e"; |
| int startPosition = "SELECT AVG".length(); |
| int endPosition = startPosition; |
| |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| |
| testHasOnlyOneProblem( |
| problems, |
| AvgFunction_MissingLeftParenthesis, |
| startPosition, |
| endPosition |
| ); |
| } |
| |
| @Test |
| public final void test_AvgFunction_MissingLeftParenthesis_2() throws Exception { |
| |
| String jpqlQuery = "SELECT AVG DISTINCT e.age) FROM Employee e"; |
| int startPosition = "SELECT AVG".length(); |
| int endPosition = startPosition; |
| |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| |
| testHasOnlyOneProblem( |
| problems, |
| AvgFunction_MissingLeftParenthesis, |
| startPosition, |
| endPosition |
| ); |
| } |
| |
| @Test |
| public final void test_AvgFunction_MissingRightParenthesis() throws Exception { |
| |
| String jpqlQuery = "SELECT AVG(DISTINCT e.age FROM Employee e"; |
| int startPosition = "SELECT AVG(DISTINCT e.age".length(); |
| int endPosition = startPosition; |
| |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| |
| testHasOnlyOneProblem( |
| problems, |
| AvgFunction_MissingRightParenthesis, |
| startPosition, |
| endPosition |
| ); |
| } |
| |
| @Test |
| public final void test_BadExpression_InvalidExpression_2() throws Exception { |
| |
| String jpqlQuery = "SELECT (SELECT e FROM Employee e), AVG(e.age) FROM Employee e"; |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| |
| if (isSubqueryAllowedAnywhere()) { |
| testDoesNotHaveProblem( |
| problems, |
| BadExpression_InvalidExpression |
| ); |
| } |
| else { |
| int startPosition = "SELECT (".length(); |
| int endPosition = "SELECT (SELECT e FROM Employee e".length(); |
| |
| testHasOnlyOneProblem( |
| problems, |
| BadExpression_InvalidExpression, |
| startPosition, |
| endPosition |
| ); |
| } |
| } |
| |
| @Test |
| public final void test_BadExpression_InvalidExpression_3() throws Exception { |
| |
| String jpqlQuery = "SELECT AVG(e.age), (SELECT e FROM Employee e) FROM Employee e"; |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| |
| if (isSubqueryAllowedAnywhere()) { |
| testDoesNotHaveProblem( |
| problems, |
| BadExpression_InvalidExpression |
| ); |
| } |
| else { |
| int startPosition = "SELECT AVG(e.age), (".length(); |
| int endPosition = "SELECT AVG(e.age), (SELECT e FROM Employee e".length(); |
| |
| testHasOnlyOneProblem( |
| problems, |
| BadExpression_InvalidExpression, |
| startPosition, |
| endPosition |
| ); |
| } |
| } |
| |
| @Test |
| public final void test_BetweenExpression_MissingAnd_1() throws Exception { |
| |
| String jpqlQuery = "SELECT e FROM Employee e WHERE e.age BETWEEN 20"; |
| int startPosition = jpqlQuery.length(); |
| int endPosition = startPosition; |
| |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| |
| testHasOnlyOneProblem( |
| problems, |
| BetweenExpression_MissingAnd, |
| startPosition, |
| endPosition |
| ); |
| } |
| |
| @Test |
| public final void test_BetweenExpression_MissingAnd_2() throws Exception { |
| |
| String jpqlQuery = "SELECT e FROM Employee e WHERE e.age BETWEEN 20 "; |
| int startPosition = jpqlQuery.length(); |
| int endPosition = startPosition; |
| |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| |
| testHasOnlyOneProblem( |
| problems, |
| BetweenExpression_MissingAnd, |
| startPosition, |
| endPosition |
| ); |
| } |
| |
| @Test |
| public final void test_BetweenExpression_MissingAnd_3() throws Exception { |
| |
| String jpqlQuery = "SELECT e FROM Employee e WHERE e.age BETWEEN 20 40"; |
| int startPosition = "SELECT e FROM Employee e WHERE e.age BETWEEN 20 ".length(); |
| int endPosition = startPosition; |
| |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| |
| testHasOnlyOneProblem( |
| problems, |
| BetweenExpression_MissingAnd, |
| startPosition, |
| endPosition |
| ); |
| } |
| |
| @Test |
| public final void test_BetweenExpression_MissingExpression() throws Exception { |
| |
| String jpqlQuery = "SELECT e FROM Employee e WHERE BETWEEN 20 AND 40"; |
| int startPosition = "SELECT e FROM Employee e WHERE ".length(); |
| int endPosition = startPosition; |
| |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| |
| testHasOnlyOneProblem( |
| problems, |
| BetweenExpression_MissingExpression, |
| startPosition, |
| endPosition |
| ); |
| } |
| |
| @Test |
| public final void test_BetweenExpression_MissingLowerBoundExpression() throws Exception { |
| |
| String jpqlQuery = "SELECT e FROM Employee e WHERE e.age BETWEEN AND 40"; |
| int startPosition = "SELECT e FROM Employee e WHERE e.age BETWEEN ".length(); |
| int endPosition = startPosition; |
| |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| |
| testHasOnlyOneProblem( |
| problems, |
| BetweenExpression_MissingLowerBoundExpression, |
| startPosition, |
| endPosition |
| ); |
| } |
| |
| @Test |
| public final void test_BetweenExpression_MissingUpperBoundExpression_1() throws Exception { |
| |
| String jpqlQuery = "SELECT e FROM Employee e WHERE e.age BETWEEN 20 AND"; |
| int startPosition = jpqlQuery.length(); |
| int endPosition = startPosition; |
| |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| |
| testHasOnlyOneProblem( |
| problems, |
| BetweenExpression_MissingUpperBoundExpression, |
| startPosition, |
| endPosition |
| ); |
| } |
| |
| @Test |
| public final void test_BetweenExpression_MissingUpperBoundExpression_2() throws Exception { |
| |
| String jpqlQuery = "SELECT e FROM Employee e WHERE e.age BETWEEN 20 AND "; |
| int startPosition = jpqlQuery.length(); |
| int endPosition = startPosition; |
| |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| |
| testHasOnlyOneProblem( |
| problems, |
| BetweenExpression_MissingUpperBoundExpression, |
| startPosition, |
| endPosition |
| ); |
| } |
| |
| @Test |
| public final void test_CaseExpression_MissingElseExpression_1() throws Exception { |
| |
| String jpqlQuery = "UPDATE Employee e " + |
| "SET e.salary = " + |
| " CASE WHEN e.rating = 1 THEN e.salary * 1.1 " + |
| " WHEN e.rating = 2 THEN e.salary * 1.05 " + |
| " ELSE " + |
| " END"; |
| |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| |
| jpqlQuery = jpqlQuery.replaceAll("\\s+", " "); |
| |
| int startPosition = jpqlQuery.length() - Expression.END.length(); |
| int endPosition = startPosition; |
| |
| testHasOnlyOneProblem( |
| problems, |
| CaseExpression_MissingElseExpression, |
| startPosition, |
| endPosition |
| ); |
| } |
| |
| @Test |
| public final void test_CaseExpression_MissingElseExpression_2() throws Exception { |
| |
| String jpqlQuery = "SELECT e.name," + |
| " CASE TYPE(e) WHEN Exempt THEN 'Exempt'" + |
| " WHEN Contractor THEN 'Contractor'" + |
| " WHEN Intern THEN 'Intern'" + |
| " ELSE " + |
| " END " + |
| "FROM Employee e"; |
| |
| jpqlQuery = jpqlQuery.replaceAll("\\s+", " "); |
| |
| int startPosition = jpqlQuery.length() - "END FROM Employee e".length(); |
| int endPosition = startPosition; |
| |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| |
| testHasOnlyOneProblem( |
| problems, |
| CaseExpression_MissingElseExpression, |
| startPosition, |
| endPosition |
| ); |
| } |
| |
| @Test |
| public final void test_CaseExpression_MissingElseIdentifier_1() throws Exception { |
| |
| String jpqlQuery = "UPDATE Employee e " + |
| "SET e.salary = " + |
| " CASE WHEN e.rating = 1 THEN e.salary * 1.1 " + |
| " WHEN e.rating = 2 THEN e.salary * 1.05" + |
| " END"; |
| |
| jpqlQuery = jpqlQuery.replaceAll("\\s+", " "); |
| |
| int startPosition = jpqlQuery.length() - Expression.END.length(); |
| int endPosition = startPosition; |
| |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| |
| testHasOnlyOneProblem( |
| problems, |
| CaseExpression_MissingElseIdentifier, |
| startPosition, |
| endPosition |
| ); |
| } |
| |
| @Test |
| public final void test_CaseExpression_MissingElseIdentifier_2() throws Exception { |
| |
| String jpqlQuery = "UPDATE Employee e " + |
| "SET e.salary = " + |
| " CASE WHEN e.rating = 1 THEN e.salary * 1.1 " + |
| " WHEN e.rating = 2 THEN e.salary * 1.05 " + |
| " END"; |
| |
| jpqlQuery = jpqlQuery.replaceAll("\\s+", " "); |
| |
| int startPosition = jpqlQuery.length() - Expression.END.length(); |
| int endPosition = startPosition; |
| |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| |
| testHasOnlyOneProblem( |
| problems, |
| CaseExpression_MissingElseIdentifier, |
| startPosition, |
| endPosition |
| ); |
| } |
| |
| @Test |
| public final void test_CaseExpression_MissingEndIdentifier() throws Exception { |
| |
| String jpqlQuery = "UPDATE Employee e " + |
| "SET e.salary = " + |
| " CASE WHEN e.rating = 1 THEN e.salary * 1.1 " + |
| " WHEN e.rating = 2 THEN e.salary * 1.05 " + |
| " ELSE e.salary * 1.01"; |
| |
| jpqlQuery = jpqlQuery.replaceAll("\\s+", " "); |
| |
| int startPosition = jpqlQuery.length(); |
| int endPosition = startPosition; |
| |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| |
| testHasOnlyOneProblem( |
| problems, |
| CaseExpression_MissingEndIdentifier, |
| startPosition, |
| endPosition |
| ); |
| } |
| |
| @Test |
| public final void test_CaseExpression_MissingWhenClause() throws Exception { |
| |
| String jpqlQuery = "UPDATE Employee e " + |
| "SET e.salary = " + |
| " CASE TYPE(e)" + |
| " ELSE 'NonExempt'" + |
| " END"; |
| |
| jpqlQuery = jpqlQuery.replaceAll("\\s+", " "); |
| |
| int startPosition = "UPDATE Employee e SET e.salary = CASE TYPE(e) ".length(); |
| int endPosition = startPosition; |
| |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| |
| testHasOnlyOneProblem( |
| problems, |
| CaseExpression_MissingWhenClause, |
| startPosition, |
| endPosition |
| ); |
| } |
| |
| @Test |
| public final void test_CoalesceExpression_InvalidExpression() throws Exception { |
| |
| String jpqlQuery = "SELECT COALESCE(SELECT e) FROM Employee e"; |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| |
| if (isSubqueryAllowedAnywhere()) { |
| testDoesNotHaveProblem( |
| problems, |
| CoalesceExpression_InvalidExpression |
| ); |
| } |
| else { |
| int startPosition = "SELECT COALESCE(".length(); |
| int endPosition = "SELECT COALESCE(SELECT e".length(); |
| |
| testHasOnlyOneProblem( |
| problems, |
| CoalesceExpression_InvalidExpression, |
| startPosition, |
| endPosition |
| ); |
| } |
| } |
| |
| @Test |
| public final void test_CoalesceExpression_MissingExpression() throws Exception { |
| |
| String jpqlQuery = "SELECT COALESCE() FROM Employee e"; |
| int startPosition = "SELECT COALESCE(".length(); |
| int endPosition = startPosition; |
| |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| |
| testHasOnlyOneProblem( |
| problems, |
| CoalesceExpression_MissingExpression, |
| startPosition, |
| endPosition |
| ); |
| } |
| |
| @Test |
| public final void test_CoalesceExpression_MissingLeftParenthesis() throws Exception { |
| |
| String jpqlQuery = "SELECT COALESCE 4 + 5) FROM Employee e"; |
| int startPosition = "SELECT COALESCE".length(); |
| int endPosition = startPosition; |
| |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| |
| testHasOnlyOneProblem( |
| problems, |
| CoalesceExpression_MissingLeftParenthesis, |
| startPosition, |
| endPosition |
| ); |
| } |
| |
| @Test |
| public final void test_CoalesceExpression_MissingRightParenthesis() throws Exception { |
| |
| String jpqlQuery = "SELECT COALESCE(e.age + 100 FROM Employee e"; |
| int startPosition = "SELECT COALESCE(e.age + 100".length(); |
| int endPosition = startPosition; |
| |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| |
| testHasOnlyOneProblem( |
| problems, |
| CoalesceExpression_MissingRightParenthesis, |
| startPosition, |
| endPosition |
| ); |
| } |
| |
| @Test |
| public final void test_CollectionMemberDeclaration_MissingCollectionValuedPathExpression() throws Exception { |
| |
| String jpqlQuery = "SELECT e FROM Employee e, IN() AS m"; |
| int startPosition = "SELECT e FROM Employee e, IN(".length(); |
| int endPosition = startPosition; |
| |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| |
| testHasOnlyOneProblem( |
| problems, |
| CollectionMemberDeclaration_MissingCollectionValuedPathExpression, |
| startPosition, |
| endPosition |
| ); |
| } |
| |
| @Test |
| public final void test_CollectionMemberDeclaration_MissingIdentificationVariable_1() throws Exception { |
| |
| String jpqlQuery = "SELECT e FROM Employee e, IN(e.employees) AS"; |
| int startPosition = jpqlQuery.length(); |
| int endPosition = startPosition; |
| |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| |
| testHasOnlyOneProblem( |
| problems, |
| CollectionMemberDeclaration_MissingIdentificationVariable, |
| startPosition, |
| endPosition |
| ); |
| } |
| |
| @Test |
| public final void test_CollectionMemberDeclaration_MissingIdentificationVariable_2() throws Exception { |
| |
| String jpqlQuery = "SELECT e FROM Employee e, IN(e.employees) AS "; |
| int startPosition = jpqlQuery.length(); |
| int endPosition = startPosition; |
| |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| |
| testHasOnlyOneProblem( |
| problems, |
| CollectionMemberDeclaration_MissingIdentificationVariable, |
| startPosition, |
| endPosition |
| ); |
| } |
| |
| @Test |
| public final void test_CollectionMemberDeclaration_MissingLeftParenthesis() throws Exception { |
| |
| String jpqlQuery = "SELECT e FROM Employee e, IN e.managers) AS m"; |
| int startPosition = "SELECT e FROM Employee e, IN".length(); |
| int endPosition = startPosition; |
| |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| |
| testHasOnlyOneProblem( |
| problems, |
| CollectionMemberDeclaration_MissingLeftParenthesis, |
| startPosition, |
| endPosition |
| ); |
| } |
| |
| @Test |
| public final void test_CollectionMemberDeclaration_MissingRightParenthesis() throws Exception { |
| |
| String jpqlQuery = "SELECT e FROM Employee e, IN(e.employees AS m"; |
| int startPosition = "SELECT e FROM Employee e, IN(e.employees".length(); |
| int endPosition = startPosition; |
| |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| |
| testHasOnlyOneProblem( |
| problems, |
| CollectionMemberDeclaration_MissingRightParenthesis, |
| startPosition, |
| endPosition |
| ); |
| } |
| |
| @Test |
| public final void test_CollectionMemberExpression_MissingCollectionValuedPathExpression() throws Exception { |
| |
| String jpqlQuery = "SELECT e, f FROM Employee e WHERE e.name MEMBER OF "; |
| int startPosition = "SELECT e, f FROM Employee e WHERE e.name MEMBER OF ".length(); |
| int endPosition = startPosition; |
| |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| |
| testHasOnlyOneProblem( |
| problems, |
| CollectionMemberExpression_MissingCollectionValuedPathExpression, |
| startPosition, |
| endPosition |
| ); |
| } |
| |
| @Test |
| public final void test_CollectionMemberExpression_MissingEntityExpression() throws Exception { |
| |
| String jpqlQuery = "SELECT e, f FROM Employee e WHERE MEMBER f.offices"; |
| int startPosition = "SELECT e, f FROM Employee e WHERE ".length(); |
| int endPosition = startPosition; |
| |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| |
| testHasOnlyOneProblem( |
| problems, |
| CollectionMemberExpression_MissingEntityExpression, |
| startPosition, |
| endPosition |
| ); |
| } |
| |
| @Test |
| public final void test_CollectionValuedPathExpression_NotCollectionType_1() throws Exception { |
| |
| String jpqlQuery = "SELECT c FROM Customer c WHERE c.lastName MEMBER 6"; |
| int startPosition = "SELECT c FROM Customer c WHERE c.lastName MEMBER ".length(); |
| int endPosition = jpqlQuery.length(); |
| |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| |
| testHasOnlyOneProblem( |
| problems, |
| CollectionValuedPathExpression_NotCollectionType, |
| startPosition, |
| endPosition |
| ); |
| } |
| |
| @Test |
| public final void test_CollectionValuedPathExpression_NotCollectionType_2() throws Exception { |
| |
| String jpqlQuery = "SELECT c FROM Customer c WHERE 6 IS EMPTY"; |
| int startPosition = "SELECT c FROM Customer c WHERE ".length(); |
| int endPosition = "SELECT c FROM Customer c WHERE 6".length(); |
| |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| |
| testHasOnlyOneProblem( |
| problems, |
| CollectionValuedPathExpression_NotCollectionType, |
| startPosition, |
| endPosition |
| ); |
| } |
| |
| @Test |
| public final void test_ComparisonExpression_MissingLeftExpression() throws Exception { |
| |
| String jpqlQuery = "SELECT e FROM EMPLOYEE e WHERE > 20"; |
| int startPosition = "SELECT e FROM EMPLOYEE e WHERE ".length(); |
| int endPosition = startPosition; |
| |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| |
| testHasOnlyOneProblem( |
| problems, |
| ComparisonExpression_MissingLeftExpression, |
| startPosition, |
| endPosition |
| ); |
| } |
| |
| @Test |
| public final void test_ComparisonExpression_MissingLeftRightExpression() throws Exception { |
| |
| String jpqlQuery = "SELECT e FROM EMPLOYEE e WHERE >"; |
| |
| int startPosition1 = "SELECT e FROM EMPLOYEE e WHERE ".length(); |
| int endPosition1 = startPosition1; |
| |
| int startPosition2 = "SELECT e FROM EMPLOYEE e WHERE >".length(); |
| int endPosition2 = startPosition2; |
| |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| |
| testHasProblems( |
| problems, |
| new String [] { ComparisonExpression_MissingLeftExpression, |
| ComparisonExpression_MissingRightExpression }, |
| new int[] { startPosition1, startPosition2 }, |
| new int[] { endPosition1, endPosition2 } |
| ); |
| } |
| |
| @Test |
| public final void test_ComparisonExpression_MissingRightExpression() throws Exception { |
| |
| String jpqlQuery = "SELECT e FROM EMPLOYEE e WHERE e.age >"; |
| int startPosition = "SELECT e FROM EMPLOYEE e WHERE e.age >".length(); |
| int endPosition = startPosition; |
| |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| |
| testHasOnlyOneProblem( |
| problems, |
| ComparisonExpression_MissingRightExpression, |
| startPosition, |
| endPosition |
| ); |
| } |
| |
| @Test |
| public final void test_ConcatExpression_InvalidFirstExpression() throws Exception { |
| |
| String jpqlQuery = "SELECT e FROM Employee e WHERE CONCAT(ALL(SELECT d FROM Dept d), e.lastName)"; |
| int startPosition = "SELECT e FROM Employee e WHERE CONCAT(".length(); |
| int endPosition = "SELECT e FROM Employee e WHERE CONCAT(ALL(SELECT d FROM Dept d)".length(); |
| |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| |
| testHasProblem( |
| problems, |
| ConcatExpression_InvalidExpression, |
| startPosition, |
| endPosition |
| ); |
| } |
| |
| @Test |
| public final void test_ConcatExpression_InvalidSecondExpression() throws Exception { |
| |
| String jpqlQuery = "SELECT e FROM Employee e WHERE CONCAT(e.firstName, ALL(SELECT d FROM Dept d))"; |
| int startPosition = "SELECT e FROM Employee e WHERE CONCAT(e.firstName, ".length(); |
| int endPosition = jpqlQuery.length() - 1; |
| |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| |
| testHasProblem( |
| problems, |
| ConcatExpression_InvalidExpression, |
| startPosition, |
| endPosition |
| ); |
| } |
| |
| @Test |
| public final void test_ConcatExpression_MissingLeftParenthesis() throws Exception { |
| |
| String jpqlQuery = "SELECT e FROM Employee e WHERE CONCAT e.firstName, e.lastName)"; |
| int startPosition = "SELECT e FROM Employee e WHERE CONCAT".length(); |
| int endPosition = startPosition; |
| |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| |
| testHasProblem( |
| problems, |
| ConcatExpression_MissingLeftParenthesis, |
| startPosition, |
| endPosition |
| ); |
| } |
| |
| @Test |
| public final void test_ConcatExpression_MissingRightParenthesis() throws Exception { |
| |
| String jpqlQuery = "SELECT e FROM Employee e WHERE CONCAT(e.firstName, e.lastName"; |
| int startPosition = jpqlQuery.length(); |
| int endPosition = startPosition; |
| |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| |
| testHasProblem( |
| problems, |
| ConcatExpression_MissingRightParenthesis, |
| startPosition, |
| endPosition |
| ); |
| } |
| |
| @Test |
| public final void test_ConstructorExpression_ConstructorItemEndsWithComma() throws Exception { |
| |
| String jpqlQuery = "SELECT NEW project1.Employee(e.name,) FROM Employee e"; |
| int startPosition = "SELECT NEW project1.Employee(e.name".length(); |
| int endPosition = startPosition + 1; |
| |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| |
| testHasOnlyOneProblem( |
| problems, |
| ConstructorExpression_ConstructorItemEndsWithComma, |
| startPosition, |
| endPosition |
| ); |
| } |
| |
| @Test |
| public final void test_ConstructorExpression_ConstructorItemIsMissingComma() throws Exception { |
| |
| String jpqlQuery = "SELECT NEW project1.Employee(e.name e.age) FROM Employee e"; |
| int startPosition = "SELECT NEW project1.Employee(e.name".length(); |
| int endPosition = startPosition + 1; |
| |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| |
| testHasOnlyOneProblem( |
| problems, |
| ConstructorExpression_ConstructorItemIsMissingComma, |
| startPosition, |
| endPosition |
| ); |
| } |
| |
| @Test |
| public final void test_ConstructorExpression_MissingConstructorItem() throws Exception { |
| |
| String jpqlQuery = "SELECT NEW project1.Employee() FROM Employee e"; |
| int startPosition = "SELECT NEW project1.Employee(".length(); |
| int endPosition = startPosition; |
| |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| |
| testHasOnlyOneProblem( |
| problems, |
| ConstructorExpression_MissingConstructorItem, |
| startPosition, |
| endPosition |
| ); |
| } |
| |
| @Test |
| public final void test_ConstructorExpression_MissingConstructorName() throws Exception { |
| |
| String jpqlQuery = "SELECT NEW (e.name) FROM Employee e"; |
| int startPosition = "SELECT NEW ".length(); |
| int endPosition = startPosition; |
| |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| |
| testHasOnlyOneProblem( |
| problems, |
| ConstructorExpression_MissingConstructorName, |
| startPosition, |
| endPosition |
| ); |
| } |
| |
| @Test |
| public final void test_ConstructorExpression_MissingLeftParenthesis() throws Exception { |
| |
| String jpqlQuery = "SELECT NEW project1.Employee e.name) FROM Employee e"; |
| int startPosition = "SELECT NEW project1.Employee".length(); |
| int endPosition = startPosition; |
| |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| |
| testHasOnlyOneProblem( |
| problems, |
| ConstructorExpression_MissingLeftParenthesis, |
| startPosition, |
| endPosition |
| ); |
| } |
| |
| @Test |
| public final void test_ConstructorExpression_MissingRightParenthesis() throws Exception { |
| |
| String jpqlQuery = "SELECT NEW project1.Employee(e.name FROM Employee e"; |
| int startPosition = "SELECT NEW project1.Employee(e.name".length(); |
| int endPosition = startPosition; |
| |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| |
| testHasOnlyOneProblem( |
| problems, |
| ConstructorExpression_MissingRightParenthesis, |
| startPosition, |
| endPosition |
| ); |
| } |
| |
| @Test |
| public final void test_CountFunction_InvalidExpression() throws Exception { |
| |
| String jpqlQuery = "SELECT COUNT(AVG(e.age)) FROM Employee e"; |
| |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| JPQLQueryBNF queryBNF = getQueryBNF(InternalCountBNF.ID); |
| |
| if (queryBNF.getExpressionFactory(AvgFunctionFactory.ID) == null) { |
| |
| int startPosition = "SELECT COUNT(".length(); |
| int endPosition = "SELECT COUNT(AVG(e.age)".length(); |
| |
| testHasOnlyOneProblem( |
| problems, |
| CountFunction_InvalidExpression, |
| startPosition, |
| endPosition |
| ); |
| } |
| else { |
| testHasNoProblems(problems); |
| } |
| } |
| |
| @Test |
| public final void test_CountFunction_MissingExpression_1() throws Exception { |
| |
| String jpqlQuery = "SELECT COUNT() FROM Employee e"; |
| int startPosition = "SELECT COUNT(".length(); |
| int endPosition = startPosition; |
| |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| |
| testHasOnlyOneProblem( |
| problems, |
| CountFunction_MissingExpression, |
| startPosition, |
| endPosition |
| ); |
| } |
| |
| @Test |
| public final void test_CountFunction_MissingExpression_2() throws Exception { |
| |
| String jpqlQuery = "SELECT COUNT(DISTINCT) FROM Employee e"; |
| int startPosition = "SELECT COUNT(DISTINCT".length(); |
| int endPosition = startPosition; |
| |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| |
| testHasOnlyOneProblem( |
| problems, |
| CountFunction_MissingExpression, |
| startPosition, |
| endPosition |
| ); |
| } |
| |
| @Test |
| public final void test_CountFunction_MissingExpression_3() throws Exception { |
| |
| String jpqlQuery = "SELECT COUNT(DISTINCT ) FROM Employee e"; |
| int startPosition = "SELECT COUNT(DISTINCT ".length(); |
| int endPosition = startPosition; |
| |
| List<JPQLQueryProblem> problems = validate(jpqlQuery, buildFormatter_2()); |
| |
| testHasOnlyOneProblem( |
| problems, |
| CountFunction_MissingExpression, |
| startPosition, |
| endPosition |
| ); |
| } |
| |
| @Test |
| public final void test_CountFunction_MissingLeftParenthesis_1() throws Exception { |
| |
| String jpqlQuery = "SELECT COUNT e.age) FROM Employee e"; |
| int startPosition = "SELECT COUNT".length(); |
| int endPosition = startPosition; |
| |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| |
| testHasOnlyOneProblem( |
| problems, |
| CountFunction_MissingLeftParenthesis, |
| startPosition, |
| endPosition |
| ); |
| } |
| |
| @Test |
| public final void test_CountFunction_MissingLeftParenthesis_2() throws Exception { |
| |
| String jpqlQuery = "SELECT COUNT DISTINCT e.age) FROM Employee e"; |
| int startPosition = "SELECT COUNT".length(); |
| int endPosition = startPosition; |
| |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| |
| testHasOnlyOneProblem( |
| problems, |
| CountFunction_MissingLeftParenthesis, |
| startPosition, |
| endPosition |
| ); |
| } |
| |
| @Test |
| public final void test_CountFunction_MissingRightParenthesis() throws Exception { |
| |
| String jpqlQuery = "SELECT COUNT(DISTINCT e.age FROM Employee e"; |
| int startPosition = "SELECT COUNT(DISTINCT e.age".length(); |
| int endPosition = startPosition; |
| |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| |
| testHasOnlyOneProblem( |
| problems, |
| CountFunction_MissingRightParenthesis, |
| startPosition, |
| endPosition |
| ); |
| } |
| |
| @Test |
| public final void test_DateTime_JDBCEscapeFormat_InvalidSpecification() throws Exception { |
| |
| String jpqlQuery = "SELECT e FROM Employee e WHERE e.startDate < {jdbc '2008-12-31'}"; |
| int startPosition = "SELECT e FROM Employee e WHERE e.startDate < {".length(); |
| int endPosition = "SELECT e FROM Employee e WHERE e.startDate < {jdbc".length(); |
| |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| |
| testHasOnlyOneProblem( |
| problems, |
| DateTime_JDBCEscapeFormat_InvalidSpecification, |
| startPosition, |
| endPosition |
| ); |
| } |
| |
| @Test |
| public final void test_DateTime_JDBCEscapeFormat_MissingCloseQuote() throws Exception { |
| |
| String jpqlQuery = "SELECT e FROM Employee e WHERE e.startDate < {d '2008-12-31}"; |
| int startPosition = "SELECT e FROM Employee e WHERE e.startDate < {d '2008-12-31".length(); |
| int endPosition = startPosition; |
| |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| |
| testHasOnlyOneProblem( |
| problems, |
| DateTime_JDBCEscapeFormat_MissingCloseQuote, |
| startPosition, |
| endPosition |
| ); |
| } |
| |
| @Test |
| public final void test_DateTime_JDBCEscapeFormat_MissingOpenQuote() throws Exception { |
| |
| String jpqlQuery = "SELECT e FROM Employee e WHERE e.startDate < {d 2008-12-31'}"; |
| int startPosition = "SELECT e FROM Employee e WHERE e.startDate < {d ".length(); |
| int endPosition = startPosition; |
| |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| |
| testHasOnlyOneProblem( |
| problems, |
| DateTime_JDBCEscapeFormat_MissingOpenQuote, |
| startPosition, |
| endPosition |
| ); |
| } |
| |
| @Test |
| public final void test_DateTime_JDBCEscapeFormat_MissingRightCurlyBrace() throws Exception { |
| |
| String jpqlQuery = "SELECT e FROM Employee e WHERE e.startDate < {d '2008-12-31'"; |
| int startPosition = jpqlQuery.length(); |
| int endPosition = startPosition; |
| |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| |
| testHasOnlyOneProblem( |
| problems, |
| DateTime_JDBCEscapeFormat_MissingRightCurlyBrace, |
| startPosition, |
| endPosition |
| ); |
| } |
| |
| @Test |
| public final void test_DeleteClause_FromMissing_1() throws Exception { |
| |
| String jpqlQuery = "DELETE"; |
| int startPosition = jpqlQuery.length(); |
| int endPosition = startPosition; |
| |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| |
| testHasOnlyOneProblem( |
| problems, |
| DeleteClause_FromMissing, |
| startPosition, |
| endPosition |
| ); |
| } |
| |
| @Test |
| public final void test_DeleteClause_FromMissing_2() throws Exception { |
| |
| String jpqlQuery = "DELETE "; |
| int startPosition = jpqlQuery.length(); |
| int endPosition = startPosition; |
| |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| |
| testHasOnlyOneProblem( |
| problems, |
| DeleteClause_FromMissing, |
| startPosition, |
| endPosition |
| ); |
| } |
| |
| @Test |
| public final void test_DeleteClause_FromMissing_3() throws Exception { |
| |
| String jpqlQuery = "DELETE Employee e WHERE e.name = 'Pascal'"; |
| int startPosition = "DELETE ".length(); |
| int endPosition = startPosition; |
| |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| |
| testHasOnlyOneProblem( |
| problems, |
| DeleteClause_FromMissing, |
| startPosition, |
| endPosition |
| ); |
| } |
| |
| @Test |
| public final void test_DeleteClause_MultipleRangeVariableDeclaration() throws Exception { |
| |
| String jpqlQuery = "DELETE FROM Employee e, Address a WHERE e.name = 'Pascal'"; |
| int startPosition = "DELETE FROM Employee e".length(); |
| int endPosition = "DELETE FROM Employee e, Address a".length(); |
| |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| |
| testHasOnlyOneProblem( |
| problems, |
| DeleteClause_MultipleRangeVariableDeclaration, |
| startPosition, |
| endPosition |
| ); |
| } |
| |
| @Test |
| public final void test_DeleteClause_RangeVariableDeclarationMalformed_1() throws Exception { |
| |
| String jpqlQuery = "DELETE FROM Employee e a WHERE e.name = 'Pascal'"; |
| int startPosition = "DELETE FROM Employee e".length(); |
| int endPosition = "DELETE FROM Employee e a".length(); |
| |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| |
| testHasOnlyOneProblem( |
| problems, |
| DeleteClause_RangeVariableDeclarationMalformed, |
| startPosition, |
| endPosition |
| ); |
| } |
| |
| @Test |
| public final void test_DeleteClause_RangeVariableDeclarationMalformed_2() throws Exception { |
| |
| String jpqlQuery = "Delete from Employee e join e.address a where e.id < 0"; |
| int startPosition = "Delete from Employee e".length(); |
| int endPosition = "Delete from Employee e join e.address a".length(); |
| |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| |
| testHasOnlyOneProblem( |
| problems, |
| DeleteClause_RangeVariableDeclarationMalformed, |
| startPosition, |
| endPosition |
| ); |
| } |
| |
| @Test |
| public final void test_DeleteClause_RangeVariableDeclarationMalformed_FromMissing() throws Exception { |
| |
| String jpqlQuery = "DELETE Employee e a WHERE e.name = 'Pascal'"; |
| int startPosition1 = "DELETE ".length(); |
| int endPosition1 = startPosition1; |
| int startPosition2 = "DELETE Employee e".length(); |
| int endPosition2 = "DELETE Employee e a".length(); |
| |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| |
| testHasProblems( |
| problems, |
| new String[] { |
| DeleteClause_FromMissing, |
| DeleteClause_RangeVariableDeclarationMalformed, |
| }, |
| new int[] { startPosition1, startPosition2 }, |
| new int[] { endPosition1, endPosition2 } |
| ); |
| } |
| |
| @Test |
| public final void test_DeleteClause_RangeVariableDeclarationMissing_1() throws Exception { |
| |
| String jpqlQuery = "DELETE "; |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| testDoesNotHaveProblem(problems, DeleteClause_RangeVariableDeclarationMissing); |
| } |
| |
| @Test |
| public final void test_DeleteClause_RangeVariableDeclarationMissing_2() throws Exception { |
| |
| String jpqlQuery = "DELETE FROM"; |
| int startPosition = jpqlQuery.length() + 1; |
| int endPosition = startPosition; |
| |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| |
| testHasOnlyOneProblem( |
| problems, |
| DeleteClause_RangeVariableDeclarationMissing, |
| startPosition, |
| endPosition |
| ); |
| } |
| |
| @Test |
| public final void test_DeleteClause_RangeVariableDeclarationMissing_3() throws Exception { |
| |
| String jpqlQuery = "DELETE FROM "; |
| int startPosition = jpqlQuery.length(); |
| int endPosition = startPosition; |
| |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| |
| testHasOnlyOneProblem( |
| problems, |
| DeleteClause_RangeVariableDeclarationMissing, |
| startPosition, |
| endPosition |
| ); |
| } |
| |
| @Test |
| public final void test_DeleteClause_RangeVariableDeclarationMissing_4() throws Exception { |
| |
| String jpqlQuery = "DELETE FROM WHERE e.name = 'Pascal'"; |
| int startPosition = "DELETE FROM ".length(); |
| int endPosition = startPosition; |
| |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| |
| testHasOnlyOneProblem( |
| problems, |
| DeleteClause_RangeVariableDeclarationMissing, |
| startPosition, |
| endPosition |
| ); |
| } |
| |
| @Test |
| public final void test_EmptyCollectionComparisonExpression_MissingExpression() throws Exception { |
| |
| String jpqlQuery = "SELECT e FROM Employee e WHERE IS NOT EMPTY"; |
| int startPosition = "SELECT e FROM Employee e WHERE ".length(); |
| int endPosition = startPosition; |
| |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| |
| testHasOnlyOneProblem( |
| problems, |
| EmptyCollectionComparisonExpression_MissingExpression, |
| startPosition, |
| endPosition |
| ); |
| } |
| |
| @Test |
| public final void test_EntryExpression_InvalidExpression() throws Exception { |
| |
| String jpqlQuery = "SELECT ENTRY(e.name) FROM Employee e"; |
| int startPosition = "SELECT ENTRY(".length(); |
| int endPosition = "SELECT ENTRY(e.name".length(); |
| |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| |
| testHasOnlyOneProblem( |
| problems, |
| EntryExpression_InvalidExpression, |
| startPosition, |
| endPosition |
| ); |
| } |
| |
| @Test |
| public final void test_EntryExpression_MissingExpression() throws Exception { |
| |
| String jpqlQuery = "SELECT ENTRY() FROM Employee e JOIN e.addresses a"; |
| int startPosition = "SELECT ENTRY(".length(); |
| int endPosition = startPosition; |
| |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| |
| testHasOnlyOneProblem( |
| problems, |
| EntryExpression_MissingExpression, |
| startPosition, |
| endPosition |
| ); |
| } |
| |
| @Test |
| public final void test_EntryExpression_MissingLeftParenthesis() throws Exception { |
| |
| String jpqlQuery = "SELECT ENTRY a) FROM Employee e JOIN e.addresses a"; |
| int startPosition = "SELECT ENTRY".length(); |
| int endPosition = startPosition; |
| |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| |
| testHasOnlyOneProblem( |
| problems, |
| EntryExpression_MissingLeftParenthesis, |
| startPosition, |
| endPosition |
| ); |
| } |
| |
| @Test |
| public final void test_EntryExpression_MissingRightParenthesis() throws Exception { |
| |
| String jpqlQuery = "SELECT ENTRY(a FROM Employee e JOIN e.addresses a"; |
| int startPosition = "SELECT ENTRY(a".length(); |
| int endPosition = startPosition; |
| |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| |
| testHasOnlyOneProblem( |
| problems, |
| EntryExpression_MissingRightParenthesis, |
| startPosition, |
| endPosition |
| ); |
| } |
| |
| @Test |
| public final void test_ExistsExpression_InvalidExpression() throws Exception { |
| |
| String jpqlQuery = "SELECT e FROM Employee e WHERE EXISTS(e.name)"; |
| int startPosition = "SELECT e FROM Employee e WHERE EXISTS(".length(); |
| int endPosition = "SELECT e FROM Employee e WHERE EXISTS(e.name".length(); |
| |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| |
| testHasOnlyOneProblem( |
| problems, |
| ExistsExpression_InvalidExpression, |
| startPosition, |
| endPosition |
| ); |
| } |
| |
| @Test |
| public final void test_ExistsExpression_MissingExpression() throws Exception { |
| |
| String jpqlQuery = "SELECT e FROM Employee e JOIN e.addresses a WHERE EXISTS()"; |
| int startPosition = "SELECT e FROM Employee e JOIN e.addresses a WHERE EXISTS(".length(); |
| int endPosition = startPosition; |
| |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| |
| testHasOnlyOneProblem( |
| problems, |
| ExistsExpression_MissingExpression, |
| startPosition, |
| endPosition |
| ); |
| } |
| |
| @Test |
| public final void test_ExistsExpression_MissingLeftParenthesis() throws Exception { |
| |
| String jpqlQuery = "SELECT e FROM Employee e JOIN e.addresses a WHERE EXISTS SELECT p FROM Order p)"; |
| int startPosition = "SELECT e FROM Employee e JOIN e.addresses a WHERE EXISTS".length(); |
| int endPosition = startPosition; |
| |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| |
| testHasOnlyOneProblem( |
| problems, |
| ExistsExpression_MissingLeftParenthesis, |
| startPosition, |
| endPosition |
| ); |
| } |
| |
| @Test |
| public final void test_ExistsExpression_MissingRightParenthesis() throws Exception { |
| |
| String jpqlQuery = "SELECT e FROM Employee e JOIN e.addresses a WHERE EXISTS(SELECT p FROM Order p"; |
| int startPosition = jpqlQuery.length(); |
| int endPosition = startPosition; |
| |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| |
| testHasOnlyOneProblem( |
| problems, |
| ExistsExpression_MissingRightParenthesis, |
| startPosition, |
| endPosition |
| ); |
| } |
| |
| @Test |
| public final void test_GroupByClause_GroupByItemEndsWithComma() throws Exception { |
| |
| String jpqlQuery = "SELECT e FROM Employee e GROUP BY e.name, e.age,"; |
| int startPosition = jpqlQuery.length() - 1; |
| int endPosition = startPosition + 1; |
| |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| |
| testHasOnlyOneProblem( |
| problems, |
| GroupByClause_GroupByItemEndsWithComma, |
| startPosition, |
| endPosition |
| ); |
| } |
| |
| @Test |
| public final void test_GroupByClause_GroupByItemIsMissingComma_1() throws Exception { |
| |
| String jpqlQuery = "SELECT e FROM Employee e GROUP BY e.name e.age"; |
| int startPosition = "SELECT e FROM Employee e GROUP BY e.name".length(); |
| int endPosition = startPosition + 1; |
| |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| |
| testHasOnlyOneProblem( |
| problems, |
| GroupByClause_GroupByItemIsMissingComma, |
| startPosition, |
| endPosition |
| ); |
| } |
| |
| @Test |
| public final void test_GroupByClause_GroupByItemIsMissingComma_2() throws Exception { |
| |
| String jpqlQuery = "SELECT e FROM Employee e GROUP BY e.name, e.age e"; |
| int startPosition = "SELECT e FROM Employee e GROUP BY e.name, e.age".length(); |
| int endPosition = startPosition + 1; |
| |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| |
| testHasOnlyOneProblem( |
| problems, |
| GroupByClause_GroupByItemIsMissingComma, |
| startPosition, |
| endPosition |
| ); |
| } |
| |
| @Test |
| public final void test_GroupByClause_GroupByItemMissing() throws Exception { |
| |
| String jpqlQuery = "SELECT e FROM Employee e GROUP BY"; |
| int startPosition = jpqlQuery.length(); |
| int endPosition = jpqlQuery.length(); |
| |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| |
| testHasOnlyOneProblem( |
| problems, |
| GroupByClause_GroupByItemMissing, |
| startPosition, |
| endPosition |
| ); |
| } |
| |
| @Test |
| public final void test_HavingClause_ConditionalExpressionMissing_1() throws Exception { |
| |
| String jpqlQuery = "SELECT e FROM Employee e HAVING"; |
| int startPosition = "SELECT e FROM Employee e ".length(); |
| int endPosition = jpqlQuery.length(); |
| |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| |
| testHasOnlyOneProblem( |
| problems, |
| HavingClause_MissingConditionalExpression, |
| startPosition, |
| endPosition |
| ); |
| } |
| |
| @Test |
| public final void test_HavingClause_ConditionalExpressionMissing_2() throws Exception { |
| |
| String jpqlQuery = "SELECT e FROM Employee e HAVING "; |
| int startPosition = "SELECT e FROM Employee e ".length(); |
| int endPosition = jpqlQuery.length(); |
| |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| |
| testHasOnlyOneProblem( |
| problems, |
| HavingClause_MissingConditionalExpression, |
| startPosition, |
| endPosition |
| ); |
| } |
| |
| @Test |
| public final void test_HavingClause_InvalidConditionalExpression() throws Exception { |
| |
| String jpqlQuery = "SELECT e FROM Employee e HAVING LENGTH(e.name)"; |
| int startPosition = "SELECT e FROM Employee e HAVING ".length(); |
| int endPosition = jpqlQuery.length(); |
| |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| |
| testHasOnlyOneProblem( |
| problems, |
| HavingClause_InvalidConditionalExpression, |
| startPosition, |
| endPosition |
| ); |
| } |
| |
| @Test |
| public final void test_IdentificationVariable_Invalid_JavaIdentifier_1() throws Exception { |
| |
| String jpqlQuery = "SELECT e FROM Employee 2e"; |
| int startPosition = "SELECT e FROM Employee ".length(); |
| int endPosition = jpqlQuery.length(); |
| |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| |
| testHasProblem( |
| problems, |
| IdentificationVariable_Invalid_JavaIdentifier, |
| startPosition, |
| endPosition |
| ); |
| } |
| |
| @Test |
| public final void test_IdentificationVariable_Invalid_JavaIdentifier_2() throws Exception { |
| |
| String jpqlQuery = "SELECT e!q FROM Employee e"; |
| int startPosition = "SELECT ".length(); |
| int endPosition = "SELECT e!q".length(); |
| |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| |
| testHasOnlyOneProblem( |
| problems, |
| IdentificationVariable_Invalid_JavaIdentifier, |
| startPosition, |
| endPosition |
| ); |
| } |
| |
| @Test |
| public final void test_IdentificationVariable_Invalid_ReservedWord() throws Exception { |
| |
| String jpqlQuery = "SELECT e FROM Employee e, Adress AVG"; |
| int startPosition = "SELECT e FROM Employee e, Adress ".length(); |
| int endPosition = jpqlQuery.length(); |
| |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| |
| testHasOnlyOneProblem( |
| problems, |
| IdentificationVariable_Invalid_ReservedWord, |
| startPosition, |
| endPosition |
| ); |
| } |
| |
| @Test |
| public final void test_IdentificationVariableDeclaration_JoinsEndWithComma_1() throws Exception { |
| |
| String jpqlQuery = "SELECT e FROM Employee e"; |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| |
| testDoesNotHaveProblem( |
| problems, |
| IdentificationVariableDeclaration_JoinsEndWithComma |
| ); |
| } |
| |
| @Test |
| public final void test_IdentificationVariableDeclaration_MissingRangeVariableDeclaration1() throws Exception { |
| |
| String jpqlQuery = "SELECT e FROM JOIN e.managers m"; |
| int startPosition = "SELECT e FROM ".length(); |
| int endPosition = startPosition; |
| |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| |
| testHasProblem( |
| problems, |
| IdentificationVariableDeclaration_MissingRangeVariableDeclaration, |
| startPosition, |
| endPosition |
| ); |
| } |
| |
| @Test |
| public final void test_IdentificationVariableDeclaration_MissingRangeVariableDeclaration2() throws Exception { |
| |
| String jpqlQuery = "SELECT e FROM Employee e JOIN e.managers m, JOIN e.addresses a, Address add"; |
| int startPosition = "SELECT e FROM Employee e JOIN e.managers m, ".length(); |
| int endPosition = startPosition; |
| |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| |
| testHasOnlyOneProblem( |
| problems, |
| IdentificationVariableDeclaration_MissingRangeVariableDeclaration, |
| startPosition, |
| endPosition |
| ); |
| } |
| |
| @Test |
| public final void test_IndexExpression_InvalidExpression() throws Exception { |
| |
| String jpqlQuery = "SELECT INDEX(e.name) FROM Employee e"; |
| int startPosition = "SELECT INDEX(".length(); |
| int endPosition = "SELECT INDEX(e.name".length(); |
| |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| |
| testHasOnlyOneProblem( |
| problems, |
| IndexExpression_InvalidExpression, |
| startPosition, |
| endPosition |
| ); |
| } |
| |
| @Test |
| public final void test_IndexExpression_MissingExpression() throws Exception { |
| |
| String jpqlQuery = "SELECT INDEX() FROM Employee e"; |
| int startPosition = "SELECT INDEX(".length(); |
| int endPosition = startPosition; |
| |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| |
| testHasOnlyOneProblem( |
| problems, |
| IndexExpression_MissingExpression, |
| startPosition, |
| endPosition |
| ); |
| } |
| |
| @Test |
| public final void test_IndexExpression_MissingLeftParenthesis() throws Exception { |
| |
| String jpqlQuery = "SELECT INDEX e) FROM Employee e"; |
| int startPosition = "SELECT INDEX".length(); |
| int endPosition = startPosition; |
| |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| |
| testHasOnlyOneProblem( |
| problems, |
| IndexExpression_MissingLeftParenthesis, |
| startPosition, |
| endPosition |
| ); |
| } |
| |
| @Test |
| public final void test_IndexExpression_MissingRightParenthesis() throws Exception { |
| |
| String jpqlQuery = "SELECT INDEX(e FROM Employee e"; |
| int startPosition = "SELECT INDEX(e".length(); |
| int endPosition = startPosition; |
| |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| |
| testHasOnlyOneProblem( |
| problems, |
| IndexExpression_MissingRightParenthesis, |
| startPosition, |
| endPosition |
| ); |
| } |
| |
| @Test |
| public final void test_InExpression_ItemEndWithComma() throws Exception { |
| |
| String jpqlQuery = "SELECT e FROM Employee e WHERE e.name IN(?1, ?2,)"; |
| int startPosition = "SELECT e FROM Employee e WHERE e.name IN(?1, ?2".length(); |
| int endPosition = startPosition + 1; |
| |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| |
| testHasOnlyOneProblem( |
| problems, |
| InExpression_ItemEndsWithComma, |
| startPosition, |
| endPosition |
| ); |
| } |
| |
| @Test |
| public final void test_InExpression_ItemInvalidExpression_2() throws Exception { |
| |
| String jpqlQuery = "SELECT e FROM Employee e WHERE e.name IN :age"; |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| |
| testDoesNotHaveProblem( |
| problems, |
| InExpression_ItemInvalidExpression |
| ); |
| } |
| |
| @Test |
| public final void test_InExpression_ItemInvalidExpression_3() throws Exception { |
| |
| String jpqlQuery = "SELECT e FROM Employee e WHERE e.name IN (:age)"; |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| |
| testDoesNotHaveProblem( |
| problems, |
| InExpression_ItemInvalidExpression |
| ); |
| } |
| |
| @Test |
| public final void test_InExpression_ItemInvalidExpression_4() throws Exception { |
| |
| String jpqlQuery = "SELECT e FROM Employee e WHERE e.name IN (SELECT a FROM Address a)"; |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| |
| testDoesNotHaveProblem( |
| problems, |
| InExpression_ItemInvalidExpression |
| ); |
| } |
| |
| @Test |
| public final void test_InExpression_ItemIsMissingComma() throws Exception { |
| |
| String jpqlQuery = "SELECT e FROM Employee e WHERE e.name IN(?1 ?2)"; |
| int startPosition = "SELECT e FROM Employee e WHERE e.name IN(?1".length(); |
| int endPosition = startPosition + 1; |
| |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| |
| testHasOnlyOneProblem( |
| problems, |
| InExpression_ItemIsMissingComma, |
| startPosition, |
| endPosition |
| ); |
| } |
| |
| @Test |
| public final void test_InExpression_MissingExpression() throws Exception { |
| |
| String jpqlQuery = "SELECT e FROM Employee e WHERE IN :age"; |
| int startPosition = "SELECT e FROM Employee e WHERE ".length(); |
| int endPosition = startPosition; |
| |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| |
| testHasOnlyOneProblem( |
| problems, |
| InExpression_MissingExpression, |
| startPosition, |
| endPosition |
| ); |
| } |
| |
| @Test |
| public final void test_InExpression_MissingInItems() throws Exception { |
| |
| String jpqlQuery = "SELECT e FROM Employee e WHERE e.name IN()"; |
| int startPosition = "SELECT e FROM Employee e WHERE e.name IN(".length(); |
| int endPosition = startPosition; |
| |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| |
| testHasOnlyOneProblem( |
| problems, |
| InExpression_MissingInItems, |
| startPosition, |
| endPosition |
| ); |
| } |
| |
| @Test |
| public final void test_InExpression_MissingLeftParenthesis_1() throws Exception { |
| |
| String jpqlQuery = "SELECT e FROM Employee e WHERE e.name IN e.address.street)"; |
| int startPosition = "SELECT e FROM Employee e WHERE e.name IN".length(); |
| int endPosition = startPosition; |
| |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| |
| testHasOnlyOneProblem( |
| problems, |
| InExpression_MissingLeftParenthesis, |
| startPosition, |
| endPosition |
| ); |
| } |
| |
| @Test |
| public final void test_InExpression_MissingLeftParenthesis_2() throws Exception { |
| |
| String jpqlQuery = "SELECT e FROM Employee e WHERE e.name IN :name"; |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| testDoesNotHaveProblem(problems, InExpression_MissingLeftParenthesis); |
| } |
| |
| @Test |
| public final void test_InExpression_MissingRightParenthesis_1() throws Exception { |
| |
| String jpqlQuery = "SELECT e FROM Employee e WHERE e.name IN('JPQL', 'JPA'"; |
| int startPosition = jpqlQuery.length(); |
| int endPosition = startPosition; |
| |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| |
| testHasOnlyOneProblem( |
| problems, |
| InExpression_MissingRightParenthesis, |
| startPosition, |
| endPosition |
| ); |
| } |
| |
| @Test |
| public final void test_InExpression_MissingRightParenthesis_2() throws Exception { |
| |
| String jpqlQuery = "SELECT e FROM Employee e WHERE e.name IN :name"; |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| testDoesNotHaveProblem(problems, InExpression_MissingRightParenthesis); |
| } |
| |
| @Test |
| public final void test_InputParameter_JavaIdentifier_1() throws Exception { |
| |
| String jpqlQuery = "SELECT e FROM Employee e WHERE :2AVG = 'Pascal'"; |
| int startPosition = "SELECT e FROM Employee e WHERE ".length(); |
| int endPosition = "SELECT e FROM Employee e WHERE :2AVG".length(); |
| |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| |
| testHasOnlyOneProblem( |
| problems, |
| InputParameter_JavaIdentifier, |
| startPosition, |
| endPosition |
| ); |
| } |
| |
| @Test |
| public final void test_InputParameter_JavaIdentifier_2() throws Exception { |
| |
| String jpqlQuery = "SELECT e FROM Employee e WHERE :e!qb = 'Pascal'"; |
| int startPosition = "SELECT e FROM Employee e WHERE ".length(); |
| int endPosition = "SELECT e FROM Employee e WHERE :e!qb".length(); |
| |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| |
| testHasOnlyOneProblem( |
| problems, |
| InputParameter_JavaIdentifier, |
| startPosition, |
| endPosition |
| ); |
| } |
| |
| @Test |
| public final void test_InputParameter_MissingParameter_1() throws Exception { |
| |
| String jpqlQuery = "SELECT e FROM Employee e WHERE ? = 'Pascal'"; |
| int startPosition = "SELECT e FROM Employee e WHERE ".length(); |
| int endPosition = startPosition + 1; |
| |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| |
| testHasOnlyOneProblem( |
| problems, |
| InputParameter_MissingParameter, |
| startPosition, |
| endPosition |
| ); |
| } |
| |
| @Test |
| public final void test_InputParameter_MissingParameter_2() throws Exception { |
| |
| String jpqlQuery = "SELECT e FROM Employee e WHERE : = 'Pascal'"; |
| int startPosition = "SELECT e FROM Employee e WHERE ".length(); |
| int endPosition = startPosition + 1; |
| |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| |
| testHasOnlyOneProblem( |
| problems, |
| InputParameter_MissingParameter, |
| startPosition, |
| endPosition |
| ); |
| } |
| |
| @Test |
| public final void test_InputParameter_Mixture() throws Exception { |
| |
| String jpqlQuery = "SELECT e FROM Employee e WHERE :name = 'Pascal' AND e.age < ?1"; |
| |
| int startPosition1 = "SELECT e FROM Employee e WHERE ".length(); |
| int endPosition1 = "SELECT e FROM Employee e WHERE :name".length(); |
| |
| int startPosition2 = "SELECT e FROM Employee e WHERE :name = 'Pascal' AND e.age < ".length(); |
| int endPosition2 = jpqlQuery.length(); |
| |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| |
| testHasProblems( |
| problems, |
| new String[] { InputParameter_Mixture, InputParameter_Mixture }, |
| new int[] { startPosition1, startPosition2 }, |
| new int[] { endPosition1, endPosition2 } |
| ); |
| } |
| |
| @Test |
| public final void test_InputParameter_NotInteger_1() throws Exception { |
| |
| String jpqlQuery = "SELECT e FROM Employee e WHERE ?1a = 'Pascal'"; |
| int startPosition = "SELECT e FROM Employee e WHERE ".length(); |
| int endPosition = "SELECT e FROM Employee e WHERE ?1a".length(); |
| |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| |
| testHasOnlyOneProblem( |
| problems, |
| InputParameter_NotInteger, |
| startPosition, |
| endPosition |
| ); |
| } |
| |
| @Test |
| public final void test_InputParameter_NotInteger_2() throws Exception { |
| |
| String jpqlQuery = "SELECT e FROM Employee e WHERE ?1.1 = 'Pascal'"; |
| int startPosition = "SELECT e FROM Employee e WHERE ".length(); |
| int endPosition = "SELECT e FROM Employee e WHERE ?1.1".length(); |
| |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| |
| testHasOnlyOneProblem( |
| problems, |
| InputParameter_NotInteger, |
| startPosition, |
| endPosition |
| ); |
| } |
| |
| @Test |
| public final void test_InputParameter_SmallerThanOne_1() throws Exception { |
| |
| String jpqlQuery = "SELECT e FROM Employee e WHERE ?0 = 'Pascal'"; |
| int startPosition = "SELECT e FROM Employee e WHERE ".length(); |
| int endPosition = "SELECT e FROM Employee e WHERE ?0".length(); |
| |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| |
| testHasOnlyOneProblem( |
| problems, |
| InputParameter_SmallerThanOne, |
| startPosition, |
| endPosition |
| ); |
| } |
| |
| @Test |
| public final void test_InvalidQuery_01() throws Exception { |
| |
| String jpqlQuery = "delete aaa aaa a"; |
| |
| int startPosition1 = "delete ".length(); |
| int endPosition1 = "delete ".length(); |
| |
| int startPosition2 = "delete aaa aaa".length(); |
| int endPosition2 = "delete aaa aaa a".length(); |
| |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| |
| testHasOnlyTheseProblems( |
| problems, |
| new String[] { DeleteClause_FromMissing, DeleteClause_RangeVariableDeclarationMalformed }, |
| new int[] { startPosition1, startPosition2 }, |
| new int[] { endPosition1, endPosition2 } |
| ); |
| } |
| |
| @Test |
| public final void test_Join_InvalidIdentifier_01() throws Exception { |
| |
| String jpqlQuery = "SELECT r FROM Employee r LEFT OUTER JOIN r.phoneNumbers c WHERE c.phoneNumber = :major AND c.area = :name AND r.working = true"; |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| testHasNoProblems(problems); |
| } |
| |
| @Test |
| public final void test_Join_InvalidIdentifier_02() throws Exception { |
| |
| String jpqlQuery = "SELECT r FROM Employee r OUTER JOIN r.phoneNumbers c WHERE c.phoneNumber = :major AND c.area = :name AND r.working = true"; |
| int startPosition = "SELECT r FROM Employee r ".length(); |
| int endPosition = "SELECT r FROM Employee r OUTER JOIN".length(); |
| |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| |
| testHasOnlyOneProblem( |
| problems, |
| Join_InvalidIdentifier, |
| startPosition, |
| endPosition |
| ); |
| } |
| |
| @Test |
| public final void test_Join_InvalidIdentifier_03() throws Exception { |
| |
| String jpqlQuery = "SELECT r FROM Employee r OUTER INNER JOIN r.phoneNumbers c WHERE c.phoneNumber = :major AND c.area = :name AND r.working = true"; |
| int startPosition = "SELECT r FROM Employee r ".length(); |
| int endPosition = "SELECT r FROM Employee r OUTER INNER JOIN".length(); |
| |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| |
| testHasOnlyOneProblem( |
| problems, |
| Join_InvalidIdentifier, |
| startPosition, |
| endPosition |
| ); |
| } |
| |
| @Test |
| public final void test_Join_InvalidIdentifier_04() throws Exception { |
| |
| String jpqlQuery = "SELECT r FROM Employee r LEFT INNER JOIN r.phoneNumbers c WHERE c.phoneNumber = :major AND c.area = :name AND r.working = true"; |
| int startPosition = "SELECT r FROM Employee r ".length(); |
| int endPosition = "SELECT r FROM Employee r LEFT INNER JOIN".length(); |
| |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| |
| testHasOnlyOneProblem( |
| problems, |
| Join_InvalidIdentifier, |
| startPosition, |
| endPosition |
| ); |
| } |
| |
| @Test |
| public final void test_Join_InvalidIdentifier_05() throws Exception { |
| |
| String jpqlQuery = "SELECT r FROM Employee r LEFT OUTER INNER JOIN r.phoneNumbers c WHERE c.phoneNumber = :major AND c.area = :name AND r.working = true"; |
| int startPosition = "SELECT r FROM Employee r ".length(); |
| int endPosition = "SELECT r FROM Employee r LEFT OUTER INNER JOIN".length(); |
| |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| |
| testHasOnlyOneProblem( |
| problems, |
| Join_InvalidIdentifier, |
| startPosition, |
| endPosition |
| ); |
| } |
| |
| @Test |
| public final void test_Join_MissingIdentificationVariable_1() throws Exception { |
| |
| String jpqlQuery = "SELECT e FROM Employee e JOIN e.employees "; |
| int startPosition = jpqlQuery.length(); |
| int endPosition = startPosition; |
| |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| |
| testHasOnlyOneProblem( |
| problems, |
| Join_MissingIdentificationVariable, |
| startPosition, |
| endPosition |
| ); |
| } |
| |
| @Test |
| public final void test_Join_MissingIdentificationVariable_2() throws Exception { |
| |
| String jpqlQuery = "SELECT e FROM Employee e JOIN e.employees AS"; |
| int startPosition = "SELECT e FROM Employee e JOIN e.employees AS".length(); |
| int endPosition = startPosition; |
| |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| |
| testHasOnlyOneProblem( |
| problems, |
| Join_MissingIdentificationVariable, |
| startPosition, |
| endPosition |
| ); |
| } |
| |
| @Test |
| public final void test_Join_MissingIdentificationVariable_3() throws Exception { |
| |
| String jpqlQuery = "SELECT e FROM Employee e JOIN e.employees AS "; |
| int startPosition = jpqlQuery.length(); |
| int endPosition = startPosition; |
| |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| |
| testHasOnlyOneProblem( |
| problems, |
| Join_MissingIdentificationVariable, |
| startPosition, |
| endPosition |
| ); |
| } |
| |
| @Test |
| public final void test_Join_MissingJoinAssociationPath_1() throws Exception { |
| |
| String jpqlQuery = "SELECT e FROM Employee e JOIN "; |
| int startPosition = "SELECT e FROM Employee e JOIN ".length(); |
| int endPosition = startPosition; |
| |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| |
| testHasOnlyOneProblem( |
| problems, |
| Join_MissingJoinAssociationPath, |
| startPosition, |
| endPosition |
| ); |
| } |
| |
| @Test |
| public final void test_Join_MissingJoinAssociationPath_2() throws Exception { |
| |
| String jpqlQuery = "SELECT e FROM Employee e JOIN AS p"; |
| int startPosition = "SELECT e FROM Employee e JOIN ".length(); |
| int endPosition = startPosition; |
| |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| |
| testHasOnlyOneProblem( |
| problems, |
| Join_MissingJoinAssociationPath, |
| startPosition, |
| endPosition |
| ); |
| } |
| |
| @Test |
| public final void test_JoinFetch_MissingIdentificationVariable_1() throws Exception { |
| |
| String jpqlQuery = "SELECT e FROM Employee e JOIN e.employees "; |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| testDoesNotHaveProblem(problems, JoinFetch_MissingIdentificationVariable); |
| } |
| |
| @Test |
| public final void test_JoinFetch_MissingIdentificationVariable_2() throws Exception { |
| |
| String jpqlQuery = "SELECT e FROM Employee e JOIN FETCH e.employees AS"; |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| |
| if (isJoinFetchIdentifiable()) { |
| int startPosition = jpqlQuery.length(); |
| int endPosition = startPosition; |
| |
| testHasOnlyOneProblem( |
| problems, |
| JoinFetch_MissingIdentificationVariable, |
| startPosition, |
| endPosition |
| ); |
| } |
| else { |
| int startPosition = "SELECT e FROM Employee e JOIN FETCH e.employees ".length(); |
| int endPosition = jpqlQuery.length(); |
| |
| testHasOnlyOneProblem( |
| problems, |
| JoinFetch_InvalidIdentification, |
| startPosition, |
| endPosition |
| ); |
| } |
| } |
| |
| @Test |
| public final void test_JoinFetch_MissingIdentificationVariable_3() throws Exception { |
| |
| String jpqlQuery = "SELECT e FROM Employee e JOIN FETCH e.employees AS "; |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| |
| if (isJoinFetchIdentifiable()) { |
| int startPosition = jpqlQuery.length(); |
| int endPosition = startPosition; |
| |
| testHasOnlyOneProblem( |
| problems, |
| JoinFetch_MissingIdentificationVariable, |
| startPosition, |
| endPosition |
| ); |
| } |
| else { |
| int startPosition = "SELECT e FROM Employee e JOIN FETCH e.employees ".length(); |
| int endPosition = jpqlQuery.length(); |
| |
| testHasOnlyOneProblem( |
| problems, |
| JoinFetch_InvalidIdentification, |
| startPosition, |
| endPosition |
| ); |
| } |
| } |
| |
| @Test |
| public final void test_JoinFetch_MissingIdentificationVariable_4() throws Exception { |
| |
| String jpqlQuery = "SELECT e FROM Employee e JOIN FETCH e.employees AS emp"; |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| |
| if (isJoinFetchIdentifiable()) { |
| testDoesNotHaveProblem( |
| problems, |
| JoinFetch_MissingIdentificationVariable |
| ); |
| } |
| else { |
| int startPosition = "SELECT e FROM Employee e JOIN FETCH e.employees ".length(); |
| int endPosition = jpqlQuery.length(); |
| |
| testHasOnlyOneProblem( |
| problems, |
| JoinFetch_InvalidIdentification, |
| startPosition, |
| endPosition |
| ); |
| } |
| } |
| |
| @Test |
| public final void test_JoinFetch_MissingJoinAssociationPath_1() throws Exception { |
| |
| String jpqlQuery = "SELECT e FROM Employee e JOIN FETCH"; |
| int startPosition = "SELECT e FROM Employee e JOIN FETCH".length(); |
| int endPosition = startPosition; |
| |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| |
| testHasOnlyOneProblem( |
| problems, |
| JoinFetch_MissingJoinAssociationPath, |
| startPosition, |
| endPosition |
| ); |
| } |
| |
| @Test |
| public final void test_JoinFetch_MissingJoinAssociationPath_2() throws Exception { |
| |
| String jpqlQuery = "SELECT e FROM Employee e JOIN FETCH "; |
| int startPosition = "SELECT e FROM Employee e JOIN FETCH ".length(); |
| int endPosition = startPosition; |
| |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| |
| testHasOnlyOneProblem( |
| problems, |
| JoinFetch_MissingJoinAssociationPath, |
| startPosition, |
| endPosition |
| ); |
| } |
| |
| @Test |
| public final void test_JoinFetch_WrongClauseDeclaration() throws Exception { |
| |
| String jpqlQuery = "SELECT e FROM Employee e WHERE EXISTS(SELECT o FROM Order o JOIN FETCH o.stores)"; |
| int startPosition = "SELECT e FROM Employee e WHERE EXISTS(SELECT o FROM Order o ".length(); |
| int endPosition = jpqlQuery.length() - 1; |
| |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| |
| testHasOnlyOneProblem( |
| problems, |
| JoinFetch_WrongClauseDeclaration, |
| startPosition, |
| endPosition |
| ); |
| } |
| |
| @Test |
| public final void test_JPQLExpression_InvalidQuery_1() throws Exception { |
| |
| String jpqlQuery = ExpressionTools.EMPTY_STRING; |
| int startPosition = 0; |
| int endPosition = 0; |
| |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| |
| testHasOnlyOneProblem( |
| problems, |
| JPQLExpression_InvalidQuery, |
| startPosition, |
| endPosition |
| ); |
| } |
| |
| @Test |
| public final void test_JPQLExpression_InvalidQuery_2() throws Exception { |
| |
| String jpqlQuery = "S"; |
| int startPosition = 0; |
| int endPosition = 1; |
| |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| |
| testHasOnlyOneProblem( |
| problems, |
| JPQLExpression_InvalidQuery, |
| startPosition, |
| endPosition |
| ); |
| } |
| |
| @Test |
| public final void test_JPQLExpression_InvalidQuery_3() throws Exception { |
| |
| String jpqlQuery = "JPA version 2.0"; |
| int startPosition = 0; |
| int endPosition = jpqlQuery.length(); |
| |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| |
| testHasOnlyOneProblem( |
| problems, |
| JPQLExpression_InvalidQuery, |
| startPosition, |
| endPosition |
| ); |
| } |
| |
| @Test |
| public final void test_JPQLExpression_InvalidQuery_4() throws Exception { |
| |
| String jpqlQuery = "SELECT e FROM Employee e"; |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| testHasNoProblems(problems); |
| } |
| |
| @Test |
| public final void test_JPQLExpression_InvalidQuery_5() throws Exception { |
| |
| String jpqlQuery = "UPDATE Employee e SET e.salary = e.salary * 1.20"; |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| testHasNoProblems(problems); |
| } |
| |
| @Test |
| public final void test_JPQLExpression_InvalidQuery_6() throws Exception { |
| |
| String jpqlQuery = "DELETE FROM Employee e WHERE e.name = 'Pascal'"; |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| testHasNoProblems(problems); |
| } |
| |
| @Test |
| public final void test_JPQLExpression_UnknownEnding_1() throws Exception { |
| |
| String jpqlQuery = "SELECT e FROM Employee e"; |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| testHasNoProblems(problems); |
| } |
| |
| @Test |
| public final void test_JPQLExpression_UnknownEnding_2() throws Exception { |
| |
| String jpqlQuery = "SELECT e FROM Employee e FROM"; |
| int startPosition = "SELECT e FROM Employee e ".length(); |
| int endPosition = jpqlQuery.length(); |
| |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| |
| testHasOnlyOneProblem( |
| problems, |
| JPQLExpression_UnknownEnding, |
| startPosition, |
| endPosition |
| ); |
| } |
| |
| @Test |
| public final void test_KeyExpression_InvalidExpression() throws Exception { |
| |
| String jpqlQuery = "SELECT KEY(a.street) FROM Employee e JOIN e.addresses a"; |
| int startPosition = "SELECT KEY(".length(); |
| int endPosition = "SELECT KEY(a.street".length(); |
| |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| |
| testHasOnlyOneProblem( |
| problems, |
| KeyExpression_InvalidExpression, |
| startPosition, |
| endPosition |
| ); |
| } |
| |
| @Test |
| public final void test_KeyExpression_MissingExpression() throws Exception { |
| |
| String jpqlQuery = "SELECT KEY() FROM Employee e JOIN e.addresses a"; |
| int startPosition = "SELECT KEY(".length(); |
| int endPosition = startPosition; |
| |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| |
| testHasOnlyOneProblem( |
| problems, |
| KeyExpression_MissingExpression, |
| startPosition, |
| endPosition |
| ); |
| } |
| |
| @Test |
| public final void test_KeyExpression_MissingLeftParenthesis() throws Exception { |
| |
| String jpqlQuery = "SELECT KEY a) FROM Employee e JOIN e.addresses a"; |
| int startPosition = "SELECT KEY".length(); |
| int endPosition = startPosition; |
| |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| |
| testHasOnlyOneProblem( |
| problems, |
| KeyExpression_MissingLeftParenthesis, |
| startPosition, |
| endPosition |
| ); |
| } |
| |
| @Test |
| public final void test_KeyExpression_MissingRightParenthesis() throws Exception { |
| |
| String jpqlQuery = "SELECT KEY(a FROM Employee e JOIN e.addresses a"; |
| int startPosition = "SELECT KEY(a".length(); |
| int endPosition = startPosition; |
| |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| |
| testHasOnlyOneProblem( |
| problems, |
| KeyExpression_MissingRightParenthesis, |
| startPosition, |
| endPosition |
| ); |
| } |
| |
| @Test |
| public final void test_LengthExpression_InvalidExpression() throws Exception { |
| |
| String jpqlQuery = "SELECT e FROM Employee e WHERE LENGTH(ALL(SELECT d FROM Dept d)) = 2"; |
| int startPosition = "SELECT e FROM Employee e WHERE LENGTH(".length(); |
| int endPosition = "SELECT e FROM Employee e WHERE LENGTH(ALL(SELECT d FROM Dept d)".length(); |
| |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| |
| testHasOnlyOneProblem( |
| problems, |
| LengthExpression_InvalidExpression, |
| startPosition, |
| endPosition |
| ); |
| } |
| |
| @Test |
| public final void test_LengthExpression_MissingExpression() throws Exception { |
| |
| String jpqlQuery = "SELECT e FROM Employee e WHERE LENGTH() = 2"; |
| int startPosition = "SELECT e FROM Employee e WHERE LENGTH(".length(); |
| int endPosition = startPosition; |
| |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| |
| testHasOnlyOneProblem( |
| problems, |
| LengthExpression_MissingExpression, |
| startPosition, |
| endPosition |
| ); |
| } |
| |
| @Test |
| public final void test_LengthExpression_MissingLeftParenthesis() throws Exception { |
| |
| String jpqlQuery = "SELECT e FROM Employee e WHERE LENGTH e.name) = 2"; |
| int startPosition = "SELECT e FROM Employee e WHERE LENGTH".length(); |
| int endPosition = startPosition; |
| |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| |
| testHasOnlyOneProblem( |
| problems, |
| LengthExpression_MissingLeftParenthesis, |
| startPosition, |
| endPosition |
| ); |
| } |
| |
| @Test |
| public final void test_LengthExpression_MissingRightParenthesis() throws Exception { |
| |
| String jpqlQuery = "SELECT e FROM Employee e WHERE LENGTH(e.name = 2"; |
| int startPosition = "SELECT e FROM Employee e WHERE LENGTH(e.name".length(); |
| int endPosition = startPosition; |
| |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| |
| testHasOnlyOneProblem( |
| problems, |
| LengthExpression_MissingRightParenthesis, |
| startPosition, |
| endPosition |
| ); |
| } |
| |
| @Test |
| public final void test_LikeExpression_InvalidEscapeCharacter_1() throws Exception { |
| |
| String jpqlQuery = "SELECT e FROM Employee e WHERE e.name LIKE 'Pascal' ESCAPE 'C'"; |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| |
| testDoesNotHaveProblem( |
| problems, |
| LikeExpression_InvalidEscapeCharacter |
| ); |
| } |
| |
| @Test |
| public final void test_LikeExpression_InvalidEscapeCharacter_2() throws Exception { |
| |
| String jpqlQuery = "SELECT e FROM Employee e WHERE e.name LIKE 'Pascal' ESCAPE :name"; |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| |
| testDoesNotHaveProblem( |
| problems, |
| LikeExpression_InvalidEscapeCharacter |
| ); |
| } |
| |
| @Test |
| public final void test_LikeExpression_InvalidEscapeCharacter_3() throws Exception { |
| |
| String jpqlQuery = "SELECT e FROM Employee e WHERE e.name LIKE 'Pascal' ESCAPE 'CHAR'"; |
| int startPosition = "SELECT e FROM Employee e WHERE e.name LIKE 'Pascal' ESCAPE ".length(); |
| int endPosition = jpqlQuery.length(); |
| |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| |
| testHasProblem( |
| problems, |
| LikeExpression_InvalidEscapeCharacter, |
| startPosition, |
| endPosition |
| ); |
| } |
| |
| @Test |
| public final void test_LikeExpression_InvalidEscapeCharacter_4() throws Exception { |
| |
| String jpqlQuery = "SELECT e FROM Employee e WHERE e.name LIKE 'Pascal' ESCAPE UPPER('_')"; |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| |
| if (jpqlGrammar == EclipseLinkJPQLGrammar2_1.instance() || |
| jpqlGrammar == EclipseLinkJPQLGrammar2_2.instance() || |
| jpqlGrammar == EclipseLinkJPQLGrammar2_3.instance() || |
| jpqlGrammar == EclipseLinkJPQLGrammar2_4.instance() || |
| jpqlGrammar == EclipseLinkJPQLGrammar2_5.instance()) { |
| |
| testDoesNotHaveProblem( |
| problems, |
| LikeExpression_InvalidEscapeCharacter |
| ); |
| } |
| else { |
| int startPosition = "SELECT e FROM Employee e WHERE e.name LIKE 'Pascal' ESCAPE ".length(); |
| int endPosition = jpqlQuery.length(); |
| |
| testHasProblem( |
| problems, |
| LikeExpression_InvalidEscapeCharacter, |
| startPosition, |
| endPosition |
| ); |
| } |
| } |
| |
| @Test |
| public final void test_LikeExpression_MissingEscapeCharacter_1() throws Exception { |
| |
| String jpqlQuery = "SELECT e FROM Employee e WHERE e.name LIKE 'Pascal' ESCAPE"; |
| int startPosition = jpqlQuery.length(); |
| int endPosition = startPosition; |
| |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| |
| testHasOnlyOneProblem( |
| problems, |
| LikeExpression_MissingEscapeCharacter, |
| startPosition, |
| endPosition |
| ); |
| } |
| |
| @Test |
| public final void test_LikeExpression_MissingEscapeCharacter_2() throws Exception { |
| |
| String jpqlQuery = "SELECT e FROM Employee e WHERE e.name LIKE 'Pascal' ESCAPE "; |
| int startPosition = jpqlQuery.length(); |
| int endPosition = startPosition; |
| |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| |
| testHasOnlyOneProblem( |
| problems, |
| LikeExpression_MissingEscapeCharacter, |
| startPosition, |
| endPosition |
| ); |
| } |
| |
| @Test |
| public final void test_LikeExpression_MissingPatternValue_1() throws Exception { |
| |
| String jpqlQuery = "SELECT e FROM Employee e WHERE e.name LIKE"; |
| int startPosition = jpqlQuery.length(); |
| int endPosition = startPosition; |
| |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| |
| testHasOnlyOneProblem( |
| problems, |
| LikeExpression_MissingPatternValue, |
| startPosition, |
| endPosition |
| ); |
| } |
| |
| @Test |
| public final void test_LikeExpression_MissingPatternValue_2() throws Exception { |
| |
| String jpqlQuery = "SELECT e FROM Employee e WHERE e.name LIKE "; |
| int startPosition = jpqlQuery.length(); |
| int endPosition = startPosition; |
| |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| |
| testHasOnlyOneProblem( |
| problems, |
| LikeExpression_MissingPatternValue, |
| startPosition, |
| endPosition |
| ); |
| } |
| |
| @Test |
| public final void test_LikeExpression_MissingStringExpression() throws Exception { |
| |
| String jpqlQuery = "SELECT e FROM Employee e WHERE LIKE 'Pascal'"; |
| int startPosition = "SELECT e FROM Employee e WHERE ".length(); |
| int endPosition = startPosition; |
| |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| |
| testHasOnlyOneProblem( |
| problems, |
| LikeExpression_MissingStringExpression, |
| startPosition, |
| endPosition |
| ); |
| } |
| |
| @Test |
| public final void test_LocateExpression_InvalidFirstExpression() throws Exception { |
| |
| String jpqlQuery = "SELECT e FROM Employee e WHERE LOCATE(ALL(SELECT d FROM Dept d), 'JPQL', 2)"; |
| int startPosition = "SELECT e FROM Employee e WHERE LOCATE(".length(); |
| int endPosition = "SELECT e FROM Employee e WHERE LOCATE(ALL(SELECT d FROM Dept d)".length(); |
| |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| |
| testHasProblem( |
| problems, |
| LocateExpression_InvalidFirstExpression, |
| startPosition, |
| endPosition |
| ); |
| } |
| |
| @Test |
| public final void test_LocateExpression_InvalidSecondExpression() throws Exception { |
| |
| String jpqlQuery = "SELECT e FROM Employee e WHERE LOCATE('JPQL', ALL(SELECT d FROM Dept d), 2)"; |
| int startPosition = "SELECT e FROM Employee e WHERE LOCATE('JPQL', ".length(); |
| int endPosition = "SELECT e FROM Employee e WHERE LOCATE('JPQL', ALL(SELECT d FROM Dept d)".length(); |
| |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| |
| testHasProblem( |
| problems, |
| LocateExpression_InvalidSecondExpression, |
| startPosition, |
| endPosition |
| ); |
| } |
| |
| @Test |
| public final void test_LocateExpression_InvalidThirdExpression() throws Exception { |
| |
| String jpqlQuery = "SELECT e FROM Employee e WHERE LOCATE(e.name, 'JPQL', e)"; |
| int startPosition = "SELECT e FROM Employee e WHERE LOCATE(e.name, 'JPQL', ".length(); |
| int endPosition = startPosition + 1; |
| |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| |
| testHasProblem( |
| problems, |
| LocateExpression_InvalidThirdExpression, |
| startPosition, |
| endPosition |
| ); |
| } |
| |
| @Test |
| public final void test_LocateExpression_MissingFirstComma_1() throws Exception { |
| |
| String jpqlQuery = "SELECT e FROM Employee e WHERE LOCATE(e.name"; |
| |
| int startPosition = "SELECT e FROM Employee e WHERE LOCATE(e.name".length(); |
| int endPosition = startPosition; |
| |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| |
| testHasProblem( |
| problems, |
| LocateExpression_MissingFirstComma, |
| startPosition, |
| endPosition |
| ); |
| } |
| |
| @Test |
| public final void test_LocateExpression_MissingFirstComma_2() throws Exception { |
| |
| String jpqlQuery = "SELECT e FROM Employee e WHERE LOCATE(e.name e.age, 2 + e.startDate)"; |
| int startPosition = "SELECT e FROM Employee e WHERE LOCATE(e.name".length(); |
| int endPosition = startPosition; |
| |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| |
| testHasProblem( |
| problems, |
| LocateExpression_MissingFirstComma, |
| startPosition, |
| endPosition |
| ); |
| } |
| |
| @Test |
| public final void test_LocateExpression_MissingFirstExpression_1() throws Exception { |
| |
| String jpqlQuery = "SELECT e FROM Employee e WHERE LOCATE("; |
| int startPosition = "SELECT e FROM Employee e WHERE LOCATE(".length(); |
| int endPosition = startPosition; |
| |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| |
| testHasProblem( |
| problems, |
| LocateExpression_MissingFirstExpression, |
| startPosition, |
| endPosition |
| ); |
| } |
| |
| @Test |
| public final void test_LocateExpression_MissingFirstExpression_2() throws Exception { |
| |
| String jpqlQuery = "SELECT e FROM Employee e WHERE LOCATE(, e.age)"; |
| int startPosition = "SELECT e FROM Employee e WHERE LOCATE(".length(); |
| int endPosition = startPosition; |
| |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| |
| testHasProblem( |
| problems, |
| LocateExpression_MissingFirstExpression, |
| startPosition, |
| endPosition |
| ); |
| } |
| |
| @Test |
| public final void test_LocateExpression_MissingFirstSecondExpression() throws Exception { |
| |
| String jpqlQuery = "SELECT e FROM Employee e WHERE LOCATE(, "; |
| |
| int startPosition1 = "SELECT e FROM Employee e WHERE LOCATE(".length(); |
| int endPosition1 = startPosition1; |
| |
| int startPosition2 = "SELECT e FROM Employee e WHERE LOCATE(, ".length(); |
| int endPosition2 = startPosition2; |
| |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| |
| testHasProblems( |
| problems, |
| new String[] { LocateExpression_MissingFirstExpression, |
| LocateExpression_MissingSecondExpression }, |
| new int[] { startPosition1, startPosition2 }, |
| new int[] { endPosition1, endPosition2 } |
| ); |
| } |
| |
| @Test |
| public final void test_LocateExpression_MissingLeftParenthesis() throws Exception { |
| |
| String jpqlQuery = "SELECT e FROM Employee e WHERE LOCATE e.name, e.age)"; |
| int startPosition = "SELECT e FROM Employee e WHERE LOCATE".length(); |
| int endPosition = startPosition; |
| |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| |
| testHasProblem( |
| problems, |
| LocateExpression_MissingLeftParenthesis, |
| startPosition, |
| endPosition |
| ); |
| } |
| |
| @Test |
| public final void test_LocateExpression_MissingRightParenthesis() throws Exception { |
| |
| String jpqlQuery = "SELECT e FROM Employee e WHERE LOCATE(e.name, e.age"; |
| int startPosition = jpqlQuery.length(); |
| int endPosition = startPosition; |
| |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| |
| testHasProblem( |
| problems, |
| LocateExpression_MissingRightParenthesis, |
| startPosition, |
| endPosition |
| ); |
| } |
| |
| @Test |
| public final void test_LocateExpression_MissingSecondComma() throws Exception { |
| |
| String jpqlQuery = "SELECT e FROM Employee e WHERE LOCATE(e.name, e.age 2 + e.startDate)"; |
| int startPosition = "SELECT e FROM Employee e WHERE LOCATE(e.name, e.age".length(); |
| int endPosition = startPosition; |
| |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| |
| testHasProblem( |
| problems, |
| LocateExpression_MissingSecondComma, |
| startPosition, |
| endPosition |
| ); |
| } |
| |
| @Test |
| public final void test_LocateExpression_MissingSecondExpression_1() throws Exception { |
| |
| String jpqlQuery = "SELECT e FROM Employee e WHERE LOCATE(e.name,"; |
| int startPosition = "SELECT e FROM Employee e WHERE LOCATE(e.name,".length(); |
| int endPosition = startPosition; |
| |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| |
| testHasProblem( |
| problems, |
| LocateExpression_MissingSecondExpression, |
| startPosition, |
| endPosition |
| ); |
| } |
| |
| @Test |
| public final void test_LocateExpression_MissingSecondExpression_2() throws Exception { |
| |
| String jpqlQuery = "SELECT e FROM Employee e WHERE LOCATE(e.name, "; |
| int startPosition = "SELECT e FROM Employee e WHERE LOCATE(e.name, ".length(); |
| int endPosition = startPosition; |
| |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| |
| testHasProblem( |
| problems, |
| LocateExpression_MissingSecondExpression, |
| startPosition, |
| endPosition |
| ); |
| } |
| |
| @Test |
| public final void test_LocateExpression_MissingThirdExpression_1() throws Exception { |
| |
| String jpqlQuery = "SELECT e FROM Employee e WHERE LOCATE(e.name, e.age,"; |
| int startPosition = jpqlQuery.length(); |
| int endPosition = startPosition; |
| |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| |
| testHasProblem( |
| problems, |
| LocateExpression_MissingThirdExpression, |
| startPosition, |
| endPosition |
| ); |
| } |
| |
| @Test |
| public final void test_LocateExpression_MissingThirdExpression_2() throws Exception { |
| |
| String jpqlQuery = "SELECT e FROM Employee e WHERE LOCATE(e.name, e.age, "; |
| int startPosition = jpqlQuery.length(); |
| int endPosition = startPosition; |
| |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| |
| testHasProblem( |
| problems, |
| LocateExpression_MissingThirdExpression, |
| startPosition, |
| endPosition |
| ); |
| } |
| |
| @Test |
| public final void test_LocateExpression_MissingThirdExpression_3() throws Exception { |
| |
| String jpqlQuery = "SELECT e FROM Employee e WHERE LOCATE(e.name, e.age, )"; |
| int startPosition = jpqlQuery.length() - 1; |
| int endPosition = startPosition; |
| |
| List<JPQLQueryProblem> problems = validate(jpqlQuery, buildFormatter_4()); |
| |
| testHasProblem( |
| problems, |
| LocateExpression_MissingThirdExpression, |
| startPosition, |
| endPosition |
| ); |
| } |
| |
| @Test |
| public final void test_LogicalExpression_InvalidLeftExpression() throws Exception { |
| |
| String jpqlQuery = "SELECT e FROM Employee e WHERE LENGTH(e.name) AND e.name = 'JPQL'"; |
| int startPosition = "SELECT e FROM Employee e WHERE ".length(); |
| int endPosition = "SELECT e FROM Employee e WHERE LENGTH(e.name)".length(); |
| |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| |
| testHasOnlyOneProblem( |
| problems, |
| LogicalExpression_InvalidLeftExpression, |
| startPosition, |
| endPosition |
| ); |
| } |
| |
| @Test |
| public final void test_LogicalExpression_InvalidRightExpression() throws Exception { |
| |
| String jpqlQuery = "SELECT e FROM Employee e WHERE e.name = 'JPQL' AND LENGTH(e.name)"; |
| int startPosition = "SELECT e FROM Employee e WHERE e.name = 'JPQL' AND ".length(); |
| int endPosition = jpqlQuery.length(); |
| |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| |
| testHasOnlyOneProblem( |
| problems, |
| LogicalExpression_InvalidRightExpression, |
| startPosition, |
| endPosition |
| ); |
| } |
| |
| @Test |
| public final void test_LogicalExpression_MissingLeftExpression() throws Exception { |
| |
| String jpqlQuery = "SELECT e FROM Employee e WHERE AND e.name = 'JPQL'"; |
| int startPosition = "SELECT e FROM Employee e WHERE ".length(); |
| int endPosition = startPosition; |
| |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| |
| testHasOnlyOneProblem( |
| problems, |
| LogicalExpression_MissingLeftExpression, |
| startPosition, |
| endPosition |
| ); |
| } |
| |
| @Test |
| public final void test_LogicalExpression_MissingRightExpression_1() throws Exception { |
| |
| String jpqlQuery = "SELECT e FROM Employee e WHERE e.name = 'JPQL' AND"; |
| int startPosition = jpqlQuery.length(); |
| int endPosition = startPosition; |
| |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| |
| testHasOnlyOneProblem( |
| problems, |
| LogicalExpression_MissingRightExpression, |
| startPosition, |
| endPosition |
| ); |
| } |
| |
| @Test |
| public final void test_LogicalExpression_MissingRightExpression_2() throws Exception { |
| |
| String jpqlQuery = "SELECT e FROM Employee e WHERE e.name = 'JPQL' AND "; |
| |
| int startPosition = jpqlQuery.length(); |
| int endPosition = startPosition; |
| |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| |
| testHasOnlyOneProblem( |
| problems, |
| LogicalExpression_MissingRightExpression, |
| startPosition, |
| endPosition |
| ); |
| } |
| |
| @Test |
| public final void test_LowerExpression_InvalidExpression() throws Exception { |
| |
| String jpqlQuery = "SELECT e FROM Employee e WHERE LOWER(ALL(SELECT d FROM Dept d)) = 'PASCAL'"; |
| int startPosition = "SELECT e FROM Employee e WHERE LOWER(".length(); |
| int endPosition = "SELECT e FROM Employee e WHERE LOWER(ALL(SELECT d FROM Dept d)".length(); |
| |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| |
| testHasOnlyOneProblem( |
| problems, |
| LowerExpression_InvalidExpression, |
| startPosition, |
| endPosition |
| ); |
| } |
| |
| @Test |
| public final void test_LowerExpression_MissingExpression() throws Exception { |
| |
| String jpqlQuery = "SELECT e FROM Employee e WHERE LOWER() = 'PASCAL'"; |
| int startPosition = "SELECT e FROM Employee e WHERE LOWER(".length(); |
| int endPosition = startPosition; |
| |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| |
| testHasOnlyOneProblem( |
| problems, |
| LowerExpression_MissingExpression, |
| startPosition, |
| endPosition |
| ); |
| } |
| |
| @Test |
| public final void test_LowerExpression_MissingLeftParenthesis() throws Exception { |
| |
| String jpqlQuery = "SELECT e FROM Employee e WHERE LOWER e.name) = 'PASCAL'"; |
| int startPosition = "SELECT e FROM Employee e WHERE LOWER".length(); |
| int endPosition = startPosition; |
| |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| |
| testHasOnlyOneProblem( |
| problems, |
| LowerExpression_MissingLeftParenthesis, |
| startPosition, |
| endPosition |
| ); |
| } |
| |
| @Test |
| public final void test_LowerExpression_MissingRightParenthesis() throws Exception { |
| |
| String jpqlQuery = "SELECT e FROM Employee e WHERE LOWER(e.name = 'PASCAL'"; |
| int startPosition = "SELECT e FROM Employee e WHERE LOWER(e.name".length(); |
| int endPosition = startPosition; |
| |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| |
| testHasOnlyOneProblem( |
| problems, |
| LowerExpression_MissingRightParenthesis, |
| startPosition, |
| endPosition |
| ); |
| } |
| |
| @Test |
| public final void test_MaxFunction_InvalidExpression() throws Exception { |
| |
| String jpqlQuery = "SELECT MAX(e) FROM Employee e"; |
| int startPosition = "SELECT MAX(".length(); |
| int endPosition = "SELECT MAX(e".length(); |
| |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| |
| testHasOnlyOneProblem( |
| problems, |
| MaxFunction_InvalidExpression, |
| startPosition, |
| endPosition |
| ); |
| } |
| |
| @Test |
| public final void test_MaxFunction_MissingExpression_1() throws Exception { |
| |
| String jpqlQuery = "SELECT MAX() FROM Employee e"; |
| int startPosition = "SELECT MAX(".length(); |
| int endPosition = startPosition; |
| |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| |
| testHasOnlyOneProblem( |
| problems, |
| MaxFunction_MissingExpression, |
| startPosition, |
| endPosition |
| ); |
| } |
| |
| @Test |
| public final void test_MaxFunction_MissingExpression_2() throws Exception { |
| |
| String jpqlQuery = "SELECT MAX(DISTINCT) FROM Employee e"; |
| int startPosition = "SELECT MAX(DISTINCT".length(); |
| int endPosition = startPosition; |
| |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| |
| testHasOnlyOneProblem( |
| problems, |
| MaxFunction_MissingExpression, |
| startPosition, |
| endPosition |
| ); |
| } |
| |
| @Test |
| public final void test_MaxFunction_MissingExpression_3() throws Exception { |
| |
| String jpqlQuery = "SELECT MAX(DISTINCT ) FROM Employee e"; |
| int startPosition = "SELECT MAX(DISTINCT ".length(); |
| int endPosition = startPosition; |
| |
| List<JPQLQueryProblem> problems = validate(jpqlQuery, buildFormatter_2()); |
| |
| testHasOnlyOneProblem( |
| problems, |
| MaxFunction_MissingExpression, |
| startPosition, |
| endPosition |
| ); |
| } |
| |
| @Test |
| public final void test_MaxFunction_MissingLeftParenthesis_1() throws Exception { |
| |
| String jpqlQuery = "SELECT MAX e.age) FROM Employee e"; |
| int startPosition = "SELECT MAX".length(); |
| int endPosition = startPosition; |
| |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| |
| testHasOnlyOneProblem( |
| problems, |
| MaxFunction_MissingLeftParenthesis, |
| startPosition, |
| endPosition |
| ); |
| } |
| |
| @Test |
| public final void test_MaxFunction_MissingLeftParenthesis_2() throws Exception { |
| |
| String jpqlQuery = "SELECT MAX DISTINCT e.age) FROM Employee e"; |
| int startPosition = "SELECT MAX".length(); |
| int endPosition = startPosition; |
| |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| |
| testHasOnlyOneProblem( |
| problems, |
| MaxFunction_MissingLeftParenthesis, |
| startPosition, |
| endPosition |
| ); |
| } |
| |
| @Test |
| public final void test_MaxFunction_MissingRightParenthesis() throws Exception { |
| |
| String jpqlQuery = "SELECT MAX(DISTINCT e.age FROM Employee e"; |
| int startPosition = "SELECT MAX(DISTINCT e.age".length(); |
| int endPosition = startPosition; |
| |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| |
| testHasOnlyOneProblem( |
| problems, |
| MaxFunction_MissingRightParenthesis, |
| startPosition, |
| endPosition |
| ); |
| } |
| |
| @Test |
| public final void test_MinFunction_InvalidExpression() throws Exception { |
| |
| String jpqlQuery = "SELECT MIN(e) FROM Employee e"; |
| int startPosition = "SELECT MIN(".length(); |
| int endPosition = "SELECT MIN(e".length(); |
| |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| |
| testHasOnlyOneProblem( |
| problems, |
| MinFunction_InvalidExpression, |
| startPosition, |
| endPosition |
| ); |
| } |
| |
| @Test |
| public final void test_MinFunction_MissingExpression_1() throws Exception { |
| |
| String jpqlQuery = "SELECT MIN() FROM Employee e"; |
| int startPosition = "SELECT MIN(".length(); |
| int endPosition = startPosition; |
| |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| |
| testHasOnlyOneProblem( |
| problems, |
| MinFunction_MissingExpression, |
| startPosition, |
| endPosition |
| ); |
| } |
| |
| @Test |
| public final void test_MinFunction_MissingExpression_2() throws Exception { |
| |
| String jpqlQuery = "SELECT MIN(DISTINCT) FROM Employee e"; |
| int startPosition = "SELECT MIN(DISTINCT".length(); |
| int endPosition = startPosition; |
| |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| |
| testHasOnlyOneProblem( |
| problems, |
| MinFunction_MissingExpression, |
| startPosition, |
| endPosition |
| ); |
| } |
| |
| @Test |
| public final void test_MinFunction_MissingExpression_3() throws Exception { |
| |
| String jpqlQuery = "SELECT MIN(DISTINCT ) FROM Employee e"; |
| int startPosition = "SELECT MIN(DISTINCT ".length(); |
| int endPosition = startPosition; |
| |
| List<JPQLQueryProblem> problems = validate(jpqlQuery, buildFormatter_2()); |
| |
| testHasOnlyOneProblem( |
| problems, |
| MinFunction_MissingExpression, |
| startPosition, |
| endPosition |
| ); |
| } |
| |
| @Test |
| public final void test_MinFunction_MissingLeftParenthesis_1() throws Exception { |
| |
| String jpqlQuery = "SELECT MIN e.age) FROM Employee e"; |
| int startPosition = "SELECT MIN".length(); |
| int endPosition = startPosition; |
| |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| |
| testHasOnlyOneProblem( |
| problems, |
| MinFunction_MissingLeftParenthesis, |
| startPosition, |
| endPosition |
| ); |
| } |
| |
| @Test |
| public final void test_MinFunction_MissingLeftParenthesis_2() throws Exception { |
| |
| String jpqlQuery = "SELECT MIN DISTINCT e.age) FROM Employee e"; |
| int startPosition = "SELECT MIN".length(); |
| int endPosition = startPosition; |
| |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| |
| testHasOnlyOneProblem( |
| problems, |
| MinFunction_MissingLeftParenthesis, |
| startPosition, |
| endPosition |
| ); |
| } |
| |
| @Test |
| public final void test_MinFunction_MissingRightParenthesis() throws Exception { |
| |
| String jpqlQuery = "SELECT MIN(DISTINCT e.age FROM Employee e"; |
| int startPosition = "SELECT MIN(DISTINCT e.age".length(); |
| int endPosition = startPosition; |
| |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| |
| testHasOnlyOneProblem( |
| problems, |
| MinFunction_MissingRightParenthesis, |
| startPosition, |
| endPosition |
| ); |
| } |
| |
| @Test |
| public final void test_ModExpression_InvalidFirstExpression() throws Exception { |
| |
| String jpqlQuery = "SELECT e FROM Employee e WHERE MOD(ALL(SELECT d FROM Dept d), e.age)"; |
| int startPosition = "SELECT e FROM Employee e WHERE MOD(".length(); |
| int endPosition = "SELECT e FROM Employee e WHERE MOD(ALL(SELECT d FROM Dept d)".length(); |
| |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| |
| testHasProblem( |
| problems, |
| ModExpression_InvalidFirstExpression, |
| startPosition, |
| endPosition |
| ); |
| } |
| |
| @Test |
| public final void test_ModExpression_InvalidSecondExpression() throws Exception { |
| |
| String jpqlQuery = "SELECT e FROM Employee e WHERE MOD(e.name, ALL(SELECT d FROM Dept d))"; |
| int startPosition = "SELECT e FROM Employee e WHERE MOD(e.name, ".length(); |
| int endPosition = "SELECT e FROM Employee e WHERE MOD(e.name, ALL(SELECT d FROM Dept d)".length(); |
| |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| |
| testHasProblem( |
| problems, |
| ModExpression_InvalidSecondExpression, |
| startPosition, |
| endPosition |
| ); |
| } |
| |
| @Test |
| public final void test_ModExpression_MissingComma_1() throws Exception { |
| |
| String jpqlQuery = "SELECT e FROM Employee e WHERE MOD(e.name"; |
| int startPosition = jpqlQuery.length(); |
| int endPosition = startPosition; |
| |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| |
| testHasProblem( |
| problems, |
| ModExpression_MissingComma, |
| startPosition, |
| endPosition |
| ); |
| } |
| |
| @Test |
| public final void test_ModExpression_MissingComma_2() throws Exception { |
| |
| String jpqlQuery = "SELECT e FROM Employee e WHERE MOD(e.name e.age)"; |
| int startPosition = "SELECT e FROM Employee e WHERE MOD(e.name".length(); |
| int endPosition = startPosition; |
| |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| |
| testHasProblem( |
| problems, |
| ModExpression_MissingComma, |
| startPosition, |
| endPosition |
| ); |
| } |
| |
| @Test |
| public final void test_ModExpression_MissingFirstExpression() throws Exception { |
| |
| String jpqlQuery = "SELECT e FROM Employee e WHERE MOD(, e.age)"; |
| int startPosition = "SELECT e FROM Employee e WHERE MOD(".length(); |
| int endPosition = startPosition; |
| |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| |
| testHasProblem( |
| problems, |
| ModExpression_MissingFirstExpression, |
| startPosition, |
| endPosition |
| ); |
| } |
| |
| @Test |
| public final void test_ModExpression_MissingLeftParenthesis_1() throws Exception { |
| |
| String jpqlQuery = "SELECT e FROM Employee e WHERE MOD"; |
| int startPosition = jpqlQuery.length(); |
| int endPosition = startPosition; |
| |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| |
| testHasProblem( |
| problems, |
| ModExpression_MissingLeftParenthesis, |
| startPosition, |
| endPosition |
| ); |
| } |
| |
| @Test |
| public final void test_ModExpression_MissingLeftParenthesis_2() throws Exception { |
| |
| String jpqlQuery = "SELECT e FROM Employee e WHERE MOD e.name, e.age)"; |
| int startPosition = "SELECT e FROM Employee e WHERE MOD".length(); |
| int endPosition = startPosition; |
| |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| |
| testHasProblem( |
| problems, |
| ModExpression_MissingLeftParenthesis, |
| startPosition, |
| endPosition |
| ); |
| } |
| |
| @Test |
| public final void test_ModExpression_MissingRightParenthesis() throws Exception { |
| |
| String jpqlQuery = "SELECT e FROM Employee e WHERE MOD(e.name, e.age"; |
| int startPosition = jpqlQuery.length(); |
| int endPosition = startPosition; |
| |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| |
| testHasProblem( |
| problems, |
| ModExpression_MissingRightParenthesis, |
| startPosition, |
| endPosition |
| ); |
| } |
| |
| @Test |
| public final void test_ModExpression_MissingSecondExpression_1() throws Exception { |
| |
| String jpqlQuery = "SELECT e FROM Employee e WHERE MOD(e.name,"; |
| int startPosition = jpqlQuery.length(); |
| int endPosition = startPosition; |
| |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| |
| testHasProblem( |
| problems, |
| ModExpression_MissingSecondExpression, |
| startPosition, |
| endPosition |
| ); |
| } |
| |
| @Test |
| public final void test_ModExpression_MissingSecondExpression_2() throws Exception { |
| |
| String jpqlQuery = "SELECT e FROM Employee e WHERE MOD(e.name, "; |
| int startPosition = jpqlQuery.length(); |
| int endPosition = startPosition; |
| |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| |
| testHasProblem( |
| problems, |
| ModExpression_MissingSecondExpression, |
| startPosition, |
| endPosition |
| ); |
| } |
| |
| @Test |
| public final void test_ModExpression_MissingSecondExpression_3() throws Exception { |
| |
| String jpqlQuery = "SELECT e FROM Employee e WHERE MOD(e.name, )"; |
| int startPosition = jpqlQuery.length() - 1; |
| int endPosition = startPosition; |
| |
| List<JPQLQueryProblem> problems = validate(jpqlQuery, buildFormatter_5()); |
| |
| testHasProblem( |
| problems, |
| ModExpression_MissingSecondExpression, |
| startPosition, |
| endPosition |
| ); |
| } |
| |
| @Test |
| public final void test_NotExpression_MissingExpression_1() throws Exception { |
| |
| String jpqlQuery = "SELECT e FROM Employee e WHERE NOT"; |
| int startPosition = jpqlQuery.length(); |
| int endPosition = startPosition; |
| |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| |
| testHasOnlyOneProblem( |
| problems, |
| NotExpression_MissingExpression, |
| startPosition, |
| endPosition |
| ); |
| } |
| |
| @Test |
| public final void test_NotExpression_MissingExpression_2() throws Exception { |
| |
| String jpqlQuery = "SELECT e FROM Employee e WHERE NOT "; |
| int startPosition = jpqlQuery.length(); |
| int endPosition = startPosition; |
| |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| |
| testHasOnlyOneProblem( |
| problems, |
| NotExpression_MissingExpression, |
| startPosition, |
| endPosition |
| ); |
| } |
| |
| @Test |
| public final void test_NullIfExpression_InvalidFirstExpression() throws Exception { |
| |
| String jpqlQuery = "SELECT NULLIF(e, 4 + e.age) FROM Employee e"; |
| int startPosition = "SELECT NULLIF(".length(); |
| int endPosition = "SELECT NULLIF(e".length(); |
| |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| |
| testHasOnlyOneProblem( |
| problems, |
| NullIfExpression_InvalidFirstExpression, |
| startPosition, |
| endPosition |
| ); |
| } |
| |
| @Test |
| public final void test_NullIfExpression_InvalidSecondExpression() throws Exception { |
| |
| String jpqlQuery = "SELECT NULLIF('JPQL', e) FROM Employee e"; |
| int startPosition = "SELECT NULLIF('JPQL', ".length(); |
| int endPosition = "SELECT NULLIF('JPQL', e".length(); |
| |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| |
| testHasOnlyOneProblem( |
| problems, |
| NullIfExpression_InvalidSecondExpression, |
| startPosition, |
| endPosition |
| ); |
| } |
| |
| @Test |
| public final void test_NullIfExpression_MissingComma() throws Exception { |
| |
| String jpqlQuery = "SELECT NULLIF('JPQL' 4 + e.age) FROM Employee e"; |
| int startPosition = "SELECT NULLIF('JPQL'".length(); |
| int endPosition = startPosition; |
| |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| |
| testHasOnlyOneProblem( |
| problems, |
| NullIfExpression_MissingComma, |
| startPosition, |
| endPosition |
| ); |
| } |
| |
| @Test |
| public final void test_NullIfExpression_MissingFirstExpression_1() throws Exception { |
| |
| String jpqlQuery = "SELECT NULLIF( FROM Employee e"; |
| int startPosition = "SELECT NULLIF(".length(); |
| int endPosition = startPosition; |
| |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| |
| testHasOnlyOneProblem( |
| problems, |
| NullIfExpression_MissingFirstExpression, |
| startPosition, |
| endPosition |
| ); |
| } |
| |
| @Test |
| public final void test_NullIfExpression_MissingFirstExpression_2() throws Exception { |
| |
| String jpqlQuery = "SELECT NULLIF(, 4 + e.age) FROM Employee e"; |
| int startPosition = "SELECT NULLIF(".length(); |
| int endPosition = startPosition; |
| |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| |
| testHasOnlyOneProblem( |
| problems, |
| NullIfExpression_MissingFirstExpression, |
| startPosition, |
| endPosition |
| ); |
| } |
| |
| @Test |
| public final void test_NullIfExpression_MissingLeftParenthesis() throws Exception { |
| |
| String jpqlQuery = "SELECT NULLIF 'JPQL', 4 + e.age) FROM Employee e"; |
| int startPosition = "SELECT NULLIF".length(); |
| int endPosition = startPosition; |
| |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| |
| testHasOnlyOneProblem( |
| problems, |
| NullIfExpression_MissingLeftParenthesis, |
| startPosition, |
| endPosition |
| ); |
| } |
| |
| @Test |
| public final void test_NullIfExpression_MissingRightParenthesis() throws Exception { |
| |
| String jpqlQuery = "SELECT NULLIF('JPQL', 4 + e.age FROM Employee e"; |
| int startPosition = "SELECT NULLIF('JPQL', 4 + e.age".length(); |
| int endPosition = startPosition; |
| |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| |
| testHasOnlyOneProblem( |
| problems, |
| NullIfExpression_MissingRightParenthesis, |
| startPosition, |
| endPosition |
| ); |
| } |
| |
| @Test |
| public final void test_NullIfExpression_MissingSecondExpression_1() throws Exception { |
| |
| String jpqlQuery = "SELECT NULLIF('JPQL', FROM Employee e"; |
| int startPosition = "SELECT NULLIF('JPQL', ".length(); |
| int endPosition = startPosition; |
| |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| |
| testHasOnlyOneProblem( |
| problems, |
| NullIfExpression_MissingSecondExpression, |
| startPosition, |
| endPosition |
| ); |
| } |
| |
| @Test |
| public final void test_NullIfExpression_MissingSecondExpression_2() throws Exception { |
| |
| String jpqlQuery = "SELECT NULLIF('JPQL',) FROM Employee e"; |
| int startPosition = "SELECT NULLIF('JPQL',".length(); |
| int endPosition = startPosition; |
| |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| |
| testHasOnlyOneProblem( |
| problems, |
| NullIfExpression_MissingSecondExpression, |
| startPosition, |
| endPosition |
| ); |
| } |
| |
| @Test |
| public final void test_NullIfExpression_MissingSecondExpression_3() throws Exception { |
| |
| String jpqlQuery = "SELECT NULLIF('JPQL', ) FROM Employee e"; |
| int startPosition = "SELECT NULLIF('JPQL', ".length(); |
| int endPosition = startPosition; |
| |
| List<JPQLQueryProblem> problems = validate(jpqlQuery, buildFormatter_6()); |
| |
| testHasOnlyOneProblem( |
| problems, |
| NullIfExpression_MissingSecondExpression, |
| startPosition, |
| endPosition |
| ); |
| } |
| |
| @Test |
| public final void test_NumericLiteral_Invalid_01() throws Exception { |
| |
| String jpqlQuery = "SELECT e FROM Employee e WHERE e.age > 1.2FF"; |
| int startPosition = "SELECT e FROM Employee e WHERE e.age > ".length(); |
| int endPosition = jpqlQuery.length(); |
| |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| |
| testHasOnlyOneProblem( |
| problems, |
| NumericLiteral_Invalid, |
| startPosition, |
| endPosition |
| ); |
| } |
| |
| @Test |
| public final void test_NumericLiteral_Invalid_02() throws Exception { |
| |
| String jpqlQuery = "SELECT e FROM Employee e WHERE e.age > 2"; |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| |
| testDoesNotHaveProblem( |
| problems, |
| NumericLiteral_Invalid |
| ); |
| } |
| |
| @Test |
| public final void test_NumericLiteral_Invalid_03() throws Exception { |
| |
| String jpqlQuery = "SELECT e FROM Employee e WHERE e.age > 2.2"; |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| |
| testDoesNotHaveProblem( |
| problems, |
| NumericLiteral_Invalid |
| ); |
| } |
| |
| @Test |
| public final void test_NumericLiteral_Invalid_04() throws Exception { |
| |
| String jpqlQuery = "SELECT e FROM Employee e WHERE e.age > 2.2D"; |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| |
| testDoesNotHaveProblem( |
| problems, |
| NumericLiteral_Invalid |
| ); |
| } |
| |
| @Test |
| public final void test_NumericLiteral_Invalid_05() throws Exception { |
| |
| String jpqlQuery = "SELECT e FROM Employee e WHERE e.age > 2.2E10"; |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| |
| testDoesNotHaveProblem( |
| problems, |
| NumericLiteral_Invalid |
| ); |
| } |
| |
| @Test |
| public final void test_NumericLiteral_Invalid_06() throws Exception { |
| |
| String jpqlQuery = "SELECT e FROM Employee e WHERE e.age > 2.2E-10"; |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| |
| testDoesNotHaveProblem( |
| problems, |
| NumericLiteral_Invalid |
| ); |
| } |
| |
| @Test |
| public final void test_NumericLiteral_Invalid_07() throws Exception { |
| |
| String jpqlQuery = "SELECT e FROM Employee e WHERE e.age > 0.34999999999999997779553950749686919152736663818359375"; |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| |
| testDoesNotHaveProblem( |
| problems, |
| NumericLiteral_Invalid |
| ); |
| } |
| |
| @Test |
| public final void test_NumericLiteral_Invalid_08() throws Exception { |
| |
| String jpqlQuery = "SELECT e FROM Employee e WHERE e.age > 2.2F"; |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| |
| testDoesNotHaveProblem( |
| problems, |
| NumericLiteral_Invalid |
| ); |
| } |
| |
| @Test |
| public final void test_NumericLiteral_Invalid_09() throws Exception { |
| |
| String jpqlQuery = "SELECT e FROM Employee e WHERE e.age > 2L"; |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| testDoesNotHaveProblem(problems, NumericLiteral_Invalid); |
| } |
| |
| @Test |
| public final void test_NumericLiteral_Invalid_10() throws Exception { |
| |
| String jpqlQuery = "SELECT e FROM Employee e WHERE e.age > 2l"; |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| testDoesNotHaveProblem(problems, NumericLiteral_Invalid); |
| } |
| |
| @Test |
| public final void test_NumericLiteral_Invalid_11() throws Exception { |
| |
| String jpqlQuery = "SELECT e FROM Employee e WHERE e.age > 2D"; |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| testDoesNotHaveProblem(problems, NumericLiteral_Invalid); |
| } |
| |
| @Test |
| public final void test_NumericLiteral_Invalid_12() throws Exception { |
| |
| String jpqlQuery = "SELECT e FROM Employee e WHERE e.age > 2d"; |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| testDoesNotHaveProblem(problems, NumericLiteral_Invalid); |
| } |
| |
| @Test |
| public final void test_NumericLiteral_Invalid_13() throws Exception { |
| |
| String jpqlQuery = "SELECT e FROM Employee e WHERE e.age > 2.2d"; |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| testDoesNotHaveProblem(problems, NumericLiteral_Invalid); |
| } |
| |
| @Test |
| public final void test_NumericLiteral_Invalid_14() throws Exception { |
| |
| String jpqlQuery = "SELECT e FROM Employee e WHERE e.age > .2d"; |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| testDoesNotHaveProblem(problems, NumericLiteral_Invalid); |
| } |
| |
| @Test |
| public final void test_NumericLiteral_Invalid_15() throws Exception { |
| |
| String jpqlQuery = "SELECT e FROM Employee e WHERE e.age > 0x1.02ADP+2"; |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| testDoesNotHaveProblem(problems, NumericLiteral_Invalid); |
| } |
| |
| @Test |
| public final void test_NumericLiteral_Invalid_16() throws Exception { |
| |
| String jpqlQuery = "SELECT e FROM Employee e WHERE e.age > 0x1.02ADP+2d"; |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| testDoesNotHaveProblem(problems, NumericLiteral_Invalid); |
| } |
| |
| @Test |
| public final void test_ObjectExpression_InvalidExpression() throws Exception { |
| |
| String jpqlQuery = "SELECT OBJECT(e.name) FROM Employee e"; |
| int startPosition = "SELECT OBJECT(".length(); |
| int endPosition = "SELECT OBJECT(e.name".length(); |
| |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| |
| testHasOnlyOneProblem( |
| problems, |
| ObjectExpression_InvalidExpression, |
| startPosition, |
| endPosition |
| ); |
| } |
| |
| @Test |
| public final void test_ObjectExpression_MissingExpression() throws Exception { |
| |
| String jpqlQuery = "SELECT OBJECT() FROM Employee e"; |
| int startPosition = "SELECT OBJECT(".length(); |
| int endPosition = startPosition; |
| |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| |
| testHasOnlyOneProblem( |
| problems, |
| ObjectExpression_MissingExpression, |
| startPosition, |
| endPosition |
| ); |
| } |
| |
| @Test |
| public final void test_ObjectExpression_MissingLeftParenthesis() throws Exception { |
| |
| String jpqlQuery = "SELECT OBJECT e) FROM Employee e"; |
| int startPosition = "SELECT OBJECT".length(); |
| int endPosition = startPosition; |
| |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| |
| testHasOnlyOneProblem( |
| problems, |
| ObjectExpression_MissingLeftParenthesis, |
| startPosition, |
| endPosition |
| ); |
| } |
| |
| @Test |
| public final void test_ObjectExpression_MissingRightParenthesis() throws Exception { |
| |
| String jpqlQuery = "SELECT OBJECT(e FROM Employee e"; |
| int startPosition = "SELECT OBJECT(e".length(); |
| int endPosition = startPosition; |
| |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| |
| testHasOnlyOneProblem( |
| problems, |
| ObjectExpression_MissingRightParenthesis, |
| startPosition, |
| endPosition |
| ); |
| } |
| |
| @Test |
| public final void test_OrderByClause_OrderByItemEndsWithComma() throws Exception { |
| |
| String jpqlQuery = "SELECT e FROM Employee e ORDER BY e.name, e.age,"; |
| int startPosition = jpqlQuery.length() - 1; |
| int endPosition = startPosition + 1; |
| |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| |
| testHasOnlyOneProblem( |
| problems, |
| OrderByClause_OrderByItemEndsWithComma, |
| startPosition, |
| endPosition |
| ); |
| } |
| |
| @Test |
| public final void test_OrderByClause_OrderByItemMissing() throws Exception { |
| |
| String jpqlQuery = "SELECT e FROM Employee e ORDER BY"; |
| int startPosition = jpqlQuery.length(); |
| int endPosition = jpqlQuery.length(); |
| |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| |
| testHasOnlyOneProblem( |
| problems, |
| OrderByClause_OrderByItemMissing, |
| startPosition, |
| endPosition |
| ); |
| } |
| |
| @Test |
| public final void test_OrderByItem_InvalidExpression_01() throws Exception { |
| String jpqlQuery = "SELECT e FROM Employee e ORDER BY e.age"; |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| testHasNoProblems(problems); |
| } |
| |
| @Test |
| public final void test_OrderByItem_InvalidExpression_02() throws Exception { |
| |
| String jpqlQuery = "SELECT e FROM Employee e ORDER BY e.age ORDER"; |
| int startPosition = "SELECT e FROM Employee e ORDER BY ".length(); |
| int endPosition = jpqlQuery.length(); |
| |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| |
| testHasOnlyOneProblem( |
| problems, |
| OrderByItem_InvalidExpression, |
| startPosition, |
| endPosition |
| ); |
| } |
| |
| @Test |
| public final void test_OrderByItem_InvalidExpression_03() throws Exception { |
| |
| String jpqlQuery = "SELECT e FROM Employee e ORDER BY e.age GROUP"; |
| int startPosition = "SELECT e FROM Employee e ORDER BY ".length(); |
| int endPosition = jpqlQuery.length(); |
| |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| |
| testHasOnlyOneProblem( |
| problems, |
| OrderByItem_InvalidExpression, |
| startPosition, |
| endPosition |
| ); |
| } |
| |
| @Test |
| public final void test_OrderByItem_InvalidExpression_04() throws Exception { |
| |
| String jpqlQuery = "SELECT e FROM Employee e ORDER BY e.age SELECT"; |
| int startPosition = "SELECT e FROM Employee e ORDER BY ".length(); |
| int endPosition = jpqlQuery.length(); |
| |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| |
| testHasOnlyOneProblem( |
| problems, |
| OrderByItem_InvalidExpression, |
| startPosition, |
| endPosition |
| ); |
| } |
| |
| @Test |
| public final void test_OrderByItem_InvalidExpression_05() throws Exception { |
| |
| String jpqlQuery = "SELECT e FROM Employee e ORDER BY e.age nulls order"; |
| |
| int startPosition = "SELECT e FROM Employee e ORDER BY e.age nulls".length(); |
| int endPosition = "SELECT e FROM Employee e ORDER BY e.age nulls ".length(); |
| List<JPQLQueryProblem> problems = validate(jpqlQuery, buildFormatter_9()); |
| |
| testHasOnlyOneProblem( |
| problems, |
| OrderByClause_OrderByItemIsMissingComma, |
| startPosition, |
| endPosition |
| ); |
| } |
| |
| @Test |
| public final void test_OrderByItem_InvalidExpression_06() throws Exception { |
| |
| String jpqlQuery = "SELECT d FROM DiscountCode d ORDER BY d.rate ORDER BY"; |
| int startPosition = "SELECT d FROM DiscountCode d ORDER BY d.rate ".length(); |
| int endPosition = jpqlQuery.length(); |
| |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| |
| testHasOnlyOneProblem( |
| problems, |
| JPQLExpression_UnknownEnding, |
| startPosition, |
| endPosition |
| ); |
| } |
| |
| @Test |
| public final void test_OrderByItem_InvalidExpression_07() throws Exception { |
| |
| String jpqlQuery = "SELECT d FROM DiscountCode d ORDER BY d.rate SUBSTRING"; |
| int startPosition = "SELECT d FROM DiscountCode d ORDER BY ".length(); |
| int endPosition = jpqlQuery.length(); |
| |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| |
| testHasOnlyOneProblem( |
| problems, |
| OrderByItem_InvalidExpression, |
| startPosition, |
| endPosition |
| ); |
| } |
| |
| @Test |
| public final void test_OrderByItem_InvalidExpression_08() throws Exception { |
| |
| String jpqlQuery = "SELECT e, f, g FROM Employee e, Manager g ORDER BY e.name ASC ORDER, f.address DESC, g.phone"; |
| |
| int startPosition = "SELECT e, f, g FROM Employee e, Manager g ORDER BY e.name ASC".length(); |
| int endPosition = "SELECT e, f, g FROM Employee e, Manager g ORDER BY e.name ASC ".length(); |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| |
| testHasOnlyOneProblem( |
| problems, |
| OrderByClause_OrderByItemIsMissingComma, |
| startPosition, |
| endPosition |
| ); |
| } |
| |
| @Test |
| public final void test_OrderByItem_InvalidExpression_09() throws Exception { |
| |
| String jpqlQuery = "SELECT e, f, g FROM Employee e, Manager g ORDER BY e.name ASC NULLS ORDER, f.address DESC, g.phone"; |
| int startPosition = "SELECT e, f, g FROM Employee e, Manager g ORDER BY e.name ASC NULLS".length(); |
| int endPosition = "SELECT e, f, g FROM Employee e, Manager g ORDER BY e.name ASC NULLS ".length(); |
| |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| |
| testHasOnlyOneProblem( |
| problems, |
| OrderByClause_OrderByItemIsMissingComma, |
| startPosition, |
| endPosition |
| ); |
| } |
| |
| @Test |
| public final void test_OrderByItem_InvalidExpression_10() throws Exception { |
| |
| String jpqlQuery = "SELECT e, f, g FROM Employee e, Manager g ORDER BY e.name ASC NULLS SELECT, f.address DESC, g.phone"; |
| |
| int startPosition1 = "SELECT e, f, g FROM Employee e, Manager g ORDER BY e.name ASC NULLS".length(); |
| int endPosition1 = "SELECT e, f, g FROM Employee e, Manager g ORDER BY e.name ASC NULLS ".length(); |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| |
| if (isSubqueryInOrderByClauseSupported()) { |
| |
| int startPosition2 = jpqlQuery.length(); |
| int endPosition2 = jpqlQuery.length(); |
| |
| int startPosition3 = "SELECT e, f, g FROM Employee e, Manager g ORDER BY e.name ASC NULLS SELECT".length(); |
| int endPosition3 = jpqlQuery.length(); |
| |
| testHasOnlyTheseProblems( |
| problems, |
| new String[] { |
| OrderByClause_OrderByItemIsMissingComma, |
| AbstractSelectStatement_FromClauseMissing, |
| SimpleSelectClause_NotSingleExpression |
| }, |
| new int[] { |
| startPosition1, |
| startPosition2, |
| startPosition3 |
| }, |
| new int[] { |
| endPosition1, |
| endPosition2, |
| endPosition3 |
| } |
| ); |
| } |
| else { |
| int startPosition2 = "SELECT e, f, g FROM Employee e, Manager g ORDER BY e.name ASC NULLS ".length(); |
| int endPosition2 = "SELECT e, f, g FROM Employee e, Manager g ORDER BY e.name ASC NULLS SELECT, f.address DESC, g.phone".length(); |
| |
| testHasOnlyTheseProblems( |
| problems, |
| new String[] { OrderByClause_OrderByItemIsMissingComma, OrderByItem_InvalidExpression }, |
| new int[] { startPosition1, startPosition2 }, |
| new int[] { endPosition1, endPosition2 } |
| ); |
| } |
| } |
| |
| @Test |
| public final void test_OrderByItem_InvalidExpression_11() throws Exception { |
| |
| String jpqlQuery = "SELECT e, f, g FROM Employee e, Manager g ORDER BY e.name ASC NULLS ORDER FIRST, f.address DESC, g.phone"; |
| |
| int startPosition1 = "SELECT e, f, g FROM Employee e, Manager g ORDER BY e.name ASC NULLS".length(); |
| int endPosition1 = "SELECT e, f, g FROM Employee e, Manager g ORDER BY e.name ASC NULLS ".length(); |
| |
| int startPosition2 = "SELECT e, f, g FROM Employee e, Manager g ORDER BY e.name ASC NULLS ".length(); |
| int endPosition2 = "SELECT e, f, g FROM Employee e, Manager g ORDER BY e.name ASC NULLS ORDER FIRST".length(); |
| |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| |
| testHasOnlyTheseProblems( |
| problems, |
| new String[] { OrderByClause_OrderByItemIsMissingComma, OrderByItem_InvalidExpression }, |
| new int[] { startPosition1, startPosition2 }, |
| new int[] { endPosition1, endPosition2 } |
| ); |
| } |
| |
| @Test |
| public final void test_OrderByItem_InvalidExpression_12() throws Exception { |
| |
| String jpqlQuery = "SELECT e, f, g FROM Employee e, Manager g ORDER BY e.name ASC ORDER NULLS FIRST, f.address DESC, g.phone"; |
| |
| int startPosition = "SELECT e, f, g FROM Employee e, Manager g ORDER BY e.name ASC".length(); |
| int endPosition = "SELECT e, f, g FROM Employee e, Manager g ORDER BY e.name ASC ".length(); |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| |
| testHasOnlyOneProblem( |
| problems, |
| OrderByClause_OrderByItemIsMissingComma, |
| startPosition, |
| endPosition |
| ); |
| } |
| |
| @Test |
| public final void test_OrderByItem_InvalidExpression_13() throws Exception { |
| |
| String jpqlQuery = "SELECT e, f, g FROM Employee e, Manager g ORDER BY e.name ASC SUBSTRING NULLS FIRST, f.address DESC, g.phone"; |
| |
| int startPosition1 = "SELECT e, f, g FROM Employee e, Manager g ORDER BY e.name ASC".length(); |
| int endPosition1 = "SELECT e, f, g FROM Employee e, Manager g ORDER BY e.name ASC ".length(); |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| |
| if (isScalarExpressionInOrderByClauseSupported()) { |
| int startPosition2 = "SELECT e, f, g FROM Employee e, Manager g ORDER BY e.name ASC SUBSTRING".length(); |
| int endPosition2 = startPosition2; |
| |
| testHasOnlyTheseProblems( |
| problems, |
| new String[] { OrderByClause_OrderByItemIsMissingComma, SubstringExpression_MissingLeftParenthesis }, |
| new int[] { startPosition1, startPosition2 }, |
| new int[] { endPosition1, endPosition2 } |
| ); |
| } |
| else { |
| int startPosition2 = "SELECT e, f, g FROM Employee e, Manager g ORDER BY e.name ASC ".length(); |
| int endPosition2 = "SELECT e, f, g FROM Employee e, Manager g ORDER BY e.name ASC SUBSTRING".length(); |
| |
| testHasOnlyTheseProblems( |
| problems, |
| new String[] { OrderByClause_OrderByItemIsMissingComma, OrderByItem_InvalidExpression }, |
| new int[] { startPosition1, startPosition2 }, |
| new int[] { endPosition1, endPosition2 } |
| ); |
| } |
| } |
| |
| @Test |
| public final void test_OrderByItem_InvalidExpression_14() throws Exception { |
| |
| String jpqlQuery = "SELECT e, f, g FROM Employee e, Manager g ORDER BY e.name ASC NULLS SUBSTRING FIRST, f.address DESC, g.phone"; |
| |
| int startPosition1 = "SELECT e, f, g FROM Employee e, Manager g ORDER BY e.name ASC NULLS".length(); |
| int endPosition1 = "SELECT e, f, g FROM Employee e, Manager g ORDER BY e.name ASC NULLS ".length(); |
| |
| int startPosition2 = "SELECT e, f, g FROM Employee e, Manager g ORDER BY e.name ASC NULLS ".length(); |
| int endPosition2 = "SELECT e, f, g FROM Employee e, Manager g ORDER BY e.name ASC NULLS SUBSTRING FIRST".length(); |
| |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| |
| testHasOnlyTheseProblems( |
| problems, |
| new String[] { OrderByClause_OrderByItemIsMissingComma, OrderByItem_InvalidExpression }, |
| new int[] { startPosition1, startPosition2 }, |
| new int[] { endPosition1, endPosition2 } |
| ); |
| } |
| |
| @Test |
| public final void test_OrderByItem_InvalidExpression_15() throws Exception { |
| |
| String jpqlQuery = "SELECT e FROM Employee e ORDER BY ALL(SELECT d FROM Dept d)"; |
| int startPosition = "SELECT e FROM Employee e ORDER BY ".length(); |
| int endPosition = jpqlQuery.length(); |
| |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| |
| testHasOnlyOneProblem( |
| problems, |
| OrderByItem_InvalidExpression, |
| startPosition, |
| endPosition |
| ); |
| } |
| |
| @Test |
| public final void test_OrderByItem_InvalidExpression_16() throws Exception { |
| |
| String jpqlQuery = "SELECT e FROM Employee e ORDER BY e.name e.age"; |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| |
| int startPosition = "SELECT e FROM Employee e ORDER BY ".length(); |
| int endPosition = "SELECT e FROM Employee e ORDER BY e.name e.age".length(); |
| |
| testHasOnlyOneProblem( |
| problems, |
| OrderByItem_InvalidExpression, |
| startPosition, |
| endPosition |
| ); |
| } |
| |
| @Test |
| public final void test_OrderByItem_InvalidExpression_17() throws Exception { |
| |
| String jpqlQuery = "SELECT e FROM Employee e ORDER BY e.name, e.age e"; |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| |
| int startPosition = "SELECT e FROM Employee e ORDER BY e.name, ".length(); |
| int endPosition = jpqlQuery.length(); |
| |
| testHasOnlyOneProblem( |
| problems, |
| OrderByItem_InvalidExpression, |
| startPosition, |
| endPosition |
| ); |
| } |
| |
| @Test |
| public final void test_OrderByItem_InvalidExpression_18() throws Exception { |
| String jpqlQuery = "SELECT order FROM Order order ORDER BY order"; |
| List<JPQLQueryProblem> problems = validate(jpqlQuery, buildFormatter_10(jpqlQuery)); |
| testHasNoProblems(problems); |
| } |
| |
| @Test |
| public final void test_OrderByItem_MissingExpression_01() throws Exception { |
| String jpqlQuery = "SELECT e FROM Employee e ORDER BY e.age"; |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| testHasNoProblems(problems); |
| } |
| |
| @Test |
| public final void test_OrderByItem_MissingExpression_02() throws Exception { |
| String jpqlQuery = "SELECT e FROM Employee e ORDER BY e.age ASC"; |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| testHasNoProblems(problems); |
| } |
| |
| @Test |
| public final void test_OrderByItem_MissingExpression_03() throws Exception { |
| String jpqlQuery = "SELECT e FROM Employee e ORDER BY e.age DESC"; |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| testHasNoProblems(problems); |
| } |
| |
| @Test |
| public final void test_OrderByItem_MissingExpression_04() throws Exception { |
| String jpqlQuery = "SELECT e FROM Employee e ORDER BY e.age NULLS FIRST"; |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| testHasNoProblems(problems); |
| } |
| |
| @Test |
| public final void test_OrderByItem_MissingExpression_05() throws Exception { |
| String jpqlQuery = "SELECT e FROM Employee e ORDER BY e.age NULLS LAST"; |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| testHasNoProblems(problems); |
| } |
| |
| @Test |
| public final void test_OrderByItem_MissingExpression_06() throws Exception { |
| |
| String jpqlQuery = "SELECT e FROM Employee e ORDER BY ASC"; |
| int startPosition = "SELECT e FROM Employee e ORDER BY ".length(); |
| int endPosition = startPosition; |
| |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| |
| testHasOnlyOneProblem( |
| problems, |
| OrderByItem_MissingExpression, |
| startPosition, |
| endPosition |
| ); |
| } |
| |
| @Test |
| public final void test_OrderByItem_MissingExpression_07() throws Exception { |
| |
| String jpqlQuery = "SELECT e FROM Employee e ORDER BY DESC"; |
| int startPosition = "SELECT e FROM Employee e ORDER BY ".length(); |
| int endPosition = startPosition; |
| |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| |
| testHasOnlyOneProblem( |
| problems, |
| OrderByItem_MissingExpression, |
| startPosition, |
| endPosition |
| ); |
| } |
| |
| @Test |
| public final void test_OrderByItem_MissingExpression_08() throws Exception { |
| |
| String jpqlQuery = "SELECT e FROM Employee e ORDER BY NULLS FIRST"; |
| int startPosition = "SELECT e FROM Employee e ORDER BY ".length(); |
| int endPosition = startPosition; |
| |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| |
| testHasOnlyOneProblem( |
| problems, |
| OrderByItem_MissingExpression, |
| startPosition, |
| endPosition |
| ); |
| } |
| |
| @Test |
| public final void test_OrderByItem_MissingExpression_09() throws Exception { |
| |
| String jpqlQuery = "SELECT e FROM Employee e ORDER BY NULLS LAST"; |
| int startPosition = "SELECT e FROM Employee e ORDER BY ".length(); |
| int endPosition = startPosition; |
| |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| |
| testHasOnlyOneProblem( |
| problems, |
| OrderByItem_MissingExpression, |
| startPosition, |
| endPosition |
| ); |
| } |
| |
| @Test |
| public final void test_RangeVariableDeclaration_MissingIdentificationVariable_1() throws Exception { |
| |
| String jpqlQuery = "SELECT o FROM Order o, Employee"; |
| int startPosition = "SELECT o FROM Order o, Employee".length(); |
| int endPosition = startPosition; |
| |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| |
| testHasOnlyOneProblem( |
| problems, |
| RangeVariableDeclaration_MissingIdentificationVariable, |
| startPosition, |
| endPosition |
| ); |
| } |
| |
| @Test |
| public final void test_RangeVariableDeclaration_MissingIdentificationVariable_2() throws Exception { |
| |
| String jpqlQuery = "SELECT o FROM Order o, Employee "; |
| int startPosition = "SELECT o FROM Order o, Employee ".length(); |
| int endPosition = startPosition; |
| |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| |
| testHasOnlyOneProblem( |
| problems, |
| RangeVariableDeclaration_MissingIdentificationVariable, |
| startPosition, |
| endPosition |
| ); |
| } |
| |
| @Test |
| public final void test_RangeVariableDeclaration_MissingIdentificationVariable_3() throws Exception { |
| |
| String jpqlQuery = "SELECT o FROM Order o, Employee AS"; |
| int startPosition = "SELECT o FROM Order o, Employee AS".length(); |
| int endPosition = startPosition; |
| |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| |
| testHasOnlyOneProblem( |
| problems, |
| RangeVariableDeclaration_MissingIdentificationVariable, |
| startPosition, |
| endPosition |
| ); |
| } |
| |
| @Test |
| public final void test_RangeVariableDeclaration_MissingIdentificationVariable_4() throws Exception { |
| |
| String jpqlQuery = "SELECT o FROM Order o, Employee AS "; |
| int startPosition = "SELECT o FROM Order o, Employee AS ".length(); |
| int endPosition = startPosition; |
| |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| |
| testHasOnlyOneProblem( |
| problems, |
| RangeVariableDeclaration_MissingIdentificationVariable, |
| startPosition, |
| endPosition |
| ); |
| } |
| |
| @Test |
| public final void test_RangeVariableDeclaration_MissingRootObject_1() throws Exception { |
| |
| String jpqlQuery = "SELECT e FROM AS e"; |
| int startPosition = "SELECT e FROM ".length(); |
| int endPosition = startPosition; |
| |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| |
| testHasOnlyOneProblem( |
| problems, |
| RangeVariableDeclaration_MissingRootObject, |
| startPosition, |
| endPosition |
| ); |
| } |
| |
| @Test |
| public final void test_RangeVariableDeclaration_MissingRootObject_2() throws Exception { |
| |
| String jpqlQuery = "SELECT e FROM Employee AS e, AS d"; |
| int startPosition = "SELECT e FROM Employee AS e, ".length(); |
| int endPosition = startPosition; |
| |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| |
| testHasOnlyOneProblem( |
| problems, |
| RangeVariableDeclaration_MissingRootObject, |
| startPosition, |
| endPosition |
| ); |
| } |
| |
| @Test |
| public final void test_RangeVariableDeclaration_MissingRootObject_3() throws Exception { |
| |
| String jpqlQuery = "UPDATE Employee e SET e.salary = e.salary * (1 / 100) WHERE EXISTS (SELECT p FROM e.projects p WHERE p.name LIKE :projectName)"; |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| testHasNoProblems(problems); |
| } |
| |
| @Test |
| public final void test_ResultVariable_MissingResultVariable() throws Exception { |
| |
| String jpqlQuery = "SELECT AVG(e.age) AS FROM Employee e"; |
| int startPosition = "SELECT AVG(e.age) AS ".length(); |
| int endPosition = startPosition; |
| |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| |
| testHasOnlyOneProblem( |
| problems, |
| ResultVariable_MissingResultVariable, |
| startPosition, |
| endPosition |
| ); |
| } |
| |
| @Test |
| public final void test_ResultVariable_MissingSelectExpression() throws Exception { |
| |
| String jpqlQuery = "SELECT AS e1 FROM Employee e"; |
| int startPosition = "SELECT ".length(); |
| int endPosition = startPosition; |
| |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| |
| testHasOnlyOneProblem( |
| problems, |
| ResultVariable_MissingSelectExpression, |
| startPosition, |
| endPosition |
| ); |
| } |
| |
| @Test |
| public final void test_SimpleSelectClause_NotSingleExpression() throws Exception { |
| |
| String jpqlQuery = "SELECT e FROM Employee e WHERE EXISTS(SELECT AVG(o.price), e FROM Order o)"; |
| int startPosition = "SELECT e FROM Employee e WHERE EXISTS(SELECT ".length(); |
| int endPosition = "SELECT e FROM Employee e WHERE EXISTS(SELECT AVG(o.price), e".length(); |
| |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| |
| testHasOnlyOneProblem( |
| problems, |
| SimpleSelectClause_NotSingleExpression, |
| startPosition, |
| endPosition |
| ); |
| } |
| |
| @Test |
| public final void test_SizeExpression_InvalidMissing() throws Exception { |
| |
| String jpqlQuery = "SELECT SIZE(e) FROM Employee e"; |
| int startPosition = "SELECT SIZE(".length(); |
| int endPosition = "SELECT SIZE(e".length(); |
| |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| |
| testHasOnlyOneProblem( |
| problems, |
| SizeExpression_InvalidExpression, |
| startPosition, |
| endPosition |
| ); |
| } |
| |
| @Test |
| public final void test_SizeExpression_MissingExpression() throws Exception { |
| |
| String jpqlQuery = "SELECT SIZE() FROM Employee e JOIN e.addresses a"; |
| int startPosition = "SELECT SIZE(".length(); |
| int endPosition = startPosition; |
| |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| |
| testHasOnlyOneProblem( |
| problems, |
| SizeExpression_MissingExpression, |
| startPosition, |
| endPosition |
| ); |
| } |
| |
| @Test |
| public final void test_SizeExpression_MissingLeftParenthesis() throws Exception { |
| |
| String jpqlQuery = "SELECT SIZE a) FROM Employee e JOIN e.addresses a"; |
| int startPosition = "SELECT SIZE".length(); |
| int endPosition = startPosition; |
| |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| |
| testHasOnlyOneProblem( |
| problems, |
| SizeExpression_MissingLeftParenthesis, |
| startPosition, |
| endPosition |
| ); |
| } |
| |
| @Test |
| public final void test_SizeExpression_MissingRightParenthesis() throws Exception { |
| |
| String jpqlQuery = "SELECT SIZE(a.street FROM Employee e JOIN e.addresses a"; |
| int startPosition = "SELECT SIZE(a.street".length(); |
| int endPosition = startPosition; |
| |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| |
| testHasOnlyOneProblem( |
| problems, |
| SizeExpression_MissingRightParenthesis, |
| startPosition, |
| endPosition |
| ); |
| } |
| |
| @Test |
| public final void test_SqrtExpression_InvalidExpression() throws Exception { |
| |
| String jpqlQuery = "SELECT SQRT(EXISTS()) FROM Employee e"; |
| int startPosition = "SELECT SQRT(".length(); |
| int endPosition = "SELECT SQRT(EXISTS()".length(); |
| |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| |
| testHasProblem( |
| problems, |
| SqrtExpression_InvalidExpression, |
| startPosition, |
| endPosition |
| ); |
| } |
| |
| @Test |
| public final void test_SqrtExpression_MissingExpression() throws Exception { |
| |
| String jpqlQuery = "SELECT SQRT() FROM Employee e"; |
| int startPosition = "SELECT SQRT(".length(); |
| int endPosition = startPosition; |
| |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| |
| testHasOnlyOneProblem( |
| problems, |
| SqrtExpression_MissingExpression, |
| startPosition, |
| endPosition |
| ); |
| } |
| |
| @Test |
| public final void test_SqrtExpression_MissingLeftParenthesis() throws Exception { |
| |
| String jpqlQuery = "SELECT SQRT 4 + 5) FROM Employee e"; |
| int startPosition = "SELECT SQRT".length(); |
| int endPosition = startPosition; |
| |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| |
| testHasOnlyOneProblem( |
| problems, |
| SqrtExpression_MissingLeftParenthesis, |
| startPosition, |
| endPosition |
| ); |
| } |
| |
| @Test |
| public final void test_SqrtExpression_MissingRightParenthesis() throws Exception { |
| |
| String jpqlQuery = "SELECT SQRT(e.age + 100 FROM Employee e"; |
| int startPosition = "SELECT SQRT(e.age + 100".length(); |
| int endPosition = startPosition; |
| |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| |
| testHasOnlyOneProblem( |
| problems, |
| SqrtExpression_MissingRightParenthesis, |
| startPosition, |
| endPosition |
| ); |
| } |
| |
| @Test |
| public final void test_SubExpression_MissingExpression() throws Exception { |
| |
| String jpqlQuery = "SELECT e FROM Employee e WHERE () = 2"; |
| int startPosition = "SELECT e FROM Employee e WHERE (".length(); |
| int endPosition = startPosition; |
| |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| |
| testHasOnlyOneProblem( |
| problems, |
| SubExpression_MissingExpression, |
| startPosition, |
| endPosition |
| ); |
| } |
| |
| @Test |
| public final void test_SubExpression_MissingRightParenthesis() throws Exception { |
| |
| String jpqlQuery = "SELECT e FROM Employee e WHERE (2 + e.age"; |
| int startPosition = jpqlQuery.length(); |
| int endPosition = startPosition; |
| |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| |
| testHasProblem( |
| problems, |
| SubExpression_MissingRightParenthesis, |
| startPosition, |
| endPosition |
| ); |
| } |
| |
| @Test |
| public final void test_SubstringExpression_InvalidFirstExpression() throws Exception { |
| |
| String jpqlQuery = "SELECT e FROM Employee e WHERE SUBSTRING(e, 0, 1)"; |
| int startPosition = "SELECT e FROM Employee e WHERE SUBSTRING(".length(); |
| int endPosition = startPosition + 1; |
| |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| |
| testHasProblem( |
| problems, |
| SubstringExpression_InvalidFirstExpression, |
| startPosition, |
| endPosition |
| ); |
| } |
| |
| @Test |
| public final void test_SubstringExpression_InvalidSecondExpression() throws Exception { |
| |
| String jpqlQuery = "SELECT e FROM Employee e WHERE SUBSTRING(e.name, e, 1)"; |
| int startPosition = "SELECT e FROM Employee e WHERE SUBSTRING(e.name, ".length(); |
| int endPosition = "SELECT e FROM Employee e WHERE SUBSTRING(e.name, e".length(); |
| |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| |
| testHasProblem( |
| problems, |
| SubstringExpression_InvalidSecondExpression, |
| startPosition, |
| endPosition |
| ); |
| } |
| |
| @Test |
| public final void test_SubstringExpression_InvalidThirdExpression() throws Exception { |
| |
| String jpqlQuery = "SELECT e FROM Employee e WHERE SUBSTRING(e.name, 0, e)"; |
| int startPosition = "SELECT e FROM Employee e WHERE SUBSTRING(e.name, 0, ".length(); |
| int endPosition = startPosition + 1; |
| |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| |
| testHasProblem( |
| problems, |
| SubstringExpression_InvalidThirdExpression, |
| startPosition, |
| endPosition |
| ); |
| } |
| |
| @Test |
| public final void test_SubstringExpression_MissingFirstComma() throws Exception { |
| |
| String jpqlQuery = "SELECT e FROM Employee e WHERE SUBSTRING(e.name 0, 1)"; |
| int startPosition = "SELECT e FROM Employee e WHERE SUBSTRING(e.name".length(); |
| int endPosition = startPosition; |
| |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| |
| testHasProblem( |
| problems, |
| SubstringExpression_MissingFirstComma, |
| startPosition, |
| endPosition |
| ); |
| } |
| |
| @Test |
| public final void test_SubstringExpression_MissingFirstExpression() throws Exception { |
| |
| String jpqlQuery = "SELECT e FROM Employee e WHERE SUBSTRING(, 0, 1)"; |
| int startPosition = "SELECT e FROM Employee e WHERE SUBSTRING(".length(); |
| int endPosition = startPosition; |
| |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| |
| testHasProblem( |
| problems, |
| SubstringExpression_MissingFirstExpression, |
| startPosition, |
| endPosition |
| ); |
| } |
| |
| @Test |
| public final void test_SubstringExpression_MissingLeftParenthesis() throws Exception { |
| |
| String jpqlQuery = "SELECT e FROM Employee e WHERE SUBSTRING e.name, 0, 1)"; |
| int startPosition = "SELECT e FROM Employee e WHERE SUBSTRING".length(); |
| int endPosition = startPosition; |
| |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| |
| testHasProblem( |
| problems, |
| SubstringExpression_MissingLeftParenthesis, |
| startPosition, |
| endPosition |
| ); |
| } |
| |
| @Test |
| public final void test_SubstringExpression_MissingRightParenthesis() throws Exception { |
| |
| String jpqlQuery = "SELECT e FROM Employee e WHERE SUBSTRING(e.name, 0, 1"; |
| int startPosition = jpqlQuery.length(); |
| int endPosition = startPosition; |
| |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| |
| testHasProblem( |
| problems, |
| SubstringExpression_MissingRightParenthesis, |
| startPosition, |
| endPosition |
| ); |
| } |
| |
| @Test |
| public final void test_SubstringExpression_MissingSecondComma() throws Exception { |
| |
| String jpqlQuery = "SELECT e FROM Employee e WHERE SUBSTRING(e.name, 0 1)"; |
| int startPosition = "SELECT e FROM Employee e WHERE SUBSTRING(e.name, 0".length(); |
| int endPosition = startPosition; |
| |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| |
| testHasProblem( |
| problems, |
| SubstringExpression_MissingSecondComma, |
| startPosition, |
| endPosition |
| ); |
| } |
| |
| @Test |
| public final void test_SubstringExpression_MissingSecondExpression() throws Exception { |
| |
| String jpqlQuery = "SELECT e FROM Employee e WHERE SUBSTRING(e.name, , 1)"; |
| int startPosition = "SELECT e FROM Employee e WHERE SUBSTRING(e.name, ".length(); |
| int endPosition = startPosition; |
| |
| List<JPQLQueryProblem> problems = validate(jpqlQuery, buildFormatter_8()); |
| |
| testHasProblem( |
| problems, |
| SubstringExpression_MissingSecondExpression, |
| startPosition, |
| endPosition |
| ); |
| } |
| |
| @Test |
| public final void test_SubstringExpression_MissingThirdExpression_1() throws Exception { |
| |
| String jpqlQuery = "SELECT e FROM Employee e WHERE SUBSTRING(e.name, 0,"; |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| |
| if (jpqlGrammar.getJPAVersion().isNewerThan(JPAVersion.VERSION_1_0)) { |
| int startPosition = jpqlQuery.length(); |
| int endPosition = startPosition; |
| |
| testHasProblem( |
| problems, |
| SubstringExpression_MissingThirdExpression, |
| startPosition, |
| endPosition |
| ); |
| } |
| else { |
| testDoesNotHaveProblem( |
| problems, |
| SubstringExpression_MissingThirdExpression |
| ); |
| } |
| } |
| |
| @Test |
| public final void test_SubstringExpression_MissingThirdExpression_2() throws Exception { |
| |
| String jpqlQuery = "SELECT e FROM Employee e WHERE SUBSTRING(e.name, 0, "; |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| |
| if (jpqlGrammar.getJPAVersion().isNewerThan(JPAVersion.VERSION_1_0)) { |
| int startPosition = jpqlQuery.length(); |
| int endPosition = startPosition; |
| |
| testHasProblem( |
| problems, |
| SubstringExpression_MissingThirdExpression, |
| startPosition, |
| endPosition |
| ); |
| } |
| else { |
| testDoesNotHaveProblem( |
| problems, |
| SubstringExpression_MissingThirdExpression |
| ); |
| } |
| } |
| |
| @Test |
| public final void test_SubstringExpression_MissingThirdExpression_3() throws Exception { |
| |
| String jpqlQuery = "SELECT e FROM Employee e WHERE SUBSTRING(e.name, 0, )"; |
| List<JPQLQueryProblem> problems = validate(jpqlQuery, buildFormatter_7()); |
| |
| if (jpqlGrammar.getJPAVersion().isNewerThan(JPAVersion.VERSION_1_0)) { |
| int startPosition = jpqlQuery.length() - 1; |
| int endPosition = startPosition; |
| |
| testHasProblem( |
| problems, |
| SubstringExpression_MissingThirdExpression, |
| startPosition, |
| endPosition |
| ); |
| } |
| else { |
| testDoesNotHaveProblem( |
| problems, |
| SubstringExpression_MissingThirdExpression |
| ); |
| } |
| } |
| |
| @Test |
| public final void test_SubstringExpression_MissingThirdExpression_4() throws Exception { |
| |
| String jpqlQuery = "SELECT e FROM Employee e WHERE SUBSTRING(e.name, 0)"; |
| |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| testDoesNotHaveProblem(problems, SubstringExpression_MissingThirdExpression); |
| } |
| |
| @Test |
| public final void test_SumFunction_InvalidExpression() throws Exception { |
| |
| String jpqlQuery = "SELECT SUM(e) FROM Employee e"; |
| int startPosition = "SELECT SUM(".length(); |
| int endPosition = "SELECT SUM(e".length(); |
| |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| |
| testHasOnlyOneProblem( |
| problems, |
| SumFunction_InvalidExpression, |
| startPosition, |
| endPosition |
| ); |
| } |
| |
| @Test |
| public final void test_SumFunction_MissingExpression_1() throws Exception { |
| |
| String jpqlQuery = "SELECT SUM() FROM Employee e"; |
| int startPosition = "SELECT SUM(".length(); |
| int endPosition = startPosition; |
| |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| |
| testHasOnlyOneProblem( |
| problems, |
| SumFunction_MissingExpression, |
| startPosition, |
| endPosition |
| ); |
| } |
| |
| @Test |
| public final void test_SumFunction_MissingExpression_2() throws Exception { |
| |
| String jpqlQuery = "SELECT SUM(DISTINCT) FROM Employee e"; |
| int startPosition = "SELECT SUM(DISTINCT".length(); |
| int endPosition = startPosition; |
| |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| |
| testHasOnlyOneProblem( |
| problems, |
| SumFunction_MissingExpression, |
| startPosition, |
| endPosition |
| ); |
| } |
| |
| @Test |
| public final void test_SumFunction_MissingExpression_3() throws Exception { |
| |
| String jpqlQuery = "SELECT SUM(DISTINCT ) FROM Employee e"; |
| int startPosition = "SELECT SUM(DISTINCT ".length(); |
| int endPosition = startPosition; |
| |
| List<JPQLQueryProblem> problems = validate(jpqlQuery, buildFormatter_2()); |
| |
| testHasOnlyOneProblem( |
| problems, |
| SumFunction_MissingExpression, |
| startPosition, |
| endPosition |
| ); |
| } |
| |
| @Test |
| public final void test_SumFunction_MissingLeftParenthesis_1() throws Exception { |
| |
| String jpqlQuery = "SELECT SUM e.age) FROM Employee e"; |
| int startPosition = "SELECT SUM".length(); |
| int endPosition = startPosition; |
| |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| |
| testHasOnlyOneProblem( |
| problems, |
| SumFunction_MissingLeftParenthesis, |
| startPosition, |
| endPosition |
| ); |
| } |
| |
| @Test |
| public final void test_SumFunction_MissingLeftParenthesis_2() throws Exception { |
| |
| String jpqlQuery = "SELECT SUM DISTINCT e.age) FROM Employee e"; |
| int startPosition = "SELECT SUM".length(); |
| int endPosition = startPosition; |
| |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| |
| testHasOnlyOneProblem( |
| problems, |
| SumFunction_MissingLeftParenthesis, |
| startPosition, |
| endPosition |
| ); |
| } |
| |
| @Test |
| public final void test_SumFunction_MissingRightParenthesis() throws Exception { |
| |
| String jpqlQuery = "SELECT SUM(DISTINCT e.age FROM Employee e"; |
| int startPosition = "SELECT SUM(DISTINCT e.age".length(); |
| int endPosition = startPosition; |
| |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| |
| testHasOnlyOneProblem( |
| problems, |
| SumFunction_MissingRightParenthesis, |
| startPosition, |
| endPosition |
| ); |
| } |
| |
| @Test |
| public final void test_TrimExpression_InvalidExpression() throws Exception { |
| |
| String jpqlQuery = "SELECT e FROM Employee e WHERE TRIM(e) = 'JPQL'"; |
| int startPosition = "SELECT e FROM Employee e WHERE TRIM(".length(); |
| int endPosition = startPosition + 1; |
| |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| |
| testHasOnlyOneProblem( |
| problems, |
| TrimExpression_InvalidExpression, |
| startPosition, |
| endPosition |
| ); |
| } |
| |
| @Test |
| public final void test_TrimExpression_InvalidTrimCharacter() throws Exception { |
| |
| String jpqlQuery = "SELECT e FROM Employee e WHERE TRIM(e FROM ' JPQL ') = 'JPQL'"; |
| int startPosition = "SELECT e FROM Employee e WHERE TRIM(".length(); |
| int endPosition = startPosition + 1; |
| |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| |
| testHasOnlyOneProblem( |
| problems, |
| TrimExpression_InvalidTrimCharacter, |
| startPosition, |
| endPosition |
| ); |
| } |
| |
| @Test |
| public final void test_TrimExpression_MissingExpression() throws Exception { |
| |
| String jpqlQuery = "SELECT e FROM Employee e WHERE TRIM() = 'JPQL'"; |
| int startPosition = "SELECT e FROM Employee e WHERE TRIM(".length(); |
| int endPosition = startPosition; |
| |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| |
| testHasOnlyOneProblem( |
| problems, |
| TrimExpression_MissingExpression, |
| startPosition, |
| endPosition |
| ); |
| } |
| |
| @Test |
| public final void test_TrimExpression_MissingLeftParenthesis() throws Exception { |
| |
| String jpqlQuery = "SELECT e FROM Employee e WHERE TRIM ' JPQL ') = 'JPQL'"; |
| int startPosition = "SELECT e FROM Employee e WHERE TRIM".length(); |
| int endPosition = startPosition; |
| |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| |
| testHasOnlyOneProblem( |
| problems, |
| TrimExpression_MissingLeftParenthesis, |
| startPosition, |
| endPosition |
| ); |
| } |
| |
| @Test |
| public final void test_TrimExpression_MissingRightParenthesis() throws Exception { |
| |
| String jpqlQuery = "SELECT e FROM Employee e WHERE TRIM(' JPQL ' = 'JPQL'"; |
| int startPosition = "SELECT e FROM Employee e WHERE TRIM(' JPQL '".length(); |
| int endPosition = startPosition; |
| |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| |
| testHasOnlyOneProblem( |
| problems, |
| TrimExpression_MissingRightParenthesis, |
| startPosition, |
| endPosition |
| ); |
| } |
| |
| @Test |
| public final void test_TrimExpression_NotSingleStringLiteral() throws Exception { |
| |
| String jpqlQuery = "SELECT e FROM Employee e WHERE TRIM('u2' FROM ' JPQL ') = 'JPQL'"; |
| int startPosition = "SELECT e FROM Employee e WHERE TRIM(".length(); |
| int endPosition = "SELECT e FROM Employee e WHERE TRIM('u2'".length(); |
| |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| |
| testHasOnlyOneProblem( |
| problems, |
| TrimExpression_NotSingleStringLiteral, |
| startPosition, |
| endPosition |
| ); |
| } |
| |
| @Test |
| public final void test_TypeExpression_InvalidExpression() throws Exception { |
| |
| String jpqlQuery = "SELECT TYPE(e.name) FROM Employee e"; |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| testDoesNotHaveProblem(problems, TypeExpression_InvalidExpression); |
| } |
| |
| @Test |
| public final void test_TypeExpression_MissingExpression() throws Exception { |
| |
| String jpqlQuery = "SELECT TYPE() FROM Employee e"; |
| int startPosition = "SELECT TYPE(".length(); |
| int endPosition = startPosition; |
| |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| |
| testHasOnlyOneProblem( |
| problems, |
| TypeExpression_MissingExpression, |
| startPosition, |
| endPosition |
| ); |
| } |
| |
| @Test |
| public final void test_TypeExpression_MissingLeftParenthesis() throws Exception { |
| |
| String jpqlQuery = "SELECT TYPE e) FROM Employee e"; |
| int startPosition = "SELECT TYPE".length(); |
| int endPosition = startPosition; |
| |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| |
| testHasOnlyOneProblem( |
| problems, |
| TypeExpression_MissingLeftParenthesis, |
| startPosition, |
| endPosition |
| ); |
| } |
| |
| @Test |
| public final void test_TypeExpression_MissingRightParenthesis() throws Exception { |
| |
| String jpqlQuery = "SELECT TYPE(e FROM Employee e"; |
| int startPosition = "SELECT TYPE(e".length(); |
| int endPosition = startPosition; |
| |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| |
| testHasOnlyOneProblem( |
| problems, |
| TypeExpression_MissingRightParenthesis, |
| startPosition, |
| endPosition |
| ); |
| } |
| |
| // @Test |
| // public final void test_UpdateItem_InvalidNewValue() |
| // { |
| // String jpqlQuery = "UPDATE Employee e SET e.name = LENGTH(e.age)"; |
| // |
| // int startPosition = "UPDATE Employee e SET e.name = ".length(); |
| // int endPosition = jpqlQuery.length(); |
| // |
| // List<QueryProblem> problems = validate(jpqlQuery); |
| // |
| // testHasOnlyOneProblem |
| // ( |
| // problems, |
| // QueryProblemMessages.UpdateItem_InvalidNewValue, |
| // startPosition, |
| // endPosition |
| // ); |
| // } |
| |
| @Test |
| public final void test_UpdateClause_MissingRangeVariableDeclaration() throws Exception { |
| |
| String jpqlQuery = "UPDATE SET e.name = 'Pascal'"; |
| int startPosition = "UPDATE ".length(); |
| int endPosition = startPosition; |
| |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| |
| testHasOnlyOneProblem( |
| problems, |
| UpdateClause_MissingRangeVariableDeclaration, |
| startPosition, |
| endPosition |
| ); |
| } |
| |
| @Test |
| public final void test_UpdateClause_MissingSet() throws Exception { |
| |
| String jpqlQuery = "UPDATE Employee e e.name = 'Pascal'"; |
| int startPosition = "UPDATE Employee e ".length(); |
| int endPosition = startPosition; |
| |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| |
| testHasOnlyOneProblem( |
| problems, |
| UpdateClause_MissingSet, |
| startPosition, |
| endPosition |
| ); |
| } |
| |
| @Test |
| public final void test_UpdateClause_MissingUpdateItems_1() throws Exception { |
| |
| String jpqlQuery = "UPDATE Employee e SET"; |
| int startPosition = jpqlQuery.length(); |
| int endPosition = startPosition; |
| |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| |
| testHasOnlyOneProblem( |
| problems, |
| UpdateClause_MissingUpdateItems, |
| startPosition, |
| endPosition |
| ); |
| } |
| |
| @Test |
| public final void test_UpdateClause_MissingUpdateItems_2() throws Exception { |
| |
| String jpqlQuery = "UPDATE Employee e SET "; |
| int startPosition = jpqlQuery.length(); |
| int endPosition = startPosition; |
| |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| |
| testHasOnlyOneProblem( |
| problems, |
| UpdateClause_MissingUpdateItems, |
| startPosition, |
| endPosition |
| ); |
| } |
| |
| @Test |
| public final void test_UpdateClause_UpdateItemEndsWithComma_1() throws Exception { |
| |
| String jpqlQuery = "UPDATE Employee e SET e.name = 'JPQL',"; |
| int startPosition = jpqlQuery.length() - 1; |
| int endPosition = startPosition + 1; |
| |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| |
| testHasOnlyOneProblem( |
| problems, |
| UpdateClause_UpdateItemEndsWithComma, |
| startPosition, |
| endPosition |
| ); |
| } |
| |
| @Test |
| public final void test_UpdateClause_UpdateItemEndsWithComma_2() throws Exception { |
| |
| String jpqlQuery = "UPDATE Employee e SET e.name = 'JPQL', "; |
| int startPosition = "UPDATE Employee e SET e.name = 'JPQL'".length(); |
| int endPosition = startPosition + 1; |
| |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| |
| testHasOnlyOneProblem( |
| problems, |
| UpdateClause_UpdateItemEndsWithComma, |
| startPosition, |
| endPosition |
| ); |
| } |
| |
| @Test |
| public final void test_UpdateClause_UpdateItemIsMissingComma() throws Exception { |
| |
| String jpqlQuery = "UPDATE Employee e SET e.name = 'JPQL' e.age = 20"; |
| int startPosition = "UPDATE Employee e SET e.name = 'JPQL'".length(); |
| int endPosition = startPosition + 1; |
| |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| |
| testHasOnlyOneProblem( |
| problems, |
| UpdateClause_UpdateItemIsMissingComma, |
| startPosition, |
| endPosition |
| ); |
| } |
| |
| @Test |
| public final void test_UpdateItem_MissingEqualSign_1() throws Exception { |
| |
| String jpqlQuery = "UPDATE Employee e SET e.name"; |
| int startPosition = jpqlQuery.length(); |
| int endPosition = startPosition; |
| |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| |
| testHasOnlyOneProblem( |
| problems, |
| UpdateItem_MissingEqualSign, |
| startPosition, |
| endPosition |
| ); |
| } |
| |
| @Test |
| public final void test_UpdateItem_MissingEqualSign_2() throws Exception { |
| |
| String jpqlQuery = "UPDATE Employee e SET e.name "; |
| int startPosition = jpqlQuery.length(); |
| int endPosition = startPosition; |
| |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| |
| testHasOnlyOneProblem( |
| problems, |
| UpdateItem_MissingEqualSign, |
| startPosition, |
| endPosition |
| ); |
| } |
| |
| @Test |
| public final void test_UpdateItem_MissingNewValue_1() throws Exception { |
| |
| String jpqlQuery = "UPDATE Employee e SET e.name ="; |
| int startPosition = jpqlQuery.length(); |
| int endPosition = startPosition; |
| |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| |
| testHasOnlyOneProblem( |
| problems, |
| UpdateItem_MissingNewValue, |
| startPosition, |
| endPosition |
| ); |
| } |
| |
| @Test |
| public final void test_UpdateItem_MissingNewValue_2() throws Exception { |
| |
| String jpqlQuery = "UPDATE Employee e SET e.name = "; |
| int startPosition = jpqlQuery.length(); |
| int endPosition = startPosition; |
| |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| |
| testHasOnlyOneProblem( |
| problems, |
| UpdateItem_MissingNewValue, |
| startPosition, |
| endPosition |
| ); |
| } |
| |
| @Test |
| public final void test_UpdateItem_MissingStateFieldPathExpression() throws Exception { |
| |
| String jpqlQuery = "UPDATE Employee e SET = 'Pascal'"; |
| int startPosition = "UPDATE Employee e SET ".length(); |
| int endPosition = startPosition; |
| |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| |
| testHasOnlyOneProblem( |
| problems, |
| UpdateItem_MissingStateFieldPathExpression, |
| startPosition, |
| endPosition |
| ); |
| } |
| |
| @Test |
| public final void test_UpperExpression_InvalidExpression() throws Exception { |
| |
| String jpqlQuery = "SELECT e FROM Employee e WHERE UPPER(ALL(SELECT d FROM Dept d)) = 'PASCAL'"; |
| int startPosition = "SELECT e FROM Employee e WHERE UPPER(".length(); |
| int endPosition = "SELECT e FROM Employee e WHERE UPPER(ALL(SELECT d FROM Dept d)".length(); |
| |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| |
| testHasOnlyOneProblem( |
| problems, |
| UpperExpression_InvalidExpression, |
| startPosition, |
| endPosition |
| ); |
| } |
| |
| @Test |
| public final void test_UpperExpression_MissingExpression() throws Exception { |
| |
| String jpqlQuery = "SELECT e FROM Employee e WHERE UPPER() = 'PASCAL'"; |
| int startPosition = "SELECT e FROM Employee e WHERE UPPER(".length(); |
| int endPosition = startPosition; |
| |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| |
| testHasOnlyOneProblem( |
| problems, |
| UpperExpression_MissingExpression, |
| startPosition, |
| endPosition |
| ); |
| } |
| |
| @Test |
| public final void test_UpperExpression_MissingLeftParenthesis() throws Exception { |
| |
| String jpqlQuery = "SELECT e FROM Employee e WHERE UPPER e.name) = 'PASCAL'"; |
| int startPosition = "SELECT e FROM Employee e WHERE UPPER".length(); |
| int endPosition = startPosition; |
| |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| |
| testHasOnlyOneProblem( |
| problems, |
| UpperExpression_MissingLeftParenthesis, |
| startPosition, |
| endPosition |
| ); |
| } |
| |
| @Test |
| public final void test_UpperExpression_MissingRightParenthesis() throws Exception { |
| |
| String jpqlQuery = "SELECT e FROM Employee e WHERE UPPER(e.name = 'PASCAL'"; |
| int startPosition = "SELECT e FROM Employee e WHERE UPPER(e.name".length(); |
| int endPosition = startPosition; |
| |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| |
| testHasOnlyOneProblem( |
| problems, |
| UpperExpression_MissingRightParenthesis, |
| startPosition, |
| endPosition |
| ); |
| } |
| |
| @Test |
| public final void test_ValidQuery_01() throws Exception { |
| |
| String jpqlQuery = "UPDATE Product " + |
| "SET partNumber = CASE TYPE(project) WHEN com.titan.domain.EnumType.FIRST_NAME THEN '1' " + |
| " WHEN com.titan.domain.EnumType.LAST_NAME THEN '2' " + |
| " ELSE '3' " + |
| " END"; |
| |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| testHasNoProblems(problems); |
| } |
| |
| @Test |
| public final void test_ValidQuery_02() throws Exception { |
| |
| String jpqlQuery = "SELECT e FROM Employee e WHERE EXISTS(SELECT o.date FROM Order o)"; |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| testHasNoProblems(problems); |
| } |
| |
| @Test |
| public final void test_ValidQuery_03() throws Exception { |
| |
| String jpqlQuery = "SELECT e FROM Employee e HAVING ALL(SELECT o.name FROM Order o) = 'JPQL'"; |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| testHasNoProblems(problems); |
| } |
| |
| @Test |
| public final void test_ValidQuery_04() throws Exception { |
| |
| String jpqlQuery = "SELECT r FROM RuleCondition r WHERE r.ruleType = :ruleType AND r.operator = :operator AND (SELECT Count(rcc) FROM r.components rcc ) = :componentCount AND (SELECT Count(rc2) FROM r.components rc2 WHERE rc2.componentId IN :componentIds) = :componentCount"; |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| testHasNoProblems(problems); |
| } |
| |
| @Test |
| public final void test_ValidQuery_05() throws Exception { |
| |
| String jpqlQuery = "SELECT p FROM Product p WHERE TYPE(p.project) <> SmallProject"; |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| testHasNoProblems(problems); |
| } |
| |
| @Test |
| public final void test_ValueExpression_InvalidExpression() throws Exception { |
| |
| String jpqlQuery = "SELECT VALUE(e.name) FROM Employee e"; |
| int startPosition = "SELECT VALUE(".length(); |
| int endPosition = "SELECT VALUE(e.name".length(); |
| |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| |
| testHasOnlyOneProblem( |
| problems, |
| ValueExpression_InvalidExpression, |
| startPosition, |
| endPosition |
| ); |
| } |
| |
| @Test |
| public final void test_ValueExpression_MissingExpression() throws Exception { |
| |
| String jpqlQuery = "SELECT VALUE() FROM Employee e JOIN e.addresses a"; |
| int startPosition = "SELECT VALUE(".length(); |
| int endPosition = startPosition; |
| |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| |
| testHasOnlyOneProblem( |
| problems, |
| ValueExpression_MissingExpression, |
| startPosition, |
| endPosition |
| ); |
| } |
| |
| @Test |
| public final void test_ValueExpression_MissingLeftParenthesis() throws Exception { |
| |
| String jpqlQuery = "SELECT VALUE a) FROM Employee e JOIN e.addresses a"; |
| int startPosition = "SELECT VALUE".length(); |
| int endPosition = startPosition; |
| |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| |
| testHasOnlyOneProblem( |
| problems, |
| ValueExpression_MissingLeftParenthesis, |
| startPosition, |
| endPosition |
| ); |
| } |
| |
| @Test |
| public final void test_ValueExpression_MissingRightParenthesis() throws Exception { |
| |
| String jpqlQuery = "SELECT VALUE(a FROM Employee e JOIN e.addresses a"; |
| int startPosition = "SELECT VALUE(a".length(); |
| int endPosition = startPosition; |
| |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| |
| testHasOnlyOneProblem( |
| problems, |
| ValueExpression_MissingRightParenthesis, |
| startPosition, |
| endPosition |
| ); |
| } |
| |
| @Test |
| public final void test_WhenClause_MissingThenExpression() throws Exception { |
| |
| String jpqlQuery = "UPDATE Employee e " + |
| "SET e.salary = " + |
| " CASE WHEN e.rating = 1 THEN " + |
| " ELSE e.salary * 1.01" + |
| " END"; |
| |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| |
| int startPosition = "UPDATE Employee e SET e.salary = CASE WHEN e.rating = 1 THEN ".length(); |
| int endPosition = startPosition; |
| |
| testHasOnlyOneProblem( |
| problems, |
| WhenClause_MissingThenExpression, |
| startPosition, |
| endPosition |
| ); |
| } |
| |
| @Test |
| public final void test_WhenClause_MissingThenIdentifier() throws Exception { |
| |
| String jpqlQuery = "UPDATE Employee e " + |
| "SET e.salary = " + |
| " CASE WHEN e.rating = 1 " + |
| " ELSE e.salary * 1.01" + |
| " END"; |
| |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| |
| jpqlQuery = jpqlQuery.replaceAll("\\s+", " "); |
| |
| int startPosition = "UPDATE Employee e SET e.salary = CASE WHEN e.rating = 1 ".length(); |
| int endPosition = startPosition; |
| |
| testHasOnlyOneProblem( |
| problems, |
| WhenClause_MissingThenIdentifier, |
| startPosition, |
| endPosition |
| ); |
| } |
| |
| @Test |
| public final void test_WhenClause_MissingWhenExpression() throws Exception { |
| |
| String jpqlQuery = "UPDATE Employee e " + |
| "SET e.salary = " + |
| " CASE WHEN" + |
| " ELSE 'NonExempt'" + |
| " END"; |
| |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| |
| jpqlQuery = jpqlQuery.replaceAll("\\s+", " "); |
| |
| int startPosition = "UPDATE Employee e SET e.salary = CASE WHEN ".length(); |
| int endPosition = startPosition; |
| |
| testHasOnlyOneProblem( |
| problems, |
| WhenClause_MissingWhenExpression, |
| startPosition, |
| endPosition |
| ); |
| } |
| |
| @Test |
| public final void test_WhereClause_ConditionalExpressionMissing_1() throws Exception { |
| |
| String jpqlQuery = "SELECT e FROM Employee e WHERE"; |
| int startPosition = "SELECT e FROM Employee e ".length(); |
| int endPosition = jpqlQuery.length(); |
| |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| |
| testHasOnlyOneProblem( |
| problems, |
| WhereClause_MissingConditionalExpression, |
| startPosition, |
| endPosition |
| ); |
| } |
| |
| @Test |
| public final void test_WhereClause_ConditionalExpressionMissing_2() throws Exception { |
| |
| String jpqlQuery = "SELECT e FROM Employee e WHERE "; |
| int startPosition = "SELECT e FROM Employee e ".length(); |
| int endPosition = jpqlQuery.length(); |
| |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| |
| testHasOnlyOneProblem( |
| problems, |
| WhereClause_MissingConditionalExpression, |
| startPosition, |
| endPosition |
| ); |
| } |
| |
| @Test |
| public final void test_WhereClause_InvalidConditionalExpression_1() throws Exception { |
| |
| String jpqlQuery = "SELECT e FROM Employee e WHERE e.name <> 'JPQL'"; |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| |
| testDoesNotHaveProblem( |
| problems, |
| WhereClause_InvalidConditionalExpression |
| ); |
| } |
| |
| @Test |
| public final void test_WhereClause_InvalidConditionalExpression_2() throws Exception { |
| |
| String jpqlQuery = "SELECT e FROM Employee e WHERE LENGTH(e.name)"; |
| int startPosition = "SELECT e FROM Employee e WHERE ".length(); |
| int endPosition = jpqlQuery.length(); |
| |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| |
| testHasOnlyOneProblem( |
| problems, |
| WhereClause_InvalidConditionalExpression, |
| startPosition, |
| endPosition |
| ); |
| } |
| |
| @Test |
| public final void test_WhereClause_InvalidConditionalExpression_3() throws Exception { |
| |
| String jpqlQuery = "select e from Employee e join e.address a where foo() = 1"; |
| int startPosition = "select e from Employee e join e.address a where ".length(); |
| int endPosition = jpqlQuery.length(); |
| |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| |
| testHasOnlyOneProblem( |
| problems, |
| WhereClause_InvalidConditionalExpression, |
| startPosition, |
| endPosition |
| ); |
| } |
| |
| @Test |
| public final void test_WhereClause_InvalidConditionalExpression_4() throws Exception { |
| |
| String jpqlQuery = "delete from Address as a where current_date "; |
| int startPosition = "delete from Address as a where ".length(); |
| int endPosition = "delete from Address as a where current_date".length(); |
| |
| List<JPQLQueryProblem> problems = validate(jpqlQuery); |
| |
| testHasOnlyOneProblem( |
| problems, |
| WhereClause_InvalidConditionalExpression, |
| startPosition, |
| endPosition |
| ); |
| } |
| } |