/******************************************************************************* | |
* Copyright (c) 2006, 2014 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 v1.0 and Eclipse Distribution License v. 1.0 | |
* which accompanies this distribution. | |
* The Eclipse Public License is available at http://www.eclipse.org/legal/epl-v10.html | |
* and the Eclipse Distribution License is available at | |
* http://www.eclipse.org/org/documents/edl-v10.php. | |
* | |
* 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() throws Exception { | |
return new JPQLQueryStringFormatter() { | |
public String format(String jpqlQuery) { | |
return jpqlQuery.replace("SELECT)", "SELECT )"); | |
} | |
}; | |
} | |
private JPQLQueryStringFormatter buildFormatter_10(final String jpqlQuery) { | |
return new JPQLQueryStringFormatter() { | |
public String format(String query) { | |
return jpqlQuery; | |
} | |
}; | |
} | |
private JPQLQueryStringFormatter buildFormatter_2() throws Exception { | |
return new JPQLQueryStringFormatter() { | |
public String format(String jpqlQuery) { | |
return jpqlQuery.replace("(DISTINCT)", "(DISTINCT )"); | |
} | |
}; | |
} | |
private JPQLQueryStringFormatter buildFormatter_4() throws Exception { | |
return new JPQLQueryStringFormatter() { | |
public String format(String jpqlQuery) { | |
return jpqlQuery.replace(",)", ", )"); | |
} | |
}; | |
} | |
private JPQLQueryStringFormatter buildFormatter_5() throws Exception { | |
return new JPQLQueryStringFormatter() { | |
public String format(String jpqlQuery) { | |
return jpqlQuery.replace(",)", ", )"); | |
} | |
}; | |
} | |
private JPQLQueryStringFormatter buildFormatter_6() throws Exception { | |
return new JPQLQueryStringFormatter() { | |
public String format(String jpqlQuery) { | |
return jpqlQuery.replace(",)", ", )"); | |
} | |
}; | |
} | |
private JPQLQueryStringFormatter buildFormatter_7() { | |
return new JPQLQueryStringFormatter() { | |
public String format(String jpqlQuery) { | |
return jpqlQuery.replace("0,)", "0, )"); | |
} | |
}; | |
} | |
private JPQLQueryStringFormatter buildFormatter_8() { | |
return new JPQLQueryStringFormatter() { | |
public String format(String jpqlQuery) { | |
return jpqlQuery.replace(",,", ", ,"); | |
} | |
}; | |
} | |
private JPQLQueryStringFormatter buildFormatter_9() { | |
return new JPQLQueryStringFormatter() { | |
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 | |
); | |
} | |
} |