/*
 * Copyright (c) 2006, 2021 Oracle and/or its affiliates. All rights reserved.
 *
 * This program and the accompanying materials are made available under the
 * terms of the Eclipse Public License v. 2.0 which is available at
 * http://www.eclipse.org/legal/epl-2.0,
 * or the Eclipse Distribution License v. 1.0 which is available at
 * http://www.eclipse.org/org/documents/edl-v10.php.
 *
 * SPDX-License-Identifier: EPL-2.0 OR BSD-3-Clause
 */

// Contributors:
//     Oracle - initial API and implementation
//
package org.eclipse.persistence.jpa.tests.jpql.parser;

import org.eclipse.persistence.jpa.jpql.ExpressionTools;
import org.eclipse.persistence.jpa.jpql.JPAVersion;
import org.eclipse.persistence.jpa.jpql.parser.AbsExpression;
import org.eclipse.persistence.jpa.jpql.parser.AbstractConditionalClause;
import org.eclipse.persistence.jpa.jpql.parser.AbstractDoubleEncapsulatedExpression;
import org.eclipse.persistence.jpa.jpql.parser.AbstractEncapsulatedExpression;
import org.eclipse.persistence.jpa.jpql.parser.AbstractFromClause;
import org.eclipse.persistence.jpa.jpql.parser.AbstractOrderByClause;
import org.eclipse.persistence.jpa.jpql.parser.AbstractPathExpression;
import org.eclipse.persistence.jpa.jpql.parser.AbstractSchemaName;
import org.eclipse.persistence.jpa.jpql.parser.AbstractSelectClause;
import org.eclipse.persistence.jpa.jpql.parser.AbstractSelectStatement;
import org.eclipse.persistence.jpa.jpql.parser.AbstractSingleEncapsulatedExpression;
import org.eclipse.persistence.jpa.jpql.parser.AbstractTripleEncapsulatedExpression;
import org.eclipse.persistence.jpa.jpql.parser.AdditionExpression;
import org.eclipse.persistence.jpa.jpql.parser.AllOrAnyExpression;
import org.eclipse.persistence.jpa.jpql.parser.AndExpression;
import org.eclipse.persistence.jpa.jpql.parser.ArithmeticFactor;
import org.eclipse.persistence.jpa.jpql.parser.AsOfClause;
import org.eclipse.persistence.jpa.jpql.parser.AvgFunction;
import org.eclipse.persistence.jpa.jpql.parser.BadExpression;
import org.eclipse.persistence.jpa.jpql.parser.BetweenExpression;
import org.eclipse.persistence.jpa.jpql.parser.CaseExpression;
import org.eclipse.persistence.jpa.jpql.parser.CastExpression;
import org.eclipse.persistence.jpa.jpql.parser.CoalesceExpression;
import org.eclipse.persistence.jpa.jpql.parser.CollectionExpression;
import org.eclipse.persistence.jpa.jpql.parser.CollectionMemberDeclaration;
import org.eclipse.persistence.jpa.jpql.parser.CollectionMemberExpression;
import org.eclipse.persistence.jpa.jpql.parser.CollectionValuedPathExpression;
import org.eclipse.persistence.jpa.jpql.parser.ComparisonExpression;
import org.eclipse.persistence.jpa.jpql.parser.CompoundExpression;
import org.eclipse.persistence.jpa.jpql.parser.ConcatExpression;
import org.eclipse.persistence.jpa.jpql.parser.ConnectByClause;
import org.eclipse.persistence.jpa.jpql.parser.ConstructorExpression;
import org.eclipse.persistence.jpa.jpql.parser.CountFunction;
import org.eclipse.persistence.jpa.jpql.parser.DatabaseType;
import org.eclipse.persistence.jpa.jpql.parser.DateTime;
import org.eclipse.persistence.jpa.jpql.parser.DefaultEclipseLinkJPQLGrammar;
import org.eclipse.persistence.jpa.jpql.parser.DefaultJPQLGrammar;
import org.eclipse.persistence.jpa.jpql.parser.DeleteClause;
import org.eclipse.persistence.jpa.jpql.parser.DeleteStatement;
import org.eclipse.persistence.jpa.jpql.parser.DivisionExpression;
import org.eclipse.persistence.jpa.jpql.parser.EmptyCollectionComparisonExpression;
import org.eclipse.persistence.jpa.jpql.parser.EntityTypeLiteral;
import org.eclipse.persistence.jpa.jpql.parser.EntryExpression;
import org.eclipse.persistence.jpa.jpql.parser.ExistsExpression;
import org.eclipse.persistence.jpa.jpql.parser.Expression;
import org.eclipse.persistence.jpa.jpql.parser.ExtractExpression;
import org.eclipse.persistence.jpa.jpql.parser.FromClause;
import org.eclipse.persistence.jpa.jpql.parser.FunctionExpression;
import org.eclipse.persistence.jpa.jpql.parser.GroupByClause;
import org.eclipse.persistence.jpa.jpql.parser.HavingClause;
import org.eclipse.persistence.jpa.jpql.parser.HierarchicalQueryClause;
import org.eclipse.persistence.jpa.jpql.parser.IdentificationVariable;
import org.eclipse.persistence.jpa.jpql.parser.IdentificationVariableDeclaration;
import org.eclipse.persistence.jpa.jpql.parser.InExpression;
import org.eclipse.persistence.jpa.jpql.parser.IndexExpression;
import org.eclipse.persistence.jpa.jpql.parser.InputParameter;
import org.eclipse.persistence.jpa.jpql.parser.JPQLExpression;
import org.eclipse.persistence.jpa.jpql.parser.JPQLGrammar;
import org.eclipse.persistence.jpa.jpql.parser.JPQLStatementBNF;
import org.eclipse.persistence.jpa.jpql.parser.Join;
import org.eclipse.persistence.jpa.jpql.parser.KeywordExpression;
import org.eclipse.persistence.jpa.jpql.parser.LengthExpression;
import org.eclipse.persistence.jpa.jpql.parser.LikeExpression;
import org.eclipse.persistence.jpa.jpql.parser.LocateExpression;
import org.eclipse.persistence.jpa.jpql.parser.LogicalExpression;
import org.eclipse.persistence.jpa.jpql.parser.LowerExpression;
import org.eclipse.persistence.jpa.jpql.parser.MaxFunction;
import org.eclipse.persistence.jpa.jpql.parser.MinFunction;
import org.eclipse.persistence.jpa.jpql.parser.ModExpression;
import org.eclipse.persistence.jpa.jpql.parser.MultiplicationExpression;
import org.eclipse.persistence.jpa.jpql.parser.NotExpression;
import org.eclipse.persistence.jpa.jpql.parser.NullComparisonExpression;
import org.eclipse.persistence.jpa.jpql.parser.NullExpression;
import org.eclipse.persistence.jpa.jpql.parser.NullIfExpression;
import org.eclipse.persistence.jpa.jpql.parser.NumericLiteral;
import org.eclipse.persistence.jpa.jpql.parser.ObjectExpression;
import org.eclipse.persistence.jpa.jpql.parser.OnClause;
import org.eclipse.persistence.jpa.jpql.parser.OrExpression;
import org.eclipse.persistence.jpa.jpql.parser.OrderByClause;
import org.eclipse.persistence.jpa.jpql.parser.OrderByItem;
import org.eclipse.persistence.jpa.jpql.parser.OrderByItem.NullOrdering;
import org.eclipse.persistence.jpa.jpql.parser.OrderByItem.Ordering;
import org.eclipse.persistence.jpa.jpql.parser.OrderSiblingsByClause;
import org.eclipse.persistence.jpa.jpql.parser.RangeVariableDeclaration;
import org.eclipse.persistence.jpa.jpql.parser.RegexpExpression;
import org.eclipse.persistence.jpa.jpql.parser.ResultVariable;
import org.eclipse.persistence.jpa.jpql.parser.SelectClause;
import org.eclipse.persistence.jpa.jpql.parser.SelectStatement;
import org.eclipse.persistence.jpa.jpql.parser.SimpleFromClause;
import org.eclipse.persistence.jpa.jpql.parser.SimpleSelectClause;
import org.eclipse.persistence.jpa.jpql.parser.SimpleSelectStatement;
import org.eclipse.persistence.jpa.jpql.parser.SizeExpression;
import org.eclipse.persistence.jpa.jpql.parser.SqrtExpression;
import org.eclipse.persistence.jpa.jpql.parser.StartWithClause;
import org.eclipse.persistence.jpa.jpql.parser.StateFieldPathExpression;
import org.eclipse.persistence.jpa.jpql.parser.StringLiteral;
import org.eclipse.persistence.jpa.jpql.parser.SubExpression;
import org.eclipse.persistence.jpa.jpql.parser.SubstringExpression;
import org.eclipse.persistence.jpa.jpql.parser.SubtractionExpression;
import org.eclipse.persistence.jpa.jpql.parser.SumFunction;
import org.eclipse.persistence.jpa.jpql.parser.TableExpression;
import org.eclipse.persistence.jpa.jpql.parser.TableVariableDeclaration;
import org.eclipse.persistence.jpa.jpql.parser.TreatExpression;
import org.eclipse.persistence.jpa.jpql.parser.TrimExpression;
import org.eclipse.persistence.jpa.jpql.parser.TrimExpression.Specification;
import org.eclipse.persistence.jpa.jpql.parser.TypeExpression;
import org.eclipse.persistence.jpa.jpql.parser.UnionClause;
import org.eclipse.persistence.jpa.jpql.parser.UnknownExpression;
import org.eclipse.persistence.jpa.jpql.parser.UpdateClause;
import org.eclipse.persistence.jpa.jpql.parser.UpdateItem;
import org.eclipse.persistence.jpa.jpql.parser.UpdateStatement;
import org.eclipse.persistence.jpa.jpql.parser.UpperExpression;
import org.eclipse.persistence.jpa.jpql.parser.WhenClause;
import org.eclipse.persistence.jpa.jpql.parser.WhereClause;
import org.eclipse.persistence.jpa.tests.jpql.JPQLBasicTest;
import static org.eclipse.persistence.jpa.jpql.parser.AbstractExpression.*;
import static org.eclipse.persistence.jpa.jpql.parser.Expression.*;
import static org.eclipse.persistence.jpa.tests.jpql.parser.JPQLParserTester.*;
import static org.eclipse.persistence.jpa.tests.jpql.parser.JPQLQueryBuilder.*;
import static org.junit.Assert.*;

/**
 * This abstract class provides the functionality to test the parsed tree representation of a JPQL
 * query by traversing the tree and comparing each node.
 * <p>
 * Note: This class provides the {@link ExpressionTester} for all JPQL grammars (1.0, 2.0 and 2.1),
 * as well as for EclipseLink (all versions).
 *
 * @version 2.6
 * @since 2.3
 * @author Pascal Filion
 */
@SuppressWarnings({"nls", "unused" /* For the extra import statement, see bug 330740 */ })
public abstract class JPQLParserTest extends JPQLBasicTest {

    @JPQLGrammarTestHelper
    private JPQLGrammar jpqlGrammar;

    protected JPQLGrammar getGrammar() {
        return jpqlGrammar;
    }

    protected final boolean isEclipseLinkProvider() {
        return DefaultEclipseLinkJPQLGrammar.PROVIDER_NAME == jpqlGrammar.getProvider();
    }

    protected final boolean isGenericProvider() {
        return DefaultJPQLGrammar.PROVIDER_NAME == jpqlGrammar.getProvider();
    }

    protected final boolean isJPA1_0() {
        return jpqlGrammar.getJPAVersion() == JPAVersion.VERSION_1_0;
    }

    protected final boolean isJPA2_0() {
        return jpqlGrammar.getJPAVersion() == JPAVersion.VERSION_2_0;
    }

    protected final boolean isJPA2_1() {
        return jpqlGrammar.getJPAVersion() == JPAVersion.VERSION_2_1;
    }

    /**
     * Tests the parsing of the given JPQL query by comparing the parsed tree ({@link JPQLExpression})
     * with the given tester, which is an equivalent representation of the parsed tree.
     * <p>
     * The parsing system will have the tolerance turned on.
     *
     * @param jpqlQuery The JPQL query to parse and to test the parsed tree representation
     * @param expressionTester The tester used to verify the parsed tree is correctly representing the
     * JPQL query
     */
    protected void testInvalidQuery(String jpqlQuery, ExpressionTester expressionTester) {
        testQuery(jpqlQuery, expressionTester, JPQLStatementBNF.ID, JPQLQueryStringFormatter.DEFAULT, true);
    }

    /**
     * Tests the parsing of the given JPQL query by comparing the parsed tree ({@link JPQLExpression})
     * with the given tester, which is an equivalent representation of the parsed tree.
     * <p>
     * The parsing system will have the tolerance turned on.
     *
     * @param jpqlQuery The JPQL query to parse and to test the parsed tree representation
     * @param expressionTester The tester used to verify the parsed tree is correctly representing the
     * JPQL query
     * @param jpqlGrammar The {@link JPQLGrammar} used to determine how to parse the JPQL query
     * before it is used to test the generated string
     */
    protected void testInvalidQuery(String jpqlQuery,
                                    ExpressionTester expressionTester,
                                    JPQLGrammar jpqlGrammar) {

        testQuery(jpqlQuery, expressionTester, jpqlGrammar, JPQLStatementBNF.ID, JPQLQueryStringFormatter.DEFAULT, true);
    }

    /**
     * Tests the parsing of the given JPQL query by comparing the parsed tree ({@link JPQLExpression})
     * with the given tester, which is an equivalent representation of the parsed tree.
     * <p>
     * The parsing system will have the tolerance turned on.
     *
     * @param jpqlQuery The JPQL query to parse and to test the parsed tree representation
     * @param expressionTester The tester used to verify the parsed tree is correctly representing the
     * JPQL query
     * @param formatter This formatter is used to personalized the formatting of the JPQL query
     * before it is used to test the generated string
     */
    protected void testInvalidQuery(String jpqlQuery,
                                    ExpressionTester expressionTester,
                                    JPQLQueryStringFormatter formatter) {

        testQuery(jpqlQuery, expressionTester, JPQLStatementBNF.ID, formatter, true);
    }

    /**
     * Tests the parsing of the given JPQL query by comparing the parsed tree ({@link JPQLExpression})
     * with the given tester, which is an equivalent representation of the parsed tree.
     * <p>
     * The parsing system will have the tolerance turned on.
     *
     * @param jpqlQuery The JPQL query to parse and to test the parsed tree representation
     * @param expressionTester The tester used to verify the parsed tree is correctly representing the
     * JPQL query
     * @param jpqlQueryBNFId The unique identifier of the
     * {@link org.eclipse.persistence.jpa.jpql.parser.JPQLQueryBNF JPQLQueryBNF}
     */
    protected void testInvalidQuery(String jpqlQuery,
                                    ExpressionTester expressionTester,
                                    String jpqlQueryBNFId) {

        testQuery(jpqlQuery, expressionTester, jpqlQueryBNFId, JPQLQueryStringFormatter.DEFAULT, true);
    }

    /**
     * Tests the parsing of the given JPQL query by comparing the parsed tree ({@link JPQLExpression})
     * with the given tester, which is an equivalent representation of the parsed tree.
     * <p>
     * The parsing system will have the tolerance turned on.
     *
     * @param jpqlQuery The JPQL query to parse and to test the parsed tree representation
     * @param expressionTester The tester used to verify the parsed tree is correctly representing the
     * JPQL query
     * @param jpqlQueryBNFId The unique identifier of the
     * {@link org.eclipse.persistence.jpa.jpql.parser.JPQLQueryBNF JPQLQueryBNF}
     * @param formatter This formatter is used to personalized the formatting of the JPQL query
     * before it is used to test the generated string
     */
    protected void testInvalidQuery(String jpqlQuery,
                                    ExpressionTester expressionTester,
                                    String jpqlQueryBNFId,
                                    JPQLQueryStringFormatter formatter) {

        testQuery(jpqlQuery, expressionTester, jpqlQueryBNFId, formatter, true);
    }

    /**
     * Tests parsing the given JPQL query by comparing the parsed tree ({@link JPQLExpression}) with
     * the given tester, which is an equivalent representation of the parsed tree.
     * <p>
     * This method test both parsing modes: tolerant and non-tolerant. When the tolerant mode is
     * turned on, it means it will parse valid/complete and invalid/incomplete JPQL queries. When the
     * tolerant mode is turned off, it means the JPQL query has to be complete and has to be
     * grammatically valid.
     *
     * @param jpqlQuery The JPQL query to parse and to test the parsed tree representation
     * @param expressionTester The tester used to verify the parsed tree is correctly representing the
     * JPQL query
     */
    protected void testQuery(String jpqlQuery, ExpressionTester expressionTester) {
        testQuery(jpqlQuery, expressionTester, JPQLStatementBNF.ID, JPQLQueryStringFormatter.DEFAULT, true);
        testQuery(jpqlQuery, expressionTester, JPQLStatementBNF.ID, JPQLQueryStringFormatter.DEFAULT, false);
    }

    /**
     * Tests the parsing of the given JPQL query by comparing the parsed tree ({@link JPQLExpression})
     * with the given tester, which is an equivalent representation of the parsed tree.
     * <p>
     * This method test both parsing modes: tolerant and non-tolerant. When the tolerant mode is
     * turned on, it means it will parse valid/complete and invalid/incomplete JPQL queries. When the
     * tolerant mode is turned off, it means the JPQL query has to be complete and has to be
     * grammatically valid.
     *
     * @param jpqlQuery The JPQL query to parse and to test the parsed tree representation
     * @param expressionTester The tester used to verify the parsed tree is correctly representing the
     * JPQL query
     * @param jpqlGrammar The {@link JPQLGrammar} used to determine how to parse the JPQL query
     */
    protected void testQuery(String jpqlQuery,
                             ExpressionTester expressionTester,
                             JPQLGrammar jpqlGrammar) {

        testQuery(jpqlQuery, expressionTester, jpqlGrammar, JPQLStatementBNF.ID, JPQLQueryStringFormatter.DEFAULT, true);
        testQuery(jpqlQuery, expressionTester, jpqlGrammar, JPQLStatementBNF.ID, JPQLQueryStringFormatter.DEFAULT, false);
    }

    /**
     * Tests the parsing of the given JPQL query by comparing the parsed tree ({@link JPQLExpression})
     * with the given tester, which is an equivalent representation of the parsed tree.
     * <p>
     * This method test both parsing modes: tolerant and non-tolerant. When the tolerant mode is
     * turned on, it means it will parse valid/complete and invalid/incomplete JPQL queries. When the
     * tolerant mode is turned off, it means the JPQL query has to be complete and has to be
     * grammatically valid.
     *
     * @param jpqlQuery The JPQL query to parse and to test the parsed tree representation
     * @param expressionTester The tester used to verify the parsed tree is correctly representing the
     * JPQL query
     * @param jpqlGrammar The {@link JPQLGrammar} used to determine how to parse the JPQL query
     * @param formatter This formatter is used to personalized the formatting of the JPQL query
     * before it is used to test the generated string
     */
    protected void testQuery(String jpqlQuery,
                             ExpressionTester expressionTester,
                             JPQLGrammar jpqlGrammar,
                             JPQLQueryStringFormatter formatter) {

        testQuery(jpqlQuery, expressionTester, jpqlGrammar, JPQLStatementBNF.ID, formatter, true);
        testQuery(jpqlQuery, expressionTester, jpqlGrammar, JPQLStatementBNF.ID, formatter, false);
    }

    /**
     * Tests the parsing of the given JPQL query by comparing the parsed tree ({@link JPQLExpression})
     * with the given tester, which is an equivalent representation of the parsed tree.
     * <p>
     * This method test both parsing modes: tolerant and non-tolerant. When the tolerant mode is
     * turned on, it means it will parse valid/complete and invalid/incomplete JPQL queries. When the
     * tolerant mode is turned off, it means the JPQL query has to be complete and has to be
     * grammatically valid.
     *
     * @param jpqlQuery The JPQL query to parse and to test the parsed tree representation
     * @param expressionTester The tester used to verify the parsed tree is correctly representing the
     * JPQL query
     * @param jpqlQueryBNFId The unique identifier of the
     * {@link org.eclipse.persistence.jpa.jpql.parser.JPQLQueryBNF JPQLQueryBNF}
     * @param formatter This formatter is used to personalized the formatting of the JPQL query
     * before it is used to test the generated string
     */
    protected void testQuery(String jpqlQuery,
                             ExpressionTester expressionTester,
                             JPQLGrammar jpqlGrammar,
                             String jpqlQueryBNFId,
                             JPQLQueryStringFormatter formatter) {

        testQuery(jpqlQuery, expressionTester, jpqlGrammar, jpqlQueryBNFId, formatter, true);
        testQuery(jpqlQuery, expressionTester, jpqlGrammar, jpqlQueryBNFId, formatter, false);
    }

    /**
     * Tests the parsing of the given JPQL query by comparing the parsed tree ({@link JPQLExpression})
     * with the given tester, which is an equivalent representation of the parsed tree.
     *
     * @param jpqlQuery The JPQL query to parse and to test the parsed tree representation
     * @param expressionTester The tester used to verify the parsed tree is correctly representing the
     * JPQL query
     * @param jpqlGrammar The {@link JPQLGrammar} used to determine how to parse the JPQL query
     * @param jpqlQueryBNFId The unique identifier of the
     * {@link org.eclipse.persistence.jpa.jpql.parser.JPQLQueryBNF JPQLQueryBNF}
     * @param formatter This formatter is used to personalized the formatting of the JPQL query
     * before it is used to test the generated string
     * @param tolerant Determines if the parsing system should be tolerant, meaning if it should try
     * to parse grammatically invalid or incomplete queries
     */
    protected void testQuery(String jpqlQuery,
                             ExpressionTester expressionTester,
                             JPQLGrammar jpqlGrammar,
                             String jpqlQueryBNFId,
                             JPQLQueryStringFormatter formatter,
                             boolean tolerant) {

        JPQLExpression jpqlExpression = buildQuery(jpqlQuery, jpqlGrammar, jpqlQueryBNFId, formatter, tolerant);

        if (expressionTester.getClass() != JPQLExpressionTester.class) {
            expressionTester = jpqlExpression(expressionTester);
        }

        expressionTester.test(jpqlExpression);
    }

    /**
     * Tests the parsing of the given JPQL query by comparing the parsed tree ({@link JPQLExpression})
     * with the given tester, which is an equivalent representation of the parsed tree.
     * <p>
     * This method test both parsing modes: tolerant and non-tolerant. When the tolerant mode is
     * turned on, it means it will parse valid/complete and invalid/incomplete JPQL queries. When the
     * tolerant mode is turned off, it means the JPQL query has to be complete and has to be
     * grammatically valid.
     *
     * @param jpqlQuery The JPQL query to parse and to test the parsed tree representation
     * @param expressionTester The tester used to verify the parsed tree is correctly representing the
     * JPQL query
     * @param formatter This formatter is used to personalized the formatting of the JPQL query
     * before it is used to test the generated string
     */
    protected void testQuery(String jpqlQuery,
                             ExpressionTester expressionTester,
                             JPQLQueryStringFormatter formatter) {

        testQuery(jpqlQuery, expressionTester, JPQLStatementBNF.ID, formatter, true);
        testQuery(jpqlQuery, expressionTester, JPQLStatementBNF.ID, formatter, false);
    }

    /**
     * Tests the parsing of the given JPQL query by comparing the parsed tree ({@link JPQLExpression})
     * with the given tester, which is an equivalent representation of the parsed tree.
     * <p>
     * This method test both parsing modes: tolerant and non-tolerant. When the tolerant mode is
     * turned on, it means it will parse valid/complete and invalid/incomplete JPQL queries. When the
     * tolerant mode is turned off, it means the JPQL query has to be complete and has to be
     * grammatically valid.
     *
     * @param jpqlQuery The JPQL query to parse and to test the parsed tree representation
     * @param expressionTester The tester used to verify the parsed tree is correctly representing the
     * JPQL query
     * @param jpqlQueryBNFId The unique identifier of the {@link org.eclipse.persistence.jpa.jpql.parser.JPQLQueryBNF JPQLQueryBNF}
     */
    protected void testQuery(String jpqlQuery,
                             ExpressionTester expressionTester,
                             String jpqlQueryBNFId) {

        testQuery(jpqlQuery, expressionTester, jpqlQueryBNFId, JPQLQueryStringFormatter.DEFAULT, true);
        testQuery(jpqlQuery, expressionTester, jpqlQueryBNFId, JPQLQueryStringFormatter.DEFAULT, false);
    }

    /**
     * Tests the parsing of the given JPQL query by comparing the parsed tree ({@link JPQLExpression})
     * with the given tester, which is an equivalent representation of the parsed tree.
     * <p>
     * This method test both parsing modes: tolerant and non-tolerant. When the tolerant mode is
     * turned on, it means it will parse valid/complete and invalid/incomplete JPQL queries. When the
     * tolerant mode is turned off, it means the JPQL query has to be complete and has to be
     * grammatically valid.
     *
     * @param jpqlQuery The JPQL query to parse and to test the parsed tree representation
     * @param expressionTester The tester used to verify the parsed tree is correctly representing the
     * JPQL query
     * @param jpqlQueryBNFId The unique identifier of the {@link org.eclipse.persistence.jpa.jpql.parser.JPQLQueryBNF JPQLQueryBNF}
     * @param formatter This formatter is used to personalized the formatting of the JPQL query
     * before it is used to test the generated string
     */
    protected void testQuery(String jpqlQuery,
                             ExpressionTester expressionTester,
                             String jpqlQueryBNFId,
                             JPQLQueryStringFormatter formatter) {

        testQuery(jpqlQuery, expressionTester, jpqlQueryBNFId, formatter, true);
        testQuery(jpqlQuery, expressionTester, jpqlQueryBNFId, formatter, false);
    }

    /**
     * Tests the parsing of the given JPQL query by comparing the parsed tree ({@link JPQLExpression})
     * with the given tester, which is an equivalent representation of the parsed tree.
     *
     * @param jpqlQuery The JPQL query to parse and to test the parsed tree representation
     * @param expressionTester The tester used to verify the parsed tree is correctly representing the
     * JPQL query
     * @param jpqlQueryBNFId The unique identifier of the
     * {@link org.eclipse.persistence.jpa.jpql.parser.JPQLQueryBNF JPQLQueryBNF}
     * @param formatter This formatter is used to personalized the formatting of the JPQL query
     * before it is used to test the generated string
     * @param tolerant Determines if the parsing system should be tolerant, meaning if it should try
     * to parse grammatically invalid or incomplete queries
     */
    protected void testQuery(String jpqlQuery,
                             ExpressionTester expressionTester,
                             String jpqlQueryBNFId,
                             JPQLQueryStringFormatter formatter,
                             boolean tolerant) {

        testQuery(jpqlQuery, expressionTester, jpqlGrammar, jpqlQueryBNFId, formatter, tolerant);
    }

    /**
     * Tests the parsing of the given JPQL query by comparing the parsed tree ({@link JPQLExpression})
     * with the given tester, which is an equivalent representation of the parsed tree.
     * <p>
     * The parsing system will have the tolerance turned off.
     *
     * @param jpqlQuery The JPQL query to parse and to test the parsed tree representation
     * @param expressionTester The tester used to verify the parsed tree is correctly representing the
     * JPQL query
     */
    protected void testValidQuery(String jpqlQuery, ExpressionTester expressionTester) {
        testQuery(jpqlQuery, expressionTester, JPQLStatementBNF.ID, JPQLQueryStringFormatter.DEFAULT, false);
    }

    /**
     * Tests the parsing of the given JPQL query by comparing the parsed tree ({@link JPQLExpression})
     * with the given tester, which is an equivalent representation of the parsed tree.
     * <p>
     * The parsing system will have the tolerance turned off.
     *
     * @param jpqlQuery The JPQL query to parse and to test the parsed tree representation
     * @param expressionTester The tester used to verify the parsed tree is correctly representing the
     * JPQL query
     * @param formatter This formatter is used to personalized the formatting of the JPQL query
     * before it is used to test the generated string
     */
    protected void testValidQuery(String jpqlQuery,
                                  ExpressionTester expressionTester,
                                  JPQLQueryStringFormatter formatter) {

        testQuery(jpqlQuery, expressionTester, JPQLStatementBNF.ID, formatter, false);
    }

    /**
     * Tests the parsing of the given JPQL query by comparing the parsed tree ({@link JPQLExpression})
     * with the given tester, which is an equivalent representation of the parsed tree.
     * <p>
     * The parsing system will have the tolerance turned off.
     *
     * @param jpqlQuery The JPQL query to parse and to test the parsed tree representation
     * @param expressionTester The tester used to verify the parsed tree is correctly representing the
     * JPQL query
     * @param jpqlQueryBNFId The unique identifier of the
     * {@link org.eclipse.persistence.jpa.jpql.parser.JPQLQueryBNF JPQLQueryBNF}
     */
    protected void testValidQuery(String jpqlQuery,
                                  ExpressionTester expressionTester,
                                  String jpqlQueryBNFId) {

        testQuery(jpqlQuery, expressionTester, jpqlQueryBNFId, JPQLQueryStringFormatter.DEFAULT, false);
    }

    /**
     * Tests the parsing of the given JPQL query by comparing the parsed tree ({@link JPQLExpression})
     * with the given tester, which is an equivalent representation of the parsed tree.
     * <p>
     * The parsing system will have the tolerance turned off.
     *
     * @param jpqlQuery The JPQL query to parse and to test the parsed tree representation
     * @param expressionTester The tester used to verify the parsed tree is correctly representing the
     * JPQL query
     * @param jpqlQueryBNFId The unique identifier of the
     * {@link org.eclipse.persistence.jpa.jpql.parser.JPQLQueryBNF JPQLQueryBNF}
     * @param formatter This formatter is used to personalized the formatting of the JPQL query
     * before it is used to test the generated string
     */
    protected void testValidQuery(String jpqlQuery,
                                  ExpressionTester expressionTester,
                                  String jpqlQueryBNFId,
                                  JPQLQueryStringFormatter formatter) {

        testQuery(jpqlQuery, expressionTester, jpqlQueryBNFId, formatter, false);
    }

    public static final class AbsExpressionTester extends AbstractSingleEncapsulatedExpressionTester {

        protected AbsExpressionTester(ExpressionTester expression) {
            super(expression);
        }

        @Override
        protected Class<? extends AbstractSingleEncapsulatedExpression> expressionType() {
            return AbsExpression.class;
        }

        @Override
        protected String identifier() {
            return ABS;
        }
    }

    public static abstract class AbstractConditionalClauseTester extends AbstractExpressionTester {

        private ExpressionTester conditionalExpression;
        public boolean hasSpaceAfterIdentifier;

        protected AbstractConditionalClauseTester(ExpressionTester conditionalExpression) {
            super();
            this.conditionalExpression   = conditionalExpression;
            this.hasSpaceAfterIdentifier = !conditionalExpression.isNull();
        }

        protected abstract Class<? extends AbstractConditionalClause> expressionType();

        protected abstract String identifier();

        @Override
        public void test(Expression expression) {

            assertInstance(expression, expressionType());

            AbstractConditionalClause conditionalClause = (AbstractConditionalClause) expression;
            assertEquals(toString(),                      conditionalClause.toParsedText());
            assertEquals(!conditionalExpression.isNull(), conditionalClause.hasConditionalExpression());
            assertEquals(hasSpaceAfterIdentifier,         conditionalClause.hasSpaceAfterIdentifier());

            conditionalExpression.test(conditionalClause.getConditionalExpression());
        }

        @Override
        public String toString() {
            StringBuilder sb = new StringBuilder();
            sb.append(identifier());
            if (hasSpaceAfterIdentifier) {
                sb.append(SPACE);
            }
            sb.append(conditionalExpression);
            return sb.toString();
        }
    }

    public static abstract class AbstractDoubleEncapsulatedExpressionTester extends AbstractEncapsulatedExpressionTester {

        private ExpressionTester firstExpression;
        public boolean hasComma;
        public boolean hasSpaceAfterComma;
        private ExpressionTester secondExpression;

        protected AbstractDoubleEncapsulatedExpressionTester(ExpressionTester firstExpression,
                                                             ExpressionTester secondExpression) {

            super();
            this.hasComma           = true;
            this.hasSpaceAfterComma = true;
            this.firstExpression    = firstExpression;
            this.secondExpression   = secondExpression;
        }

        @Override
        protected abstract Class<? extends AbstractDoubleEncapsulatedExpression> expressionType();

        @Override
        protected boolean hasEncapsulatedExpression() {
            return !firstExpression.isNull() || hasComma || !secondExpression.isNull();
        }

        @Override
        public void test(Expression expression) {
            super.test(expression);

            AbstractDoubleEncapsulatedExpression abstractDoubleEncapsulatedExpression = (AbstractDoubleEncapsulatedExpression) expression;
            assertEquals(!firstExpression.isNull(),  abstractDoubleEncapsulatedExpression.hasFirstExpression());
            assertEquals(!secondExpression.isNull(), abstractDoubleEncapsulatedExpression.hasSecondExpression());
            assertEquals(hasComma,                   abstractDoubleEncapsulatedExpression.hasComma());
            assertEquals(hasSpaceAfterComma,         abstractDoubleEncapsulatedExpression.hasSpaceAfterComma());

            firstExpression .test(abstractDoubleEncapsulatedExpression.getFirstExpression());
            secondExpression.test(abstractDoubleEncapsulatedExpression.getSecondExpression());
        }

        @Override
        protected void toStringEncapsulatedExpression(StringBuilder sb) {
            sb.append(firstExpression);
            if (hasComma) {
                sb.append(COMMA);
            }
            if (hasSpaceAfterComma) {
                sb.append(SPACE);
            }
            sb.append(secondExpression);
        }
    }

    public static abstract class AbstractEncapsulatedExpressionTester extends AbstractExpressionTester {

        public boolean hasLeftParenthesis;
        public boolean hasRightParenthesis;

        protected AbstractEncapsulatedExpressionTester() {
            super();
            this.hasLeftParenthesis  = true;
            this.hasRightParenthesis = true;
        }

        protected abstract Class<? extends AbstractEncapsulatedExpression> expressionType();

        protected abstract boolean hasEncapsulatedExpression();

        protected abstract String identifier();

        @Override
        public void test(Expression expression) {
            assertInstance(expression, expressionType());

            AbstractEncapsulatedExpression abstractEncapsulatedExpression = (AbstractEncapsulatedExpression) expression;
            assertEquals(toString(),                  abstractEncapsulatedExpression.toParsedText());
            assertEquals(hasLeftParenthesis,          abstractEncapsulatedExpression.hasLeftParenthesis());
            assertEquals(hasRightParenthesis,         abstractEncapsulatedExpression.hasRightParenthesis());
            assertEquals(hasEncapsulatedExpression(), abstractEncapsulatedExpression.hasEncapsulatedExpression());
        }

        @Override
        public final String toString() {
            StringBuilder sb = new StringBuilder();
            sb.append(identifier());
            if (hasLeftParenthesis) {
                sb.append(LEFT_PARENTHESIS);
            }
            else if (hasEncapsulatedExpression()) {
                sb.append(SPACE);
            }
            toStringEncapsulatedExpression(sb);
            if (hasRightParenthesis) {
                sb.append(RIGHT_PARENTHESIS);
            }
            return sb.toString();
        }

        protected abstract void toStringEncapsulatedExpression(StringBuilder sb);
    }

    /**
     * The abstract definition of an {@link ExpressionTester}.
     */
    public static abstract class AbstractExpressionTester implements ExpressionTester {

        @Override
        public final AdditionExpressionTester add(ExpressionTester expression) {
            return JPQLParserTester.add(this, expression);
        }

        @Override
        public final AndExpressionTester and(ExpressionTester expression) {
            return JPQLParserTester.and(this, expression);
        }

        protected final void assertInstance(Expression expression,
                                            Class<? extends Expression> expressionType) {

            Class<? extends Expression> expressionClass = expression.getClass();

            if (expressionClass != expressionType &&
               !expressionType.isAssignableFrom(expressionClass)) {

                StringBuilder sb = new StringBuilder();
                sb.append("Expecting ");
                sb.append(expressionType.getSimpleName());
                sb.append(" but was ");
                sb.append(expressionClass.getSimpleName());
                sb.append(" for [");
                sb.append(expression.toParsedText());
                sb.append("]");

                fail(sb.toString());
            }
        }

        @Override
        public final BetweenExpressionTester between(ExpressionTester lowerBoundExpression,
                                                     ExpressionTester upperBoundExpression) {

            return JPQLParserTester.between(this, lowerBoundExpression, upperBoundExpression);
        }

        @Override
        public final ComparisonExpressionTester different(ExpressionTester expression) {
            return JPQLParserTester.different(this, expression);
        }

        @Override
        public final DivisionExpressionTester divide(ExpressionTester expression) {
            return JPQLParserTester.division(this, expression);
        }

        @Override
        public final ComparisonExpressionTester equal(ExpressionTester expression) {
            return JPQLParserTester.equal(this, expression);
        }

        @Override
        public final ComparisonExpressionTester greaterThan(ExpressionTester expression) {
            return JPQLParserTester.greaterThan(this, expression);
        }

        @Override
        public final ComparisonExpressionTester greaterThanOrEqual(ExpressionTester expression) {
            return JPQLParserTester.greaterThanOrEqual(this, expression);
        }

        @Override
        public final InExpressionTester in(ExpressionTester... inItems) {
            if (inItems.length == 1) {
                return JPQLParserTester.in(this, inItems[0]);
            }
            return JPQLParserTester.in(this, inItems);
        }

        @Override
        public final InExpressionTester in(String inputParameter) {
            return JPQLParserTester.in(this, inputParameter);
        }

        @Override
        public final EmptyCollectionComparisonExpressionTester isEmpty() {
            return JPQLParserTester.isEmpty(this);
        }

        @Override
        public final EmptyCollectionComparisonExpressionTester isNotEmpty() {
            return JPQLParserTester.isNotEmpty(this);
        }

        @Override
        public boolean isNull() {
            return false;
        }

        @Override
        public final LikeExpressionTester like(ExpressionTester patternValue) {
            return JPQLParserTester.like(this, patternValue);
        }

        @Override
        public final LikeExpressionTester like(ExpressionTester patternValue,
                                               ExpressionTester escapeCharacter) {

            return JPQLParserTester.like(this, patternValue, escapeCharacter);
        }

        @Override
        public final ComparisonExpressionTester lowerThan(ExpressionTester expression) {
            return JPQLParserTester.lowerThan(this, expression);
        }

        @Override
        public final ComparisonExpressionTester lowerThanOrEqual(ExpressionTester expression) {
            return JPQLParserTester.lowerThanOrEqual(this, expression);
        }

        @Override
        public final CollectionMemberExpressionTester member(ExpressionTester collectionPath) {
            return JPQLParserTester.member(this, collectionPath);
        }

        @Override
        public final CollectionMemberExpressionTester memberOf(ExpressionTester collectionPath) {
            return JPQLParserTester.memberOf(this, collectionPath);
        }

        @Override
        public final MultiplicationExpressionTester multiply(ExpressionTester expression) {
            return JPQLParserTester.multiplication(this, expression);
        }

        @Override
        public final BetweenExpressionTester notBetween(ExpressionTester lowerBoundExpression,
                                                        ExpressionTester upperBoundExpression) {

            return JPQLParserTester.notBetween(this, lowerBoundExpression, upperBoundExpression);
        }

        @Override
        public final ComparisonExpressionTester notEqual(ExpressionTester expression) {
            return JPQLParserTester.notEqual(this, expression);
        }

        @Override
        public final InExpressionTester notIn(ExpressionTester... inItems) {
            if (inItems.length == 1) {
                return JPQLParserTester.notIn(this, inItems[0]);
            }
            return JPQLParserTester.notIn(this, inItems);
        }

        @Override
        public final InExpressionTester notIn(String inputParameter) {
            return JPQLParserTester.notIn(this, inputParameter);
        }

        @Override
        public final LikeExpressionTester notLike(ExpressionTester expression) {
            return JPQLParserTester.notLike(this, expression);
        }

        @Override
        public final LikeExpressionTester notLike(ExpressionTester expression,
                                                  ExpressionTester escapeCharacter) {

            return JPQLParserTester.notLike(this, expression, escapeCharacter);
        }

        @Override
        public final ExpressionTester notMember(ExpressionTester collectionPath) {
            return JPQLParserTester.notMember(this, collectionPath);
        }

        @Override
        public final ExpressionTester notMemberOf(ExpressionTester collectionPath) {
            return JPQLParserTester.notMemberOf(this, collectionPath);
        }

        @Override
        public final OrExpressionTester or(ExpressionTester expression) {
            return JPQLParserTester.or(this, expression);
        }

        @Override
        public final RegexpExpressionTester regexp(StringLiteralTester patternValue) {
            return JPQLParserTester.regexp(this, patternValue);
        }

        @Override
        public final SubtractionExpressionTester subtract(ExpressionTester expression) {
            return JPQLParserTester.subtract(this, expression);
        }
    }

    public static abstract class AbstractFromClauseTester extends AbstractExpressionTester {

        private ExpressionTester asOfClause;
        private ExpressionTester declaration;
        private boolean hasSpaceAfterDeclaration;
        public boolean hasSpaceAfterFrom;
        private boolean hasSpaceAfterHierarchicalQueryClause;
        private ExpressionTester hierarchicalQueryClause;

        protected AbstractFromClauseTester(ExpressionTester declaration,
                                           ExpressionTester hierarchicalQueryClause,
                                           ExpressionTester asOfClause) {
            super();
            this.hasSpaceAfterFrom                    = true;
            this.asOfClause                           = asOfClause;
            this.declaration                          = declaration;
            this.hierarchicalQueryClause              = hierarchicalQueryClause;
            this.hasSpaceAfterDeclaration             = !declaration.isNull() && (!hierarchicalQueryClause.isNull() || !asOfClause.isNull());
            this.hasSpaceAfterHierarchicalQueryClause = !hierarchicalQueryClause.isNull() && !asOfClause.isNull();
        }

        @Override
        public void test(Expression expression) {
            assertInstance(expression, AbstractFromClause.class);

            AbstractFromClause fromClause = (AbstractFromClause) expression;
            assertEquals(toString(),                           fromClause.toParsedText());
            assertEquals(hasSpaceAfterFrom,                    fromClause.hasSpaceAfterFrom());
            assertEquals(!declaration.isNull(),                fromClause.hasDeclaration());
            assertEquals(hasSpaceAfterDeclaration,             fromClause.hasSpaceAfterDeclaration());
            assertEquals(!hierarchicalQueryClause.isNull(),    fromClause.hasHierarchicalQueryClause());
            assertEquals(hasSpaceAfterHierarchicalQueryClause, fromClause.hasSpaceAfterHierarchicalQueryClause());
            assertEquals(!asOfClause.isNull(),                 fromClause.hasAsOfClause());

            declaration.test(fromClause.getDeclaration());
            hierarchicalQueryClause.test(fromClause.getHierarchicalQueryClause());
            asOfClause.test(fromClause.getAsOfClause());
        }

        @Override
        public String toString() {
            StringBuilder sb = new StringBuilder();
            sb.append(FROM);
            if (hasSpaceAfterFrom) {
                sb.append(SPACE);
            }
            sb.append(declaration);
            if (hasSpaceAfterDeclaration) {
                sb.append(SPACE);
            }
            sb.append(hierarchicalQueryClause);
            if (hasSpaceAfterHierarchicalQueryClause) {
                sb.append(SPACE);
            }
            sb.append(asOfClause);
            return sb.toString();
        }
    }

    public static abstract class AbstractOrderByClauseTester extends AbstractExpressionTester {

        public boolean hasSpaceAfterIdentifier;
        private ExpressionTester orderByItems;

        protected AbstractOrderByClauseTester(ExpressionTester orderByItems) {
            super();
            this.orderByItems            = orderByItems;
            this.hasSpaceAfterIdentifier = !orderByItems.isNull();
        }

        protected abstract String identifier();

        @Override
        public void test(Expression expression) {
            assertInstance(expression, AbstractOrderByClause.class);

            AbstractOrderByClause orderByClause = (AbstractOrderByClause) expression;
            assertEquals(toString(),              orderByClause.toParsedText());
            assertEquals(!orderByItems.isNull(),  orderByClause.hasOrderByItems());
            assertEquals(hasSpaceAfterIdentifier, orderByClause.hasSpaceAfterIdentifier());

            orderByItems.test(orderByClause.getOrderByItems());
        }

        @Override
        public String toString() {
            StringBuilder sb = new StringBuilder();
            sb.append(identifier());
            if (hasSpaceAfterIdentifier) {
                sb.append(SPACE);
            }
            sb.append(orderByItems);
            return sb.toString();
        }
    }

    public static abstract class AbstractPathExpressionTester extends AbstractExpressionTester {

        private boolean endsWithDot;
        private ExpressionTester identificationVariable;
        private boolean startsWithDot;
        private String value;

        protected AbstractPathExpressionTester(ExpressionTester identificationVariable, String value) {

            super();

            this.value                  = value;
            this.identificationVariable = identificationVariable;
            this.startsWithDot          = (identificationVariable.toString().length() == 0) && (value.indexOf(DOT) > -1);

            if (value.length() > 1) {
                endsWithDot = value.charAt(value.length() - 1) == DOT;
            }
        }

        @Override
        public void test(Expression expression) {

            assertInstance(expression, AbstractPathExpression.class);

            AbstractPathExpression abstractPathExpression = (AbstractPathExpression) expression;
            assertEquals(toString(),                       abstractPathExpression.toParsedText());
            assertEquals(!identificationVariable.isNull(), abstractPathExpression.hasIdentificationVariable());
            assertEquals(endsWithDot,                      abstractPathExpression.endsWithDot());
            assertEquals(startsWithDot,                    abstractPathExpression.startsWithDot());

            identificationVariable.test(abstractPathExpression.getIdentificationVariable());
        }

        @Override
        public String toString() {
            StringBuilder sb = new StringBuilder();
            sb.append(identificationVariable);
            if (startsWithDot || (sb.length() > 0)) {
                sb.append(DOT);
            }
            sb.append(value);
            return sb.toString();
        }
    }

    public static final class AbstractSchemaNameTester extends AbstractExpressionTester {

        private String abstractSchemaName;

        protected AbstractSchemaNameTester(String abstractSchemaName) {
            super();
            this.abstractSchemaName = abstractSchemaName;
        }

        @Override
        public void test(Expression expression) {
            assertInstance(expression, AbstractSchemaName.class);

            AbstractSchemaName abstractSchemaName = (AbstractSchemaName) expression;
            assertEquals(toString(), abstractSchemaName.toParsedText());
        }

        @Override
        public String toString() {
            return abstractSchemaName;
        }
    }

    public static abstract class AbstractSelectClauseTester extends AbstractExpressionTester {

        private boolean hasDistinct;
        public boolean hasSpaceAfterDistinct;
        public boolean hasSpaceAfterSelect;
        private ExpressionTester selectExpression;

        protected AbstractSelectClauseTester(ExpressionTester selectExpression, boolean hasDistinct) {
            super();
            this.hasDistinct           = hasDistinct;
            this.hasSpaceAfterDistinct = hasDistinct;
            this.hasSpaceAfterSelect   = hasDistinct || !selectExpression.isNull();
            this.selectExpression      = selectExpression;
        }

        @Override
        public void test(Expression expression) {

            assertInstance(expression, AbstractSelectClause.class);
            AbstractSelectClause selectClause = (AbstractSelectClause) expression;

            assertEquals(toString(),                 selectClause.toParsedText());
            assertEquals(hasSpaceAfterSelect,        selectClause.hasSpaceAfterSelect());
            assertEquals(hasDistinct,                selectClause.hasDistinct());
            assertEquals(hasSpaceAfterDistinct,      selectClause.hasSpaceAfterDistinct());
            assertEquals(!selectExpression.isNull(), selectClause.hasSelectExpression());

            selectExpression.test(selectClause.getSelectExpression());
        }

        @Override
        public String toString() {
            StringBuilder sb = new StringBuilder();
            sb.append(SELECT);
            if (hasSpaceAfterSelect) {
                sb.append(SPACE);
            }
            if (hasDistinct) {
                sb.append(DISTINCT);
            }
            if (hasSpaceAfterDistinct) {
                sb.append(SPACE);
            }
            sb.append(selectExpression);
            return sb.toString();
        }
    }

    public static abstract class AbstractSelectStatementTester extends AbstractExpressionTester {

        private ExpressionTester fromClause;
        private ExpressionTester groupByClause;
        public boolean hasSpaceAfterFrom;
        public boolean hasSpaceAfterGroupBy;
        public boolean hasSpaceAfterSelect;
        public boolean hasSpaceAfterWhere;
        private ExpressionTester havingClause;
        private ExpressionTester selectClause;
        private ExpressionTester whereClause;

        protected AbstractSelectStatementTester(ExpressionTester selectClause,
                                                ExpressionTester fromClause,
                                                ExpressionTester whereClause,
                                                ExpressionTester groupByClause,
                                                ExpressionTester havingClause) {

            super();

            this.selectClause            = selectClause;
            this.fromClause              = fromClause;
            this.whereClause             = whereClause;
            this.groupByClause           = groupByClause;
            this.havingClause            = havingClause;

            hasSpaceAfterSelect  = !fromClause.isNull();
            hasSpaceAfterFrom    = !fromClause.isNull() && (!whereClause.isNull() || !groupByClause.isNull() || !havingClause.isNull());
            hasSpaceAfterWhere   = !whereClause.isNull() && (!groupByClause.isNull() || !havingClause.isNull());
            hasSpaceAfterGroupBy = !groupByClause.isNull() && !havingClause.isNull();
        }

        protected abstract Class<? extends AbstractSelectStatement> expressionType();

        @Override
        public void test(Expression expression) {
            assertInstance(expression, expressionType());

            AbstractSelectStatement selectStatement = (AbstractSelectStatement) expression;
            assertEquals(toString(),                        selectStatement.toParsedText());
            assertEquals(!selectClause .isNull(), selectStatement.hasSelectClause());
            assertEquals(!fromClause   .isNull(), selectStatement.hasFromClause());
            assertEquals(!whereClause  .isNull(), selectStatement.hasWhereClause());
            assertEquals(!groupByClause.isNull(), selectStatement.hasGroupByClause());
            assertEquals(!havingClause .isNull(), selectStatement.hasHavingClause());

            selectClause .test(selectStatement.getSelectClause());
            fromClause   .test(selectStatement.getFromClause());
            whereClause  .test(selectStatement.getWhereClause());
            groupByClause.test(selectStatement.getGroupByClause());
            havingClause .test(selectStatement.getHavingClause());
        }

        @Override
        public String toString() {

            StringBuilder sb = new StringBuilder();

            // SELECT
            sb.append(selectClause);

            if (hasSpaceAfterSelect && (sb.length() > 0) && (sb.charAt(sb.length() - 1) != ' ')) {
                sb.append(SPACE);
            }

            // FROM
            sb.append(fromClause);

            if (hasSpaceAfterFrom && sb.charAt(sb.length() - 1) != ' ') {
                sb.append(SPACE);
            }

            // WHERE
            sb.append(whereClause);

            if (hasSpaceAfterWhere && sb.charAt(sb.length() - 1) != ' ') {
                sb.append(SPACE);
            }

            // GROUP BY
            sb.append(groupByClause);

            if (hasSpaceAfterGroupBy && sb.charAt(sb.length() - 1) != ' ') {
                sb.append(SPACE);
            }

            // HAVING
            sb.append(havingClause);

            return sb.toString();
        }
    }

    public static abstract class AbstractSingleEncapsulatedExpressionTester extends AbstractEncapsulatedExpressionTester {

        private ExpressionTester expression;

        protected AbstractSingleEncapsulatedExpressionTester(ExpressionTester expression) {
            super();
            this.expression = expression;
        }

        @Override
        protected abstract Class<? extends AbstractSingleEncapsulatedExpression> expressionType();

        @Override
        protected boolean hasEncapsulatedExpression() {
            return !expression.isNull();
        }

        @Override
        public void test(Expression expression) {
            super.test(expression);

            AbstractSingleEncapsulatedExpression encapsulatedExpression = (AbstractSingleEncapsulatedExpression) expression;
            this.expression.test(encapsulatedExpression.getExpression());
        }

        @Override
        protected void toStringEncapsulatedExpression(StringBuilder sb) {
            sb.append(expression);
        }
    }

    public static abstract class AbstractTripleEncapsulatedExpressionTester extends AbstractEncapsulatedExpressionTester {

        private ExpressionTester firstExpression;
        public boolean hasFirstComma;
        public boolean hasSecondComma;
        public boolean hasSpaceAfterFirstComma;
        public boolean hasSpaceAfterSecondComma;
        private ExpressionTester secondExpression;
        private ExpressionTester thirdExpression;

        protected AbstractTripleEncapsulatedExpressionTester(ExpressionTester firstExpression,
                                                             ExpressionTester secondExpression,
                                                             ExpressionTester thirdExpression) {

            super();

            this.firstExpression  = firstExpression;
            this.secondExpression = secondExpression;
            this.thirdExpression  = thirdExpression;

            hasFirstComma  = !secondExpression.isNull();
            hasSecondComma = !thirdExpression.isNull();

            hasSpaceAfterFirstComma  = hasFirstComma;
            hasSpaceAfterSecondComma = hasSecondComma;
        }

        @Override
        protected abstract Class<? extends AbstractTripleEncapsulatedExpression> expressionType();

        @Override
        protected boolean hasEncapsulatedExpression() {
            return !firstExpression.isNull() || hasFirstComma || !secondExpression.isNull() || hasSecondComma || !thirdExpression.isNull();
        }

        @Override
        public void test(Expression expression) {
            super.test(expression);
            assertInstance(expression, AbstractTripleEncapsulatedExpression.class);

            AbstractTripleEncapsulatedExpression tripleExpression = (AbstractTripleEncapsulatedExpression) expression;
            assertEquals(toString(), tripleExpression.toParsedText());

            assertEquals(hasFirstComma,  tripleExpression.hasFirstComma());
            assertEquals(hasSecondComma, tripleExpression.hasSecondComma());

            assertEquals(hasSpaceAfterFirstComma,  tripleExpression.hasSpaceAfterFirstComma());
            assertEquals(hasSpaceAfterSecondComma, tripleExpression.hasSpaceAfterSecondComma());

            assertEquals(!firstExpression.isNull(),  tripleExpression.hasFirstExpression());
            assertEquals(!secondExpression.isNull(), tripleExpression.hasSecondExpression());
            assertEquals(!thirdExpression.isNull(),  tripleExpression.hasThirdExpression());

            firstExpression.test(tripleExpression.getFirstExpression());
            secondExpression.test(tripleExpression.getSecondExpression());
            thirdExpression.test(tripleExpression.getThirdExpression());
        }

        @Override
        protected void toStringEncapsulatedExpression(StringBuilder sb) {
            sb.append(firstExpression);
            if (hasFirstComma) {
                sb.append(COMMA);
            }
            if (hasSpaceAfterFirstComma) {
                sb.append(SPACE);
            }
            sb.append(secondExpression);
            if (hasSecondComma) {
                sb.append(COMMA);
            }
            if (hasSpaceAfterSecondComma) {
                sb.append(SPACE);
            }
            sb.append(thirdExpression);
        }
    }

    public static final class AdditionExpressionTester extends CompoundExpressionTester {

        protected AdditionExpressionTester(ExpressionTester leftExpression,
                                           ExpressionTester rightExpression) {

            super(leftExpression, rightExpression);
        }

        @Override
        protected Class<? extends CompoundExpression> expressionType() {
            return AdditionExpression.class;
        }

        @Override
        protected String identifier() {
            return PLUS;
        }
    }

    public static abstract class AggregateFunctionTester extends AbstractSingleEncapsulatedExpressionTester {

        public boolean hasDistinct;
        public boolean hasSpaceAfterDistinct;

        protected AggregateFunctionTester(ExpressionTester expression, boolean hasDistinct) {
            super(expression);
            this.hasDistinct = hasDistinct;
            this.hasSpaceAfterDistinct = hasDistinct;
        }

        @Override
        protected void toStringEncapsulatedExpression(StringBuilder sb) {

            if (hasDistinct) {
                sb.append(DISTINCT);
            }

            if (hasSpaceAfterDistinct) {
                sb.append(SPACE);
            }

            super.toStringEncapsulatedExpression(sb);
        }
    }

    public static final class AllOrAnyExpressionTester extends AbstractSingleEncapsulatedExpressionTester {

        private String identifier;

        protected AllOrAnyExpressionTester(String identifier, ExpressionTester expression) {
            super(expression);
            this.identifier = identifier;
        }

        @Override
        protected Class<? extends AbstractSingleEncapsulatedExpression> expressionType() {
            return AllOrAnyExpression.class;
        }

        @Override
        protected String identifier() {
            return identifier;
        }
    }

    public static final class AndExpressionTester extends LogicalExpressionTester {

        protected AndExpressionTester(ExpressionTester leftExpression,
                                      ExpressionTester rightExpression) {

            super(leftExpression, rightExpression);
        }

        @Override
        protected Class<? extends CompoundExpression> expressionType() {
            return AndExpression.class;
        }

        @Override
        protected String identifier() {
            return AND;
        }
    }

    public static final class ArithmeticFactorTester extends AbstractExpressionTester {

        private ExpressionTester expression;
        private String sign;

        protected ArithmeticFactorTester(String sign, ExpressionTester expression) {
            super();
            this.sign = sign;
            this.expression = expression;
        }

        @Override
        public void test(Expression expression) {
            assertInstance(expression, ArithmeticFactor.class);

            ArithmeticFactor factor = (ArithmeticFactor) expression;
            assertEquals(toString(),    factor.toParsedText());
            assertEquals(sign == MINUS, factor.isNegative());
            assertEquals(sign == PLUS,  factor.isPositive());

            this.expression.test(factor.getExpression());
        }

        @Override
        public String toString() {
            StringBuilder sb = new StringBuilder();
            sb.append(sign);
            sb.append(expression);
            return sb.toString();
        }
    }

    protected final static class AsOfClauseTester extends AbstractExpressionTester {

        private String category;
        private ExpressionTester expression;
        public boolean hasSpaceAfterCategory;
        public boolean hasSpaceAfterIdentifier;

        protected AsOfClauseTester(String category, ExpressionTester expression) {
            super();
            this.category                = category;
            this.expression              = expression;
            this.hasSpaceAfterIdentifier = (category != null) || !expression.isNull();
            this.hasSpaceAfterCategory   = (category != null) && !expression.isNull();
        }

        @Override
        public void test(Expression expression) {
            assertInstance(expression, AsOfClause.class);

            AsOfClause asOfClause = (AsOfClause) expression;
            assertEquals(toString(),                asOfClause.toParsedText());
            assertEquals(!this.expression.isNull(), asOfClause.hasExpression());
            assertEquals(hasSpaceAfterIdentifier,   asOfClause.hasSpaceAfterIdentifier());
            assertEquals(hasSpaceAfterCategory,     asOfClause.hasSpaceAfterCategory());

            this.expression.test(asOfClause.getExpression());
        }

        @Override
        public String toString() {
            StringBuilder sb = new StringBuilder();
            sb.append(AS_OF);
            if (hasSpaceAfterIdentifier) {
                sb.append(SPACE);
            }
            if (category != null) {
                sb.append(category);
            }
            if (hasSpaceAfterCategory) {
                sb.append(SPACE);
            }
            sb.append(expression);
            return sb.toString();
        }
    }

    public static final class AvgFunctionTester extends AggregateFunctionTester {

        protected AvgFunctionTester(ExpressionTester expression, boolean hasDistinct) {
            super(expression, hasDistinct);
        }

        @Override
        protected Class<? extends AbstractSingleEncapsulatedExpression> expressionType() {
            return AvgFunction.class;
        }

        @Override
        protected String identifier() {
            return AVG;
        }
    }

    public static final class BadExpressionTester extends AbstractExpressionTester {

        private ExpressionTester expression;

        protected BadExpressionTester(ExpressionTester expression) {
            super();
            this.expression = expression;
        }

        @Override
        public void test(Expression expression) {
            assertInstance(expression, BadExpression.class);

            BadExpression badExpression = (BadExpression) expression;
            assertEquals(toString(), badExpression.toParsedText());

            this.expression.test(badExpression.getExpression());
        }

        @Override
        public String toString() {
            return expression.toString();
        }
    }

    public static final class BetweenExpressionTester extends AbstractExpressionTester {

        private ExpressionTester expression;
        public boolean hasAnd;
        public boolean hasBetween;
        private boolean hasNot;
        public boolean hasSpaceAfterAnd;
        public boolean hasSpaceAfterBetween;
        public boolean hasSpaceAfterLowerBound;
        private ExpressionTester lowerBoundExpression;
        private ExpressionTester upperBoundExpression;

        protected BetweenExpressionTester(ExpressionTester expression,
                                          boolean hasNot,
                                          ExpressionTester lowerBoundExpression,
                                          ExpressionTester upperBoundExpression) {

            super();
            this.hasNot                  = hasNot;
            this.hasAnd                  = true;
            this.expression              = expression;
            this.hasSpaceAfterAnd        = true;
            this.hasSpaceAfterLowerBound = true;
            this.hasSpaceAfterBetween    = true;
            this.lowerBoundExpression    = lowerBoundExpression;
            this.upperBoundExpression    = upperBoundExpression;
        }

        @Override
        public void test(Expression expression) {
            assertInstance(expression, BetweenExpression.class);

            BetweenExpression betweenExpression = (BetweenExpression) expression;
            assertEquals(toString(),                     betweenExpression.toParsedText());
            assertEquals(!this.expression.isNull(),      betweenExpression.hasExpression());
            assertEquals(hasNot,                         betweenExpression.hasNot());
            assertEquals(hasAnd,                         betweenExpression.hasAnd());
            assertEquals(!lowerBoundExpression.isNull(), betweenExpression.hasLowerBoundExpression());
            assertEquals(hasSpaceAfterAnd,               betweenExpression.hasSpaceAfterAnd());
            assertEquals(hasSpaceAfterBetween,           betweenExpression.hasSpaceAfterBetween());
            assertEquals(hasSpaceAfterLowerBound,        betweenExpression.hasSpaceAfterLowerBound());
            assertEquals(!upperBoundExpression.isNull(), betweenExpression.hasUpperBoundExpression());

            this.expression.test(betweenExpression.getExpression());
            lowerBoundExpression.test(betweenExpression.getLowerBoundExpression());
            upperBoundExpression.test(betweenExpression.getUpperBoundExpression());
        }

        @Override
        public String toString() {
            StringBuilder sb = new StringBuilder();
            sb.append(expression);
            if (!expression.isNull()) {
                sb.append(SPACE);
            }
            if (hasNot) {
                sb.append(NOT);
                sb.append(SPACE);
            }
            sb.append(BETWEEN);
            if (hasSpaceAfterBetween) {
                sb.append(SPACE);
            }
            sb.append(lowerBoundExpression);
            if (hasSpaceAfterLowerBound) {
                sb.append(SPACE);
            }
            if (hasAnd) {
                sb.append(AND);
            }
            if (hasSpaceAfterAnd) {
                sb.append(SPACE);
            }
            sb.append(upperBoundExpression);
            return sb.toString();
        }
    }

    public static final class CaseExpressionTester extends AbstractExpressionTester {

        private ExpressionTester caseOperand;
        private ExpressionTester elseExpression;
        public boolean hasElse;
        public boolean hasEnd;
        public boolean hasSpaceAfterCase;
        public boolean hasSpaceAfterCaseOperand;
        public boolean hasSpaceAfterElse;
        public boolean hasSpaceAfterElseExpression;
        public boolean hasSpaceAfterWhenClauses;
        private ExpressionTester whenClauses;

        protected CaseExpressionTester(ExpressionTester caseOperand,
                                       ExpressionTester whenClauses,
                                       ExpressionTester elseExpression) {

            super();
            this.whenClauses                 = whenClauses;
            this.caseOperand                 = caseOperand;
            this.elseExpression              = elseExpression;
            this.hasElse                     = !elseExpression.isNull();
            this.hasEnd                      = true;
            this.hasSpaceAfterCase           = true;
            this.hasSpaceAfterElse           = hasElse;
            this.hasSpaceAfterElseExpression = hasElse;
            this.hasSpaceAfterCaseOperand    = !caseOperand.isNull();
            this.hasSpaceAfterWhenClauses    = !whenClauses.isNull();
        }

        @Override
        public void test(Expression expression) {

            assertInstance(expression, CaseExpression.class);

            CaseExpression caseExpression = (CaseExpression) expression;
            assertEquals(toString(),                  caseExpression.toParsedText());
            assertEquals(!caseOperand.isNull(),       caseExpression.hasCaseOperand());
            assertEquals(hasElse,                     caseExpression.hasElse());
            assertEquals(hasEnd,                      caseExpression.hasEnd());
            assertEquals(hasSpaceAfterCase,           caseExpression.hasSpaceAfterCase());
            assertEquals(hasSpaceAfterCaseOperand,    caseExpression.hasSpaceAfterCaseOperand());
            assertEquals(hasSpaceAfterElse,           caseExpression.hasSpaceAfterElse());
            assertEquals(hasSpaceAfterElseExpression, caseExpression.hasSpaceAfterElseExpression());
            assertEquals(hasSpaceAfterWhenClauses,    caseExpression.hasSpaceAfterWhenClauses());
            assertEquals(!whenClauses.isNull(),       caseExpression.hasWhenClauses());

            caseOperand.test(caseExpression.getCaseOperand());
            whenClauses.test(caseExpression.getWhenClauses());
            elseExpression.test(caseExpression.getElseExpression());
        }

        @Override
        public String toString() {
            StringBuilder sb = new StringBuilder();
            sb.append(CASE);
            if (hasSpaceAfterCase) {
                sb.append(SPACE);
            }
            sb.append(caseOperand);
            if (hasSpaceAfterCaseOperand) {
                sb.append(SPACE);
            }
            sb.append(whenClauses);
            if (hasSpaceAfterWhenClauses) {
                sb.append(SPACE);
            }
            if (hasElse) {
                sb.append(ELSE);
            }
            if (hasSpaceAfterElse) {
                sb.append(SPACE);
            }
            sb.append(elseExpression);
            if (hasSpaceAfterElseExpression) {
                sb.append(SPACE);
            }
            if (hasEnd) {
                sb.append(END);
            }
            return sb.toString();
        }
    }

    public static final class CastExpressionTester extends AbstractSingleEncapsulatedExpressionTester {

        private ExpressionTester databaseType;
        private boolean hasAs;
        public boolean hasSpaceAfterAs;
        public boolean hasSpaceAfterExpression;

        protected CastExpressionTester(ExpressionTester expression,
                                       boolean hasAs,
                                       ExpressionTester databaseType) {

            super(expression);
            this.hasAs                   = hasAs;
            this.databaseType            = databaseType;
            this.hasSpaceAfterAs         = hasAs && !databaseType.isNull();
            this.hasSpaceAfterExpression = !expression.isNull() && (hasAs || !databaseType.isNull());
        }

        @Override
        protected Class<CastExpression> expressionType() {
            return CastExpression.class;
        }

        @Override
        protected boolean hasEncapsulatedExpression() {
            return super.hasEncapsulatedExpression() || hasAs || !databaseType.isNull();
        }

        @Override
        protected String identifier() {
            return CAST;
        }

        @Override
        protected void toStringEncapsulatedExpression(StringBuilder sb) {
            super.toStringEncapsulatedExpression(sb);
            if (hasSpaceAfterExpression) {
                sb.append(SPACE);
            }
            if (hasAs) {
                sb.append(AS);
            }
            if (hasSpaceAfterAs) {
                sb.append(SPACE);
            }
            sb.append(databaseType);
        }
    }

    public static final class CoalesceExpressionTester extends AbstractSingleEncapsulatedExpressionTester {

        protected CoalesceExpressionTester(ExpressionTester expression) {
            super(expression);
        }

        @Override
        protected Class<? extends AbstractSingleEncapsulatedExpression> expressionType() {
            return CoalesceExpression.class;
        }

        @Override
        protected String identifier(){
            return COALESCE;
        }
    }

    public static final class CollectionExpressionTester extends AbstractExpressionTester {

        public Boolean[] commas;
        private ExpressionTester[] expressionTesters;
        public Boolean[] spaces;

        protected CollectionExpressionTester(ExpressionTester[] expressionTesters,
                                             Boolean[] commas,
                                             Boolean[] spaces) {

            super();
            this.expressionTesters = expressionTesters;
            this.spaces            = spaces;
            this.commas            = commas;
        }

        @Override
        public void test(Expression expression) {
            assertInstance(expression, CollectionExpression.class);

            CollectionExpression collectionExpression = (CollectionExpression) expression;
            assertEquals(toString(), collectionExpression.toParsedText());
            assertEquals(spaces.length, collectionExpression.childrenSize());
            assertEquals(commas.length, collectionExpression.childrenSize());
            assertEquals(expressionTesters.length, collectionExpression.childrenSize());

            // Expressions
            for (int index = expressionTesters.length; --index >= 0; ) {
                expressionTesters[index].test(collectionExpression.getChild(index));
            }

            // Spaces
            for (int index = 0, count = spaces.length; index < count; index++) {
                assertEquals(
                    "The flag for a space at " + index + " does not match",
                    spaces[index],
                    collectionExpression.hasSpace(index)
                );
            }

            // Commas
            for (int index = 0, count = commas.length; index < count; index++) {
                assertEquals(
                    "The flag for a comma at " + index + " does not match",
                    commas[index],
                    collectionExpression.hasComma(index)
                );
            }
        }

        @Override
        public String toString() {

            StringBuilder sb = new StringBuilder();

            for (int index = 0, count = expressionTesters.length; index < count; index++) {
                sb.append(expressionTesters[index]);

                if ((index < commas.length) && commas[index]) {
                    sb.append(COMMA);
                }

                if ((index < spaces.length) && spaces[index]) {
                    sb.append(SPACE);
                }
            }

            return sb.toString();
        }
    }

    public static final class CollectionMemberDeclarationTester extends AbstractExpressionTester {

        private ExpressionTester collectionValuedPath;
        public boolean hasAs;
        public boolean hasLeftParenthesis;
        public boolean hasRightParenthesis;
        public boolean hasSpaceAfterAs;
        public boolean hasSpaceAfterIn;
        public boolean hasSpaceAfterRightParenthesis;
        private ExpressionTester identificationVariable;

        protected CollectionMemberDeclarationTester(ExpressionTester collectionValuedPath,
                                                    boolean hasAs,
                                                    ExpressionTester identificationVariable) {

            super();
            this.hasAs                         = hasAs;
            this.hasSpaceAfterAs               = hasAs;
            this.hasLeftParenthesis            = true;
            this.hasRightParenthesis           = true;
            this.collectionValuedPath          = collectionValuedPath;
            this.identificationVariable        = identificationVariable;
            this.hasSpaceAfterRightParenthesis = hasAs || !identificationVariable.isNull();
        }

        @Override
        public void test(Expression expression) {
            assertInstance(expression, CollectionMemberDeclaration.class);

            CollectionMemberDeclaration collectionMemberDeclaration = (CollectionMemberDeclaration) expression;
            assertEquals(toString(),                       collectionMemberDeclaration.toParsedText());
            assertEquals(hasAs,                            collectionMemberDeclaration.hasAs());
            assertEquals(!collectionValuedPath.isNull(),   collectionMemberDeclaration.hasCollectionValuedPathExpression());
            assertEquals(!identificationVariable.isNull(), collectionMemberDeclaration.hasIdentificationVariable());
            assertEquals(hasLeftParenthesis,               collectionMemberDeclaration.hasLeftParenthesis());
            assertEquals(hasRightParenthesis,              collectionMemberDeclaration.hasRightParenthesis());
            assertEquals(hasSpaceAfterAs,                  collectionMemberDeclaration.hasSpaceAfterAs());
            assertEquals(hasSpaceAfterIn,                  collectionMemberDeclaration.hasSpaceAfterIn());
            assertEquals(hasSpaceAfterRightParenthesis,    collectionMemberDeclaration.hasSpaceAfterRightParenthesis());

            collectionValuedPath.test(collectionMemberDeclaration.getCollectionValuedPathExpression());
            identificationVariable.test(collectionMemberDeclaration.getIdentificationVariable());
        }

        @Override
        public String toString() {
            StringBuilder sb = new StringBuilder();
            sb.append(IN);
            if (hasSpaceAfterIn) {
                sb.append(SPACE);
            }
            else if (hasLeftParenthesis) {
                sb.append(LEFT_PARENTHESIS);
            }
            sb.append(collectionValuedPath);
            if (hasRightParenthesis) {
                sb.append(RIGHT_PARENTHESIS);
            }
            if (hasSpaceAfterRightParenthesis) {
                sb.append(SPACE);
            }
            if (hasAs) {
                sb.append(AS);
            }
            if (hasSpaceAfterAs) {
                sb.append(SPACE);
            }
            sb.append(identificationVariable);
            return sb.toString();
        }
    }

    public static final class CollectionMemberExpressionTester extends AbstractExpressionTester {

        private ExpressionTester collectionPath;
        private ExpressionTester entityExpression;
        private boolean hasNot;
        private boolean hasOf;
        public boolean hasSpaceAfterMember;
        public boolean hasSpaceAfterOf;

        protected CollectionMemberExpressionTester(ExpressionTester entityExpression,
                                                   boolean hasNot,
                                                   boolean hasOf,
                                                   ExpressionTester collectionPath) {

            super();
            this.hasNot                         = hasNot;
            this.hasOf                          = hasOf;
            this.hasSpaceAfterMember            = true;
            this.hasSpaceAfterOf                = hasOf;
            this.entityExpression               = entityExpression;
            this.collectionPath = collectionPath;
        }

        @Override
        public void test(Expression expression) {
            assertInstance(expression, CollectionMemberExpression.class);

            CollectionMemberExpression collectionMemberExpression = (CollectionMemberExpression) expression;
            assertEquals(toString(),                               collectionMemberExpression.toParsedText());
            assertEquals(!collectionPath.isNull(), collectionMemberExpression.hasCollectionValuedPathExpression());
            assertEquals(!entityExpression.isNull(),               collectionMemberExpression.hasEntityExpression());
            assertEquals(hasNot,                                   collectionMemberExpression.hasNot());
            assertEquals(hasSpaceAfterMember,                      collectionMemberExpression.hasSpaceAfterMember());
            assertEquals(hasOf,                                    collectionMemberExpression.hasOf());
            assertEquals(hasSpaceAfterOf,                          collectionMemberExpression.hasSpaceAfterOf());

            entityExpression.test(collectionMemberExpression.getEntityExpression());
            collectionPath.test(collectionMemberExpression.getCollectionValuedPathExpression());
        }

        @Override
        public String toString() {
            StringBuilder sb = new StringBuilder();
            sb.append(entityExpression);
            if (!entityExpression.isNull()) {
                sb.append(SPACE);
            }
            if (hasNot) {
                sb.append(NOT);
                sb.append(SPACE);
            }
            if (hasOf) {
                sb.append(MEMBER_OF);
                if (hasSpaceAfterOf) {
                    sb.append(SPACE);
                }
            }
            else {
                sb.append(MEMBER);
                if (hasSpaceAfterMember) {
                    sb.append(SPACE);
                }
            }
            sb.append(collectionPath);
            return sb.toString();
        }
    }

    public static final class CollectionValuedPathExpressionTester extends AbstractPathExpressionTester {

        protected CollectionValuedPathExpressionTester(ExpressionTester identificationVariable,
                                                       String value) {

            super(identificationVariable, value);
        }

        @Override
        public void test(Expression expression) {
            super.test(expression);
            assertInstance(expression, CollectionValuedPathExpression.class);
        }
    }

    public static final class ComparisonExpressionTester extends AbstractExpressionTester {

        private String comparator;
        public boolean hasSpaceAfterIdentifier;
        private ExpressionTester leftExpression;
        private ExpressionTester rightExpression;

        protected ComparisonExpressionTester(String comparator,
                                             ExpressionTester leftExpression,
                                             ExpressionTester rightExpression) {

            super();
            this.comparator              = comparator;
            this.leftExpression          = leftExpression;
            this.rightExpression         = rightExpression;
            this.hasSpaceAfterIdentifier = true;
        }

        @Override
        public void test(Expression expression) {
            assertInstance(expression, ComparisonExpression.class);

            ComparisonExpression comparisonExpression = (ComparisonExpression) expression;
            assertEquals(toString(),                comparisonExpression.toParsedText());
            assertEquals(!leftExpression.isNull(),  comparisonExpression.hasLeftExpression());
            assertEquals(!rightExpression.isNull(), comparisonExpression.hasRightExpression());
            assertEquals(hasSpaceAfterIdentifier,   comparisonExpression.hasSpaceAfterIdentifier());

            leftExpression .test(comparisonExpression.getLeftExpression());
            rightExpression.test(comparisonExpression.getRightExpression());
        }

        @Override
        public String toString() {
            StringBuilder sb = new StringBuilder();
            sb.append(leftExpression);
            if (!leftExpression.isNull()) {
                sb.append(SPACE);
            }
            sb.append(comparator);
            if (hasSpaceAfterIdentifier) {
                sb.append(SPACE);
            }
            sb.append(rightExpression);
            return sb.toString();
        }
    }

    public static abstract class CompoundExpressionTester extends AbstractExpressionTester {

        public boolean hasSpaceAfterIdentifier;
        private ExpressionTester leftExpression;
        private ExpressionTester rightExpression;

        protected CompoundExpressionTester(ExpressionTester leftExpression,
                                           ExpressionTester rightExpression) {

            super();
            this.leftExpression          = leftExpression;
            this.rightExpression         = rightExpression;
            this.hasSpaceAfterIdentifier = !rightExpression.isNull();
        }

        protected abstract Class<? extends CompoundExpression> expressionType();

        protected abstract String identifier();

        @Override
        public void test(Expression expression) {
            assertInstance(expression, expressionType());

            CompoundExpression compoundExpression = (CompoundExpression) expression;
            assertEquals(toString(),                compoundExpression.toParsedText());
            assertEquals(!leftExpression.isNull(),  compoundExpression.hasLeftExpression());
            assertEquals(!rightExpression.isNull(), compoundExpression.hasRightExpression());
            assertEquals(hasSpaceAfterIdentifier,   compoundExpression.hasSpaceAfterIdentifier());

            leftExpression .test(compoundExpression.getLeftExpression());
            rightExpression.test(compoundExpression.getRightExpression());
        }

        @Override
        public String toString() {

            StringBuilder sb = new StringBuilder();

            if (!leftExpression.isNull()) {
                sb.append(leftExpression);
                if (sb.charAt(sb.length() - 1) != SPACE) {
                    sb.append(SPACE);
                }
            }

            sb.append(identifier());

            if (hasSpaceAfterIdentifier) {
                sb.append(SPACE);
            }

            sb.append(rightExpression);
            return sb.toString();
        }
    }

    public static final class ConcatExpressionTester extends AbstractSingleEncapsulatedExpressionTester {

        protected ConcatExpressionTester(ExpressionTester expression) {
            super(expression);
        }

        @Override
        protected Class<? extends AbstractSingleEncapsulatedExpression> expressionType() {
            return ConcatExpression.class;
        }

        @Override
        protected String identifier() {
            return CONCAT;
        }
    }

    public static final class ConnectByClauseTester extends AbstractExpressionTester {

        private ExpressionTester expression;
        public boolean hasSpaceAfterConnectBy;

        protected ConnectByClauseTester(ExpressionTester expression) {
            super();
            this.expression             = expression;
            this.hasSpaceAfterConnectBy = !expression.isNull();
        }

        @Override
        public void test(Expression expression) {
            assertInstance(expression, ConnectByClause.class);

            ConnectByClause priorExpression = (ConnectByClause) expression;
            assertEquals(toString(),                priorExpression.toParsedText());
            assertEquals(hasSpaceAfterConnectBy,    priorExpression.hasSpaceAfterConnectBy());
            assertEquals(!this.expression.isNull(), priorExpression.hasExpression());

            this.expression.test(priorExpression.getExpression());
        }

        @Override
        public String toString() {
            StringBuilder sb = new StringBuilder();
            sb.append(CONNECT_BY);
            if (hasSpaceAfterConnectBy) {
                sb.append(SPACE);
            }
            sb.append(expression);
            return sb.toString();
        }
    }

    public static final class ConstructorExpressionTester extends AbstractExpressionTester {

        private String className;
        private ExpressionTester constructorItems;
        public boolean hasLeftParenthesis;
        public boolean hasRightParenthesis;
        public boolean hasSpaceAfterNew;

        protected ConstructorExpressionTester(String className, ExpressionTester constructorItems) {
            super();
            this.className           = className;
            this.constructorItems    = constructorItems;
            this.hasSpaceAfterNew    = true;
            this.hasLeftParenthesis  = true;
            this.hasRightParenthesis = true;
        }

        @Override
        public void test(Expression expression) {
            assertInstance(expression, ConstructorExpression.class);

            ConstructorExpression constructorExpression = (ConstructorExpression) expression;
            assertEquals(toString(),                 constructorExpression.toParsedText());
            assertEquals(!constructorItems.isNull(), constructorExpression.hasConstructorItems());
            assertEquals(hasSpaceAfterNew,           constructorExpression.hasSpaceAfterNew());
            assertEquals(hasLeftParenthesis,         constructorExpression.hasLeftParenthesis());
            assertEquals(hasRightParenthesis,        constructorExpression.hasRightParenthesis());

            constructorItems.test(constructorExpression.getConstructorItems());
        }

        @Override
        public String toString() {
            StringBuilder sb = new StringBuilder();
            sb.append(NEW);
            if (hasSpaceAfterNew) {
                sb.append(SPACE);
            }
            sb.append(className);
            if (hasLeftParenthesis) {
                sb.append(LEFT_PARENTHESIS);
            }
            sb.append(constructorItems);
            if (hasRightParenthesis) {
                sb.append(RIGHT_PARENTHESIS);
            }
            return sb.toString();
        }
    }

    public static final class CountFunctionTester extends AggregateFunctionTester {

        protected CountFunctionTester(ExpressionTester expression, boolean hasDistinct) {
            super(expression, hasDistinct);
        }

        @Override
        protected Class<? extends AbstractSingleEncapsulatedExpression> expressionType() {
            return CountFunction.class;
        }

        @Override
        protected String identifier() {
            return COUNT;
        }
    }

    public static final class DatabaseTypeTester extends AbstractDoubleEncapsulatedExpressionTester {

        private String databaseType;

        protected DatabaseTypeTester(String databaseType,
                                     ExpressionTester size,
                                     ExpressionTester precision) {

            super(size, precision);
            this.databaseType = databaseType;
        }

        @Override
        protected Class<DatabaseType> expressionType() {
            return DatabaseType.class;
        }

        @Override
        protected String identifier() {
            return databaseType;
        }
    }

    public static final class DateTimeTester extends AbstractExpressionTester {

        private String dateTime;

        protected DateTimeTester(String dateTime) {
            super();
            this.dateTime = dateTime;
        }

        @Override
        public void test(Expression expression) {
            assertInstance(expression, DateTime.class);

            DateTime dateTime = (DateTime) expression;
            assertEquals(toString(), dateTime.toParsedText());
        }

        @Override
        public String toString() {
            return dateTime;
        }
    }

    /**
     * Tester for {@link DeleteClause}.
     */
    public static final class DeleteClauseTester extends AbstractExpressionTester {

        public boolean hasFrom;
        public boolean hasSpaceAfterDelete;
        public boolean hasSpaceAfterFrom;
        private ExpressionTester rangeVariableDeclaration;

        protected DeleteClauseTester(ExpressionTester rangeVariableDeclaration) {
            super();
            this.hasFrom                  = true;
            this.hasSpaceAfterFrom        = true;
            this.hasSpaceAfterDelete      = true;
            this.rangeVariableDeclaration = rangeVariableDeclaration;
        }

        @Override
        public void test(Expression expression) {

            assertInstance(expression, DeleteClause.class);

            DeleteClause deleteClause = (DeleteClause) expression;
            assertEquals(toString(),                         deleteClause.toParsedText());
            assertEquals(hasSpaceAfterDelete,                deleteClause.hasSpaceAfterDelete());
            assertEquals(hasFrom,                            deleteClause.hasFrom());
            assertEquals(hasSpaceAfterFrom,                  deleteClause.hasSpaceAfterFrom());
            assertEquals(!rangeVariableDeclaration.isNull(), deleteClause.hasRangeVariableDeclaration());

            rangeVariableDeclaration.test(deleteClause.getRangeVariableDeclaration());
        }

        @Override
        public String toString() {
            StringBuilder sb = new StringBuilder();
            sb.append(DELETE);
            if (hasSpaceAfterDelete) {
                sb.append(SPACE);
            }
            if (hasFrom) {
                sb.append(FROM);
            }
            if (hasSpaceAfterFrom) {
                sb.append(SPACE);
            }
            sb.append(rangeVariableDeclaration);
            return sb.toString();
        }
    }

    public static final class DeleteStatementTester extends AbstractExpressionTester {

        private ExpressionTester deleteClause;
        public boolean hasSpaceAfterDeleteClause;
        private ExpressionTester whereClause;

        protected DeleteStatementTester(ExpressionTester deleteClause, ExpressionTester whereClause) {
            super();
            this.deleteClause              = deleteClause;
            this.whereClause               = whereClause;
            this.hasSpaceAfterDeleteClause = !whereClause.isNull();
        }

        @Override
        public void test(Expression expression) {

            assertInstance(expression, DeleteStatement.class);

            DeleteStatement deleteStatement = (DeleteStatement) expression;
            assertEquals(toString(),                deleteStatement.toParsedText());
            assertEquals(hasSpaceAfterDeleteClause, deleteStatement.hasSpaceAfterDeleteClause());
            assertEquals(!whereClause.isNull(),     deleteStatement.hasWhereClause());

            deleteClause.test(deleteStatement.getDeleteClause());
            whereClause .test(deleteStatement.getWhereClause());
        }

        @Override
        public String toString() {
            StringBuilder sb = new StringBuilder();
            sb.append(deleteClause);
            if (hasSpaceAfterDeleteClause) {
                sb.append(SPACE);
            }
            sb.append(whereClause);
            return sb.toString();
        }
    }

    public static final class DivisionExpressionTester extends CompoundExpressionTester {

        protected DivisionExpressionTester(ExpressionTester leftExpression,
                                           ExpressionTester rightExpression) {

            super(leftExpression, rightExpression);
        }

        @Override
        protected Class<? extends CompoundExpression> expressionType() {
            return DivisionExpression.class;
        }

        @Override
        protected String identifier() {
            return DIVISION;
        }
    }

    public static final class EmptyCollectionComparisonExpressionTester extends AbstractExpressionTester {

        private ExpressionTester collectionPath;
        private boolean hasNot;
        public boolean hasSpaceAfterIs;

        protected EmptyCollectionComparisonExpressionTester(ExpressionTester collectionPath,
                                                            boolean hasNot) {

            super();
            this.hasNot = hasNot;
            this.hasSpaceAfterIs = true;
            this.collectionPath = collectionPath;
        }

        @Override
        public void test(Expression expression) {
            assertInstance(expression, EmptyCollectionComparisonExpression.class);

            EmptyCollectionComparisonExpression emptyCollection = (EmptyCollectionComparisonExpression) expression;
            assertEquals(toString(),                               emptyCollection.toParsedText());
            assertEquals(!collectionPath.isNull(), emptyCollection.hasExpression());
            assertEquals(hasNot,                                   emptyCollection.hasNot());
            assertEquals(hasSpaceAfterIs,                          emptyCollection.hasSpaceAfterIs());

            collectionPath.test(emptyCollection.getExpression());
        }

        @Override
        public String toString() {
            StringBuilder sb = new StringBuilder();
            sb.append(collectionPath);
            if (!collectionPath.isNull()) {
                sb.append(SPACE);
            }
            sb.append(IS);
            if (hasSpaceAfterIs) {
                sb.append(SPACE);
            }
            if (hasNot) {
                sb.append(NOT);
                sb.append(SPACE);
            }
            sb.append(EMPTY);
            return sb.toString();
        }
    }

    public static final class EntityTypeLiteralTester extends AbstractExpressionTester {

        private String entityType;

        protected EntityTypeLiteralTester(String entityType) {
            super();
            this.entityType = entityType;
        }

        @Override
        public void test(Expression expression) {
            assertInstance(expression, EntityTypeLiteral.class);

            EntityTypeLiteral entityTypeLiteral = (EntityTypeLiteral) expression;
            assertEquals(toString(), entityTypeLiteral.toParsedText());
        }

        @Override
        public String toString() {
            return entityType;
        }
    }

    public static final class EntryExpressionTester extends AbstractSingleEncapsulatedExpressionTester {

        protected EntryExpressionTester(ExpressionTester identificationVariable) {
            super(identificationVariable);
        }

        @Override
        protected Class<? extends AbstractSingleEncapsulatedExpression> expressionType() {
            return EntryExpression.class;
        }

        @Override
        protected String identifier() {
            return ENTRY;
        }
    }

    public static final class ExistsExpressionTester extends AbstractSingleEncapsulatedExpressionTester {

        private boolean hasNot;

        protected ExistsExpressionTester(ExpressionTester subquery, boolean hasNot) {
            super(subquery);
            this.hasNot = hasNot;
        }

        @Override
        protected Class<? extends AbstractSingleEncapsulatedExpression> expressionType() {
            return ExistsExpression.class;
        }

        @Override
        protected String identifier() {
            return hasNot ? NOT_EXISTS : EXISTS;
        }

        @Override
        public void test(Expression expression) {
            super.test(expression);
            assertInstance(expression, ExistsExpression.class);

            ExistsExpression existsExpression = (ExistsExpression) expression;
            assertEquals(hasNot, existsExpression.hasNot());
        }
    }

    /**
     * This tester tests an {@link Expression} information to make sure it correctly parsed a section
     * of the query. This interface also adds helper method for easily creating a parsed tree
     * representation of the actual query parsed tree.
     */
    public static interface ExpressionTester {

        AdditionExpressionTester add(ExpressionTester expression);
        AndExpressionTester and(ExpressionTester expression);
        BetweenExpressionTester between(ExpressionTester lowerBoundExpression, ExpressionTester upperBoundExpression);
        ComparisonExpressionTester different(ExpressionTester expression);
        DivisionExpressionTester divide(ExpressionTester expression);
        ComparisonExpressionTester equal(ExpressionTester expression);
        ComparisonExpressionTester greaterThan(ExpressionTester expression);
        ComparisonExpressionTester greaterThanOrEqual(ExpressionTester expression);
        InExpressionTester in(ExpressionTester... inItems);
        InExpressionTester in(String inputParameter);
        EmptyCollectionComparisonExpressionTester isEmpty();
        EmptyCollectionComparisonExpressionTester isNotEmpty();

        /**
         * Determines whether this tester represents the {@link NullExpression}.
         *
         * @return <code>true</code> if this tester represents a <code>null</code> object;
         * <code>false</code> otherwise
         */
        boolean isNull();

        LikeExpressionTester like(ExpressionTester patternValue);
        LikeExpressionTester like(ExpressionTester patternValue, ExpressionTester escapeCharacter);
        ComparisonExpressionTester lowerThan(ExpressionTester expression);
        ComparisonExpressionTester lowerThanOrEqual(ExpressionTester expression);
        ExpressionTester member(ExpressionTester collectionPath);
        ExpressionTester memberOf(ExpressionTester collectionPath);
        MultiplicationExpressionTester multiply(ExpressionTester expression);
        BetweenExpressionTester notBetween(ExpressionTester lowerBoundExpression, ExpressionTester upperBoundExpression);
        ComparisonExpressionTester notEqual(ExpressionTester expression);
        InExpressionTester notIn(ExpressionTester... inItems);
        InExpressionTester notIn(String inputParameter);
        LikeExpressionTester notLike(ExpressionTester expression);
        LikeExpressionTester notLike(ExpressionTester expression, ExpressionTester escapeCharacter);
        ExpressionTester notMember(ExpressionTester collectionPath);
        ExpressionTester notMemberOf(ExpressionTester collectionPath);
        OrExpressionTester or(ExpressionTester expression);
        RegexpExpressionTester regexp(StringLiteralTester patternValue);
        SubtractionExpressionTester subtract(ExpressionTester expression);

        /**
         * Tests the given {@link Expression} internal data.
         */
        void test(Expression expression);
    }

    public static final class ExtractExpressionTester extends AbstractSingleEncapsulatedExpressionTester {

        private boolean hasFrom;
        public boolean hasSpaceAfterFrom;
        public boolean hasSpaceAfterPart;
        private String part;

        protected ExtractExpressionTester(String part, boolean hasFom, ExpressionTester expression) {
            super(expression);
            this.hasFrom           = hasFom;
            this.part              = (part != null) ? part : ExpressionTools.EMPTY_STRING;
            this.hasSpaceAfterPart = (part != null) && (hasFrom || !expression.isNull());
            this.hasSpaceAfterFrom = hasFom && !expression.isNull();
        }

        @Override
        protected Class<ExtractExpression> expressionType() {
            return ExtractExpression.class;
        }

        @Override
        protected boolean hasEncapsulatedExpression() {
            return super.hasEncapsulatedExpression() || hasFrom || ExpressionTools.stringIsNotEmpty(part);
        }

        @Override
        protected String identifier() {
            return EXTRACT;
        }

        @Override
        public void test(Expression expression) {
            super.test(expression);

            ExtractExpression extractExpression = (ExtractExpression) expression;
            assertEquals(part,              extractExpression.getDatePart());
            assertEquals(hasFrom,           extractExpression.hasFrom());
            assertSame  (hasSpaceAfterFrom, extractExpression.hasSpaceAfterFrom());
            assertSame  (hasSpaceAfterPart, extractExpression.hasSpaceAfterDatePart());
        }

        @Override
        protected void toStringEncapsulatedExpression(StringBuilder sb) {

            sb.append(part);

            if (hasSpaceAfterPart) {
                sb.append(SPACE);
            }

            if (hasFrom) {
                sb.append(FROM);
            }

            if (hasSpaceAfterFrom) {
                sb.append(SPACE);
            }

            super.toStringEncapsulatedExpression(sb);
        }
    }

    public static final class FromClauseTester extends AbstractFromClauseTester {

        protected FromClauseTester(ExpressionTester declarations,
                                   ExpressionTester hierarchicalQueryClause,
                                   ExpressionTester asOfClause) {

            super(declarations, hierarchicalQueryClause, asOfClause);
        }

        @Override
        public void test(Expression expression) {
            super.test(expression);
            assertInstance(expression, FromClause.class);
        }
    }

    public static final class FunctionExpressionTester extends AbstractSingleEncapsulatedExpressionTester {

        private String functionName;
        public boolean hasComma;
        public boolean hasSpaceAfterComma;
        private String identifier;

        protected FunctionExpressionTester(String identifier,
                                           String functionName,
                                           ExpressionTester funcItems) {

            super(funcItems);
            this.identifier = identifier;
            this.functionName = functionName;
            this.hasSpaceAfterComma = !funcItems.isNull();
            this.hasComma = !funcItems.isNull();
        }

        @Override
        protected Class<? extends AbstractSingleEncapsulatedExpression> expressionType() {
            return FunctionExpression.class;
        }

        @Override
        protected boolean hasEncapsulatedExpression() {
            return functionName.length() > 0 ||
                   hasComma                  ||
                   hasSpaceAfterComma        ||
                   super.hasEncapsulatedExpression();
        }

        @Override
        protected String identifier() {
            return identifier;
        }

        @Override
        public void test(Expression expression) {
            super.test(expression);

            FunctionExpression funcExpression = (FunctionExpression) expression;
            assertEquals(identifier,         funcExpression.getIdentifier());
            assertEquals(functionName,       funcExpression.getFunctionName());
            assertEquals(hasComma,           funcExpression.hasComma());
            assertEquals(hasSpaceAfterComma, funcExpression.hasSpaceAfterComma());
        }

        @Override
        protected void toStringEncapsulatedExpression(StringBuilder sb) {
            if (functionName != null) {
                sb.append(functionName);
            }
            if (hasComma) {
                sb.append(COMMA);
            }
            if (hasSpaceAfterComma) {
                sb.append(SPACE);
            }
            super.toStringEncapsulatedExpression(sb);
        }
    }

    public static final class GroupByClauseTester extends AbstractExpressionTester {

        private ExpressionTester groupByItems;
        public boolean hasSpaceAfterGroupBy;

        protected GroupByClauseTester(ExpressionTester groupByItems) {
            super();
            this.groupByItems         = groupByItems;
            this.hasSpaceAfterGroupBy = !groupByItems.isNull();
        }

        @Override
        public void test(Expression expression) {

            assertInstance(expression, GroupByClause.class);

            GroupByClause groupByClause = (GroupByClause) expression;
            assertEquals(toString(),             groupByClause.toParsedText());
            assertEquals(!groupByItems.isNull(), groupByClause.hasGroupByItems());
            assertEquals(hasSpaceAfterGroupBy,   groupByClause.hasSpaceAfterGroupBy());

            groupByItems.test(groupByClause.getGroupByItems());
        }

        @Override
        public String toString() {
            StringBuilder sb = new StringBuilder();
            sb.append(GROUP_BY);
            if (hasSpaceAfterGroupBy) {
                sb.append(SPACE);
            }
            sb.append(groupByItems);
            return sb.toString();
        }
    }

    public static final class HavingClauseTester extends AbstractConditionalClauseTester {

        protected HavingClauseTester(ExpressionTester conditionalExpression) {
            super(conditionalExpression);
        }

        @Override
        protected Class<? extends AbstractConditionalClause> expressionType() {
            return HavingClause.class;
        }

        @Override
        protected String identifier() {
            return HAVING;
        }
    }

    public static final class HierarchicalQueryClauseTester extends AbstractExpressionTester {

        private ExpressionTester connectByClause;
        public boolean hasSpaceAfterConnectByClause;
        public boolean hasSpaceAfterStartWithClause;
        private ExpressionTester orderSiblingsByClause;
        private ExpressionTester startWithClause;

        protected HierarchicalQueryClauseTester(ExpressionTester startWithClause,
                                                ExpressionTester connectByClause,
                                                ExpressionTester orderSiblingsByClause) {
            super();
            this.startWithClause              = startWithClause;
            this.connectByClause              = connectByClause;
            this.orderSiblingsByClause        = orderSiblingsByClause;
            this.hasSpaceAfterStartWithClause = !startWithClause.isNull() && !connectByClause.isNull();
            this.hasSpaceAfterConnectByClause = !connectByClause.isNull() && !orderSiblingsByClause.isNull();
        }

        @Override
        public void test(Expression expression) {
            assertInstance(expression, HierarchicalQueryClause.class);

            HierarchicalQueryClause clause = (HierarchicalQueryClause) expression;
            assertEquals(toString(),                      clause.toString());
            assertEquals(!startWithClause.isNull(),       clause.hasStartWithClause());
            assertEquals(!connectByClause.isNull(),       clause.hasConnectByClause());
            assertEquals(!orderSiblingsByClause.isNull(), clause.hasOrderSiblingsByClause());
            assertEquals(hasSpaceAfterStartWithClause,    clause.hasSpaceAfterStartWithClause());
            assertEquals(hasSpaceAfterConnectByClause,    clause.hasSpaceAfterConnectByClause());

            startWithClause.test(clause.getStartWithClause());
            connectByClause.test(clause.getConnectByClause());
            orderSiblingsByClause.test(clause.getOrderSiblingsByClause());
        }

        @Override
        public String toString() {
            StringBuilder sb = new StringBuilder();
            sb.append(startWithClause);
            if (hasSpaceAfterStartWithClause) {
                sb.append(SPACE);
            }
            sb.append(connectByClause);
            if (hasSpaceAfterConnectByClause) {
                sb.append(SPACE);
            }
            sb.append(orderSiblingsByClause);
            return sb.toString();
        }
    }

    public static final class IdentificationVariableDeclarationTester extends AbstractExpressionTester {

        public boolean hasSpace;
        private ExpressionTester joins;
        private ExpressionTester rangeVariableDeclaration;

        protected IdentificationVariableDeclarationTester(ExpressionTester rangeVariableDeclaration,
                                                          ExpressionTester joins) {

            super();
            this.rangeVariableDeclaration = rangeVariableDeclaration;
            this.hasSpace                 = !joins.isNull();
            this.joins                    = joins;
        }

        @Override
        public void test(Expression expression) {

            assertInstance(expression, IdentificationVariableDeclaration.class);

            IdentificationVariableDeclaration identificationVariableDeclaration = (IdentificationVariableDeclaration) expression;
            assertEquals(toString(),                         identificationVariableDeclaration.toParsedText());
            assertEquals(!rangeVariableDeclaration.isNull(), identificationVariableDeclaration.hasRangeVariableDeclaration());
            assertEquals(hasSpace,                           identificationVariableDeclaration.hasSpace());
            assertEquals(!joins.isNull(),                    identificationVariableDeclaration.hasJoins());

            rangeVariableDeclaration.test(identificationVariableDeclaration.getRangeVariableDeclaration());
            joins.test(identificationVariableDeclaration.getJoins());
        }

        @Override
        public String toString() {
            StringBuilder sb = new StringBuilder();
            sb.append(rangeVariableDeclaration);
            if (hasSpace) {
                sb.append(SPACE);
            }
            sb.append(joins);
            return sb.toString();
        }
    }

    public static final class IdentificationVariableTester extends AbstractExpressionTester {

        private String identificationVariable;
        private boolean virtual;
        private ExpressionTester virtualPathExpression;

        protected IdentificationVariableTester(String identificationVariable,
                                               boolean virtual,
                                               ExpressionTester virtualPathExpression) {
            super();
            this.virtual                = virtual;
            this.identificationVariable = identificationVariable;
            this.virtualPathExpression  = virtualPathExpression;
        }

        @Override
        public boolean isNull() {
            return virtual && virtualPathExpression.isNull();
        }

        @Override
        public void test(Expression expression) {
            assertInstance(expression, IdentificationVariable.class);

            IdentificationVariable identificationVariable = (IdentificationVariable) expression;
            assertEquals(this.identificationVariable, identificationVariable.toParsedText());
            assertEquals(virtual,                     identificationVariable.isVirtual());

            if (virtual) {
                StateFieldPathExpression pathExpression = identificationVariable.getStateFieldPathExpression();
                assertEquals(virtualPathExpression.isNull(), pathExpression == null);
                if (pathExpression != null) {
                    virtualPathExpression.test(pathExpression);
                }
            }
        }

        @Override
        public String toString() {
            return virtual ? virtualPathExpression.toString() : identificationVariable;
        }
    }

    public static final class IndexExpressionTester extends AbstractSingleEncapsulatedExpressionTester {

        protected IndexExpressionTester(ExpressionTester identificationVariable) {
            super(identificationVariable);
        }

        @Override
        protected Class<? extends AbstractSingleEncapsulatedExpression> expressionType() {
            return IndexExpression.class;
        }

        @Override
        protected String identifier() {
            return INDEX;
        }
    }

    public static final class InExpressionTester extends AbstractExpressionTester {

        public boolean hasLeftParenthesis;
        private boolean hasNot;
        public boolean hasRightParenthesis;
        public boolean hasSpaceAfterIn;
        private ExpressionTester inItems;
        private ExpressionTester stateFieldPathExpression;

        protected InExpressionTester(ExpressionTester stateFieldPathExpression,
                                     boolean hasNot,
                                     ExpressionTester inItems) {

            super();
            this.stateFieldPathExpression = stateFieldPathExpression;
            this.hasLeftParenthesis       = !inItems.isNull();
            this.hasRightParenthesis      = !inItems.isNull();
            this.hasNot                   = hasNot;
            this.inItems                  = inItems;
            this.hasSpaceAfterIn          = !hasLeftParenthesis && !inItems.isNull();
        }

        @Override
        public void test(Expression expression) {
            assertInstance(expression, InExpression.class);

            InExpression inExpression = (InExpression) expression;
            assertEquals(toString(),                         inExpression.toParsedText());
            assertEquals(hasLeftParenthesis,                 inExpression.hasLeftParenthesis());
            assertEquals(hasRightParenthesis,                inExpression.hasRightParenthesis());
            assertEquals(hasNot,                             inExpression.hasNot());
            assertEquals(!inItems.isNull(),                  inExpression.hasInItems());
            assertEquals(!stateFieldPathExpression.isNull(), inExpression.hasExpression());

            stateFieldPathExpression.test(inExpression.getExpression());
            inItems.test(inExpression.getInItems());
        }

        @Override
        public String toString() {
            StringBuilder sb = new StringBuilder();
            sb.append(stateFieldPathExpression);
            if (!stateFieldPathExpression.isNull()) {
                sb.append(SPACE);
            }
            sb.append(hasNot ? NOT_IN : IN);
            if (hasSpaceAfterIn) {
                sb.append(SPACE);
            }
            if (hasLeftParenthesis) {
                sb.append(LEFT_PARENTHESIS);
            }
            sb.append(inItems);
            if (hasRightParenthesis) {
                sb.append(RIGHT_PARENTHESIS);
            }
            return sb.toString();
        }
    }

    public static final class InputParameterTester extends AbstractExpressionTester {

        private String inputParameter;

        protected InputParameterTester(String inputParameter) {
            super();
            this.inputParameter = inputParameter;
        }

        @Override
        public void test(Expression expression) {
            assertInstance(expression, InputParameter.class);

            InputParameter inputParameter = (InputParameter) expression;
            assertEquals(toString(),                           inputParameter.toParsedText());
            assertEquals(this.inputParameter.charAt(0) == '?', inputParameter.isPositional());
            assertEquals(this.inputParameter.charAt(0) == ':', inputParameter.isNamed());
            assertEquals(this.inputParameter.substring(1),     inputParameter.getParameterName());
        }

        @Override
        public String toString() {
            return inputParameter;
        }
    }

    public static final class JoinTester extends AbstractExpressionTester {

        private boolean hasAs;
        public boolean hasSpaceAfterAs;
        public boolean hasSpaceAfterIdentificationVariable;
        public boolean hasSpaceAfterJoin;
        public boolean hasSpaceAfterJoinAssociation;
        private ExpressionTester identificationVariable;
        private ExpressionTester joinAssociationPath;
        private ExpressionTester joinCondition;
        private String joinType;

        protected JoinTester(String joinType,
                             ExpressionTester joinAssociationPath,
                             boolean hasAs,
                             ExpressionTester identificationVariable,
                             ExpressionTester joinCondition) {

            super();
            this.joinType                            = joinType;
            this.hasSpaceAfterJoin                   = true;
            this.joinAssociationPath                 = joinAssociationPath;
            this.hasAs                               = hasAs;
            this.hasSpaceAfterAs                     = hasAs;
            this.identificationVariable              = identificationVariable;
            this.hasSpaceAfterJoinAssociation        = !joinAssociationPath.isNull();
            this.hasSpaceAfterIdentificationVariable = !identificationVariable.isNull() && !joinCondition.isNull();
            this.joinCondition                       = joinCondition;
        }

        @Override
        public void test(Expression expression) {
            assertInstance(expression, Join.class);

            Join join = (Join) expression;
            assertEquals(toString(), join.toParsedText());
            assertEquals(joinType, join.getIdentifier());

            assertEquals(hasSpaceAfterJoin,                   join.hasSpaceAfterJoin());
            assertEquals(!joinAssociationPath.isNull(),       join.hasJoinAssociationPath());
            assertEquals(hasAs,                               join.hasAs());
            assertEquals(hasSpaceAfterAs,                     join.hasSpaceAfterAs());
            assertEquals(hasSpaceAfterJoinAssociation,        join.hasSpaceAfterJoinAssociation());
            assertEquals(!identificationVariable.isNull(),    join.hasIdentificationVariable());
            assertEquals(hasSpaceAfterIdentificationVariable, join.hasSpaceAfterIdentificationVariable());

            joinAssociationPath.test(join.getJoinAssociationPath());
            identificationVariable.test(join.getIdentificationVariable());
            joinCondition.test(join.getOnClause());
        }

        @Override
        public String toString() {
            StringBuilder sb = new StringBuilder();
            sb.append(joinType);
            if (hasSpaceAfterJoin) {
                sb.append(SPACE);
            }
            sb.append(joinAssociationPath);
            if (hasSpaceAfterJoinAssociation) {
                sb.append(SPACE);
            }
            if (hasAs) {
                sb.append(AS);
            }
            if (hasSpaceAfterAs) {
                sb.append(SPACE);
            }
            sb.append(identificationVariable);
            if (hasSpaceAfterIdentificationVariable) {
                sb.append(SPACE);
            }
            sb.append(joinCondition);
            return sb.toString();
        }
    }

    public static final class JPQLExpressionTester extends AbstractExpressionTester {

        private ExpressionTester queryStatement;
        private ExpressionTester unknownExpression;

        protected JPQLExpressionTester(ExpressionTester queryStatement,
                                       ExpressionTester unknownExpression) {

            super();
            this.queryStatement    = queryStatement;
            this.unknownExpression = unknownExpression;
        }

        @Override
        public void test(Expression expression) {

            JPQLExpression jpqlExpression = (JPQLExpression) expression;

            assertEquals(toString(),                  jpqlExpression.toParsedText());
            assertEquals(!queryStatement.isNull(),    jpqlExpression.hasQueryStatement());
            assertEquals(!unknownExpression.isNull(), jpqlExpression.hasUnknownEndingStatement());

            queryStatement   .test(jpqlExpression.getQueryStatement());
            unknownExpression.test(jpqlExpression.getUnknownEndingStatement());
        }

        @Override
        public String toString() {
            StringBuilder sb = new StringBuilder();
            sb.append(queryStatement);
            sb.append(unknownExpression);
            return sb.toString();
        }
    }

    public static final class KeywordExpressionTester extends AbstractExpressionTester {

        private String keyword;

        protected KeywordExpressionTester(String keyword) {
            super();
            this.keyword = keyword;
        }

        @Override
        public void test(Expression expression) {
            assertInstance(expression, KeywordExpression.class);

            KeywordExpression keywordExpression = (KeywordExpression) expression;
            assertEquals(toString(), keywordExpression.toParsedText());
        }

        @Override
        public String toString() {
            return keyword;
        }
    }

    public static final class LengthExpressionTester extends AbstractSingleEncapsulatedExpressionTester {

        protected LengthExpressionTester(ExpressionTester expression) {
            super(expression);
        }

        @Override
        protected Class<? extends AbstractSingleEncapsulatedExpression> expressionType() {
            return LengthExpression.class;
        }

        @Override
        protected String identifier() {
            return LENGTH;
        }
    }

    public static final class LikeExpressionTester extends AbstractExpressionTester {

        private ExpressionTester escapeCharacter;
        public boolean hasEscape;
        private boolean hasNot;
        public boolean hasSpaceAfterEscape;
        public boolean hasSpaceAfterLike;
        public boolean hasSpaceAfterPatternValue;
        private ExpressionTester patternValue;
        private ExpressionTester stringExpression;

        protected LikeExpressionTester(ExpressionTester stringExpression,
                                       boolean hasNot,
                                       ExpressionTester patternValue,
                                       ExpressionTester escapeCharacter) {

            super();
            this.hasNot              = hasNot;
            this.hasSpaceAfterLike   = true;
            this.stringExpression    = stringExpression;
            this.patternValue        = patternValue;
            this.escapeCharacter     = escapeCharacter;
            this.hasEscape           = !escapeCharacter.isNull();
            this.hasSpaceAfterEscape = hasEscape;
            this.hasSpaceAfterPatternValue = !patternValue.isNull() && hasEscape;
        }

        @Override
        public void test(Expression expression) {
            assertInstance(expression, LikeExpression.class);

            LikeExpression likeExpression = (LikeExpression) expression;
            assertEquals(toString(),                likeExpression.toParsedText());
            assertEquals(hasNot,                    likeExpression.hasNot());
            assertEquals(hasSpaceAfterLike,         likeExpression.hasSpaceAfterLike());
            assertEquals(hasEscape,                 likeExpression.hasEscape());
            assertEquals(!escapeCharacter.isNull(), likeExpression.hasEscapeCharacter());
            assertEquals(hasSpaceAfterEscape,       likeExpression.hasSpaceAfterEscape());
            assertEquals(hasSpaceAfterPatternValue, likeExpression.hasSpaceAfterPatternValue());
            assertEquals(!patternValue.isNull(),    likeExpression.hasPatternValue());

            stringExpression.test(likeExpression.getStringExpression());
            patternValue.test(likeExpression.getPatternValue());
            escapeCharacter.test(likeExpression.getEscapeCharacter());
        }

        @Override
        public String toString() {
            StringBuilder sb = new StringBuilder();
            sb.append(stringExpression);
            if (!stringExpression.isNull()) {
                sb.append(SPACE);
            }
            sb.append(hasNot ? NOT_LIKE : LIKE);
            if (hasSpaceAfterLike) {
                sb.append(SPACE);
            }
            sb.append(patternValue);
            if (hasSpaceAfterPatternValue) {
                sb.append(SPACE);
            }
            if (hasEscape) {
                sb.append(ESCAPE);
            }
            if (hasSpaceAfterEscape) {
                sb.append(SPACE);
            }
            sb.append(escapeCharacter);
            return sb.toString();
        }
    }

    public static final class LocateExpressionTester extends AbstractTripleEncapsulatedExpressionTester {

        protected LocateExpressionTester(ExpressionTester firstExpression,
                                         ExpressionTester secondExpression,
                                         ExpressionTester thirdExpression) {

            super(firstExpression, secondExpression, thirdExpression);
        }

        @Override
        protected Class<? extends AbstractTripleEncapsulatedExpression> expressionType() {
            return LocateExpression.class;
        }

        @Override
        protected String identifier() {
            return LOCATE;
        }
    }

    public static abstract class LogicalExpressionTester extends CompoundExpressionTester {

        protected LogicalExpressionTester(ExpressionTester leftExpression,
                                          ExpressionTester rightExpression) {

            super(leftExpression, rightExpression);
        }

        @Override
        public void test(Expression expression) {
            super.test(expression);
            assertInstance(expression, LogicalExpression.class);
        }
    }

    public static final class LowerExpressionTester extends AbstractSingleEncapsulatedExpressionTester {

        protected LowerExpressionTester(ExpressionTester expression) {
            super(expression);
        }

        @Override
        protected Class<? extends AbstractSingleEncapsulatedExpression> expressionType() {
            return LowerExpression.class;
        }

        @Override
        protected String identifier() {
            return LOWER;
        }
    }

    public static final class MaxFunctionTester extends AggregateFunctionTester {

        protected MaxFunctionTester(ExpressionTester expression, boolean hasDistinct) {
            super(expression, hasDistinct);
        }

        @Override
        protected Class<? extends AbstractSingleEncapsulatedExpression> expressionType() {
            return MaxFunction.class;
        }

        @Override
        protected String identifier() {
            return MAX;
        }
    }

    public static final class MinFunctionTester extends AggregateFunctionTester {

        protected MinFunctionTester(ExpressionTester expression, boolean hasDistinct) {
            super(expression, hasDistinct);
        }

        @Override
        protected Class<? extends AbstractSingleEncapsulatedExpression> expressionType() {
            return MinFunction.class;
        }

        @Override
        protected String identifier() {
            return MIN;
        }
    }

    public static final class ModExpressionTester extends AbstractDoubleEncapsulatedExpressionTester {

        protected ModExpressionTester(ExpressionTester firstExpression, ExpressionTester secondExpression) {
            super(firstExpression, secondExpression);
        }

        @Override
        protected Class<? extends AbstractDoubleEncapsulatedExpression> expressionType() {
            return ModExpression.class;
        }

        @Override
        protected String identifier() {
            return MOD;
        }
    }

    public static final class MultiplicationExpressionTester extends CompoundExpressionTester {

        protected MultiplicationExpressionTester(ExpressionTester leftExpression,
                                                 ExpressionTester rightExpression) {

            super(leftExpression, rightExpression);
        }

        @Override
        protected Class<? extends CompoundExpression> expressionType() {
            return MultiplicationExpression.class;
        }

        @Override
        protected String identifier() {
            return MULTIPLICATION;
        }
    }

    public static final class NotExpressionTester extends AbstractExpressionTester {

        private ExpressionTester expression;
        public boolean hasSpaceAfterNot;

        protected NotExpressionTester(ExpressionTester expression) {
            super();
            this.expression       = expression;
            this.hasSpaceAfterNot = true;
        }

        @Override
        public void test(Expression expression) {
            assertInstance(expression, NotExpression.class);

            NotExpression notExpression = (NotExpression) expression;
            assertEquals(toString(),                notExpression.toParsedText());
            assertEquals(hasSpaceAfterNot,          notExpression.hasSpaceAfterNot());
            assertEquals(!this.expression.isNull(), notExpression.hasExpression());

            this.expression.test(notExpression.getExpression());
        }

        @Override
        public String toString() {
            StringBuilder sb = new StringBuilder();
            sb.append(NOT);
            if (hasSpaceAfterNot) {
                sb.append(SPACE);
            }
            sb.append(expression);
            return sb.toString();
        }
    }

    public static final class NullComparisonExpressionTester extends AbstractExpressionTester {

        private ExpressionTester expression;
        private boolean hasNot;

        protected NullComparisonExpressionTester(ExpressionTester expression, boolean hasNot) {
            super();
            this.hasNot     = hasNot;
            this.expression = expression;
        }

        @Override
        public void test(Expression expression) {
            assertInstance(expression, NullComparisonExpression.class);

            NullComparisonExpression nullComparisonExpression = (NullComparisonExpression) expression;
            assertEquals(toString(),                nullComparisonExpression.toParsedText());
            assertEquals(hasNot,                    nullComparisonExpression.hasNot());
            assertEquals(!this.expression.isNull(), nullComparisonExpression.hasExpression());

            this.expression.test(nullComparisonExpression.getExpression());
        }

        @Override
        public String toString() {
            StringBuilder sb = new StringBuilder();
            sb.append(expression);
            if (!expression.isNull()) {
                sb.append(SPACE);
            }
            sb.append(hasNot ? IS_NOT_NULL : IS_NULL);
            return sb.toString();
        }
    }

    public static final class NullExpressionTester extends AbstractExpressionTester {

        @Override
        public boolean isNull() {
            return true;
        }

        @Override
        public void test(Expression expression) {
            assertInstance(expression, NullExpression.class);
        }

        @Override
        public String toString() {
            return ExpressionTools.EMPTY_STRING;
        }
    }

    public static final class NullIfExpressionTester extends AbstractDoubleEncapsulatedExpressionTester {

        protected NullIfExpressionTester(ExpressionTester firstExpression,
                                         ExpressionTester secondExpression) {

            super(firstExpression, secondExpression);
      }

        @Override
        protected Class<? extends AbstractDoubleEncapsulatedExpression> expressionType() {
            return NullIfExpression.class;
        }

        @Override
        protected String identifier() {
            return NULLIF;
        }
    }

    public static final class NumericLiteralTester extends AbstractExpressionTester {

        private String number;

        protected NumericLiteralTester(String number) {
            super();
            this.number = number;
        }

        @Override
        public void test(Expression expression) {
            assertInstance(expression, NumericLiteral.class);

            assertEquals(toString(), expression.toParsedText());
        }

        @Override
        public String toString() {
            return number;
        }
    }

    public static final class ObjectExpressionTester extends AbstractSingleEncapsulatedExpressionTester {

        protected ObjectExpressionTester(ExpressionTester identificationVariable) {
            super(identificationVariable);
        }

        @Override
        protected Class<? extends AbstractSingleEncapsulatedExpression> expressionType() {
            return ObjectExpression.class;
        }

        @Override
        protected String identifier() {
            return OBJECT;
        }
    }

    public static final class OnClauseTester extends AbstractConditionalClauseTester {

        protected OnClauseTester(ExpressionTester conditionalExpression) {
            super(conditionalExpression);
        }

        @Override
        protected Class<? extends AbstractConditionalClause> expressionType() {
            return OnClause.class;
        }

        @Override
        protected String identifier() {
            return ON;
        }
    }

    public static final class OrderByClauseTester extends AbstractOrderByClauseTester {

        protected OrderByClauseTester(ExpressionTester orderByItems) {
            super(orderByItems);
        }

        @Override
        protected String identifier() {
            return ORDER_BY;
        }

        @Override
        public void test(Expression expression) {
            super.test(expression);
            assertInstance(expression, OrderByClause.class);
        }
    }

    public static final class OrderByItemTester extends AbstractExpressionTester {

        public boolean hasSpaceAfterExpression;
        public boolean hasSpaceAfterNulls;
        public boolean hasSpaceAfterOrdering;
        private NullOrdering nullOrdering;
        public String nulls;
        private ExpressionTester orderByItem;
        private Ordering ordering;

        protected OrderByItemTester(ExpressionTester orderByItem,
                                    Ordering ordering,
                                    NullOrdering nullOrdering) {

            super();
            this.ordering     = ordering;
            this.orderByItem  = orderByItem;
            this.nullOrdering = nullOrdering;
            this.hasSpaceAfterExpression = ordering != Ordering.DEFAULT ||
                                           nullOrdering != NullOrdering.DEFAULT;
            this.hasSpaceAfterOrdering = ordering != Ordering.DEFAULT &&
                                         nullOrdering != NullOrdering.DEFAULT;
        }

        @Override
        public void test(Expression expression) {
            assertInstance(expression, OrderByItem.class);

            OrderByItem orderByItem = (OrderByItem) expression;
            assertEquals(toString(), orderByItem.toParsedText());
            assertEquals(!this.orderByItem.isNull(), orderByItem.hasExpression());
            assertEquals(hasSpaceAfterExpression,    orderByItem.hasSpaceAfterExpression());
            assertEquals(hasSpaceAfterOrdering,      orderByItem.hasSpaceAfterOrdering());
            assertSame  (ordering, orderByItem.getOrdering());

            if (nulls != null) {
                assertEquals(nulls, orderByItem.getActualNullOrdering().toUpperCase());
            }
            else {
                assertSame(nullOrdering, orderByItem.getNullOrdering());
            }

            this.orderByItem.test(orderByItem.getExpression());
        }

        @Override
        public String toString() {

            StringBuilder sb = new StringBuilder();
            sb.append(orderByItem);

            if (hasSpaceAfterExpression) {
                sb.append(SPACE);
            }

            if (ordering != Ordering.DEFAULT) {
                sb.append(ordering.name());
            }

            if (hasSpaceAfterOrdering) {
                sb.append(SPACE);
            }

            if (nulls != null) {
                sb.append(nulls);
                if (hasSpaceAfterNulls) {
                    sb.append(SPACE);
                }
            }
            else if (nullOrdering != NullOrdering.DEFAULT) {
                sb.append(nullOrdering.getIdentifier());
            }

            return sb.toString();
        }
    }

    public static final class OrderSiblingsByClauseTester extends AbstractOrderByClauseTester {

        protected OrderSiblingsByClauseTester(ExpressionTester orderByItems) {
            super(orderByItems);
        }

        @Override
        protected String identifier() {
            return ORDER_SIBLINGS_BY;
        }

        @Override
        public void test(Expression expression) {
            super.test(expression);
            assertInstance(expression, OrderSiblingsByClause.class);
        }
    }

    public static final class OrExpressionTester extends LogicalExpressionTester {

        protected OrExpressionTester(ExpressionTester leftExpression,
                                     ExpressionTester rightExpression) {

            super(leftExpression, rightExpression);
        }

        @Override
        protected Class<? extends CompoundExpression> expressionType() {
            return OrExpression.class;
        }

        @Override
        protected String identifier() {
            return OR;
        }
    }

    public static final class RangeVariableDeclarationTester extends AbstractExpressionTester {

        private ExpressionTester abstractSchemaName;
        private boolean hasAs;
        public boolean hasSpaceAfterAbstractSchemaName;
        public boolean hasSpaceAfterAs;
        private ExpressionTester identificationVariable;

        protected RangeVariableDeclarationTester(ExpressionTester abstractSchemaName,
                                                 boolean hasAs,
                                                 ExpressionTester identificationVariable) {

            super();
            this.hasAs                           = hasAs;
            this.abstractSchemaName              = abstractSchemaName;
            this.identificationVariable          = identificationVariable;
            this.hasSpaceAfterAbstractSchemaName = hasAs || !identificationVariable.isNull();
            this.hasSpaceAfterAs                 = hasAs;

            if (identificationVariable instanceof IdentificationVariableTester &&
                identificationVariable.isNull()) {

                this.hasSpaceAfterAbstractSchemaName = true;
            }
        }

        @Override
        public void test(Expression expression) {
            assertInstance(expression, RangeVariableDeclaration.class);

            RangeVariableDeclaration rangeVariableDeclaration = (RangeVariableDeclaration) expression;
            assertEquals(toString(),                       rangeVariableDeclaration.toParsedText());
            assertEquals(hasAs,                            rangeVariableDeclaration.hasAs());
            assertEquals(hasSpaceAfterAs,                  rangeVariableDeclaration.hasSpaceAfterAs());
            assertEquals(!identificationVariable.isNull(), rangeVariableDeclaration.hasIdentificationVariable());
            assertEquals(hasSpaceAfterAbstractSchemaName,  rangeVariableDeclaration.hasSpaceAfterRootObject());

            abstractSchemaName.test(rangeVariableDeclaration.getRootObject());
            identificationVariable.test(rangeVariableDeclaration.getIdentificationVariable());
        }

        @Override
        public String toString() {
            StringBuilder sb = new StringBuilder();
            sb.append(abstractSchemaName);
            if (hasSpaceAfterAbstractSchemaName) {
                sb.append(SPACE);
            }
            if (hasAs) {
                sb.append(AS);
            }
            if (hasSpaceAfterAs) {
                sb.append(SPACE);
            }
            sb.append(identificationVariable);
            return sb.toString();
        }
    }

    public static final class RegexpExpressionTester extends AbstractExpressionTester {

        public boolean hasSpaceAfterIdentifier;
        private ExpressionTester patternValue;
        private ExpressionTester stringExpression;

        protected RegexpExpressionTester(ExpressionTester stringExpression,
                                         ExpressionTester patternValue) {

            super();
            this.stringExpression        = stringExpression;
            this.patternValue            = patternValue;
            this.hasSpaceAfterIdentifier = !patternValue.isNull();
        }

        @Override
        public void test(Expression expression) {
            assertInstance(expression, RegexpExpression.class);

            RegexpExpression regexpExpression = (RegexpExpression) expression;
            assertEquals(toString(),                 regexpExpression.toParsedText());
            assertEquals(!patternValue.isNull(),     regexpExpression.hasPatternValue());
            assertEquals(hasSpaceAfterIdentifier,    regexpExpression.hasSpaceAfterIdentifier());
            assertEquals(!stringExpression.isNull(), regexpExpression.hasSpaceAfterStringExpression());
            assertEquals(!stringExpression.isNull(), regexpExpression.hasStringExpression());

            stringExpression.test(regexpExpression.getStringExpression());
            patternValue    .test(regexpExpression.getPatternValue());
        }

        @Override
        public String toString() {
            StringBuilder sb = new StringBuilder();
            sb.append(stringExpression);
            if (!stringExpression.isNull()) {
                sb.append(SPACE);
            }
            sb.append(REGEXP);
            if (hasSpaceAfterIdentifier) {
                sb.append(SPACE);
            }
            sb.append(patternValue);
            return sb.toString();
        }
    }

    public static final class ResultVariableTester extends AbstractExpressionTester {

        private boolean hasAs;
        public boolean hasSpaceAfterAs;
        private ExpressionTester resultVariable;
        private ExpressionTester selectExpression;

        protected ResultVariableTester(ExpressionTester selectExpression,
                                       boolean hasAs,
                                       ExpressionTester resultVariable) {

            super();
            this.hasAs            = hasAs;
            this.hasSpaceAfterAs  = hasAs;
            this.selectExpression = selectExpression;
            this.resultVariable   = resultVariable;
        }

        @Override
        public void test(Expression expression) {

            assertInstance(expression, ResultVariable.class);
            ResultVariable resultVariable = (ResultVariable) expression;

            assertEquals(toString(),                    resultVariable.toParsedText());
            assertEquals(hasAs,                         resultVariable.hasAs());
            assertEquals(hasSpaceAfterAs,               resultVariable.hasSpaceAfterAs());
            assertEquals(!this.resultVariable.isNull(), resultVariable.hasResultVariable());
            assertEquals(!selectExpression.isNull(),    resultVariable.hasSelectExpression());

            this.selectExpression.test(resultVariable.getSelectExpression());
            this.resultVariable  .test(resultVariable.getResultVariable());
        }

        @Override
        public String toString() {
            StringBuilder sb = new StringBuilder();
            sb.append(selectExpression);
            if (!selectExpression.isNull()) {
                sb.append(SPACE);
            }
            if (hasAs) {
                sb.append(AS);
            }
            if (hasSpaceAfterAs) {
                sb.append(SPACE);
            }
            sb.append(resultVariable);
            return sb.toString();
        }
    }

    public static final class SelectClauseTester extends AbstractSelectClauseTester {

        protected SelectClauseTester(ExpressionTester selectExpressions, boolean hasDistinct) {
            super(selectExpressions, hasDistinct);
        }

        @Override
        public void test(Expression expression) {
            super.test(expression);
            assertInstance(expression, SelectClause.class);
        }
    }

    public static final class SelectStatementTester extends AbstractSelectStatementTester {

        public boolean hasSpaceBeforeOrderByClause;
        public boolean hasSpaceBeforeUnionClauses;
        private ExpressionTester orderByClause;
        private ExpressionTester unionClauses;

        protected SelectStatementTester(ExpressionTester selectClause,
                                        ExpressionTester fromClause,
                                        ExpressionTester whereClause,
                                        ExpressionTester groupByClause,
                                        ExpressionTester havingClause,
                                        ExpressionTester orderByClause,
                                        ExpressionTester unionClauses) {

            super(selectClause,
                  fromClause,
                  whereClause,
                  groupByClause,
                  havingClause);

            this.orderByClause = orderByClause;
            this.unionClauses  = unionClauses;

            this.hasSpaceBeforeOrderByClause = !orderByClause.isNull();
            this.hasSpaceBeforeUnionClauses  = !unionClauses .isNull();

//            hasSpaceAfterFrom                    |= (!fromClause   .isNull() && (!whereClause.isNull() || !groupByClause.isNull() &&  havingClause .isNull() && !orderByClause.isNull() && !unionClauses.isNull());
//            hasSpaceAfterWhere                   |= (!whereClause  .isNull() && groupByClause.isNull() && !havingClause .isNull() && !orderByClause.isNull() && !unionClauses .isNull());
//            hasSpaceAfterHierarchicalQueryClause |= (!whereClause  .isNull() && groupByClause.isNull() && !havingClause .isNull() && !orderByClause.isNull() && !unionClauses .isNull());
//            hasSpaceAfterGroupBy                 |= (!groupByClause.isNull() && havingClause .isNull() && !orderByClause.isNull() && !unionClauses.isNull());
        }

        @Override
        protected Class<? extends AbstractSelectStatement> expressionType() {
            return SelectStatement.class;
        }

        @Override
        public void test(Expression expression) {
            super.test(expression);

            SelectStatement selectStatement = (SelectStatement) expression;
            assertEquals(!orderByClause.isNull(), selectStatement.hasOrderByClause());
//            assertEquals(hasSpaceBeforeOrderByClause, selectStatement.hasSpaceBeforeOrderBy());

            orderByClause.test(selectStatement.getOrderByClause());
            unionClauses .test(selectStatement.getUnionClauses());
        }

        @Override
        public String toString() {

            StringBuilder sb = new StringBuilder();
            sb.append(super.toString());
            if (hasSpaceBeforeOrderByClause && sb.charAt(sb.length() - 1) != ' ') {
                sb.append(SPACE);
            }
            sb.append(orderByClause);
            if (hasSpaceBeforeUnionClauses && sb.charAt(sb.length() - 1) != ' ') {
                sb.append(SPACE);
            }
            sb.append(unionClauses);
            return sb.toString();
        }
    }

    public static final class SimpleFromClauseTester extends AbstractFromClauseTester {

        protected SimpleFromClauseTester(ExpressionTester declaration,
                                           ExpressionTester hierarchicalQueryClause,
                                           ExpressionTester asOfClause) {

            super(declaration, hierarchicalQueryClause, asOfClause);
        }

        @Override
        public void test(Expression expression) {
            super.test(expression);
            assertInstance(expression, SimpleFromClause.class);
        }
    }

    public static final class SimpleSelectClauseTester extends AbstractSelectClauseTester {

        protected SimpleSelectClauseTester(ExpressionTester selectExpressions, boolean hasDistinct) {
            super(selectExpressions, hasDistinct);
        }

        @Override
        public void test(Expression expression) {
            super.test(expression);
            assertInstance(expression, SimpleSelectClause.class);
        }
    }

    public static final class SimpleSelectStatementTester extends AbstractSelectStatementTester {

        protected SimpleSelectStatementTester(ExpressionTester selectClause,
                                              ExpressionTester fromClause,
                                              ExpressionTester whereClause,
                                              ExpressionTester groupByClause,
                                              ExpressionTester havingClause) {

            super(selectClause, fromClause, whereClause, groupByClause, havingClause);
        }

        @Override
        protected Class<? extends AbstractSelectStatement> expressionType() {
            return SimpleSelectStatement.class;
        }
    }

    public static final class SizeExpressionTester extends AbstractSingleEncapsulatedExpressionTester {

        protected SizeExpressionTester(ExpressionTester collectionPath) {
            super(collectionPath);
        }

        @Override
        protected Class<? extends AbstractSingleEncapsulatedExpression> expressionType() {
            return SizeExpression.class;
        }

        @Override
        protected String identifier() {
            return SIZE;
        }
    }

    public static final class SqrtExpressionTester extends AbstractSingleEncapsulatedExpressionTester {

        protected SqrtExpressionTester(ExpressionTester expression) {
            super(expression);
        }

        @Override
        protected Class<? extends AbstractSingleEncapsulatedExpression> expressionType() {
            return SqrtExpression.class;
        }

        @Override
        protected String identifier() {
            return SQRT;
        }
    }

    public static final class StartWithClauseTester extends AbstractConditionalClauseTester {

        protected StartWithClauseTester(ExpressionTester expression) {
            super(expression);
        }

        @Override
        protected Class<StartWithClause> expressionType() {
            return StartWithClause.class;
        }

        @Override
        protected String identifier() {
            return START_WITH;
        }
    }

    public static final class StateFieldPathExpressionTester extends AbstractPathExpressionTester {

        protected StateFieldPathExpressionTester(ExpressionTester identificationVariable,
                                               String value) {

            super(identificationVariable, value);
        }

        @Override
        public void test(Expression expression) {
            super.test(expression);
            assertInstance(expression, StateFieldPathExpression.class);
        }
    }

    public static final class StringLiteralTester extends AbstractExpressionTester {

        private boolean hasCloseQuote;
        private String literal;

        protected StringLiteralTester(String literal) {

            super();
            this.literal = literal;

            if (literal.length() > 1) {
                char lastChar = literal.charAt(literal.length() - 1);
                hasCloseQuote = (lastChar == SINGLE_QUOTE) || (lastChar == DOUBLE_QUOTE);
            }
        }

        @Override
        public void test(Expression expression) {
            assertInstance(expression, StringLiteral.class);

            StringLiteral stringLiteral = (StringLiteral) expression;
            assertEquals(toString(),    stringLiteral.toString());
            assertEquals(hasCloseQuote, stringLiteral.hasCloseQuote());
        }

        @Override
        public String toString() {
            return literal;
        }
    }

    public static final class SubExpressionTester extends AbstractSingleEncapsulatedExpressionTester {

        protected SubExpressionTester(ExpressionTester expression) {
            super(expression);
        }

        @Override
        protected Class<? extends AbstractSingleEncapsulatedExpression> expressionType() {
            return SubExpression.class;
        }

        @Override
        protected String identifier() {
            return ExpressionTools.EMPTY_STRING;
        }
    }

    public static final class SubstringExpressionTester extends AbstractTripleEncapsulatedExpressionTester {

        protected SubstringExpressionTester(ExpressionTester firstExpression,
                                            ExpressionTester firstArithmeticExpression,
                                            ExpressionTester secondArithmeticExpression) {

            super(firstExpression, firstArithmeticExpression, secondArithmeticExpression);
        }

        @Override
        protected Class<? extends AbstractTripleEncapsulatedExpression> expressionType() {
            return SubstringExpression.class;
        }

        @Override
        protected String identifier() {
            return SubstringExpression.SUBSTRING;
        }
    }

    public static final class SubtractionExpressionTester extends CompoundExpressionTester {

        protected SubtractionExpressionTester(ExpressionTester leftExpression,
                                              ExpressionTester rightExpression) {

            super(leftExpression, rightExpression);
        }

        @Override
        protected Class<? extends CompoundExpression> expressionType() {
            return SubtractionExpression.class;
        }

        @Override
        protected String identifier() {
            return MINUS;
        }
    }

    public static final class SumFunctionTester extends AggregateFunctionTester {

        protected SumFunctionTester(ExpressionTester expression, boolean hasDistinct) {
            super(expression, hasDistinct);
        }

        @Override
        protected Class<? extends AbstractSingleEncapsulatedExpression> expressionType() {
            return SumFunction.class;
        }

        @Override
        protected String identifier() {
            return SUM;
        }
    }

    public static final class TableExpressionTester extends AbstractSingleEncapsulatedExpressionTester {

        protected TableExpressionTester(ExpressionTester expression) {
            super(expression);
        }

        @Override
        protected Class<TableExpression> expressionType() {
            return TableExpression.class;
        }

        @Override
        protected String identifier() {
            return TABLE;
        }
    }

    public static final class TableVariableDeclarationTester extends AbstractExpressionTester {


        private boolean hasAs;
        public boolean hasSpaceAfterAs;
        public boolean hasSpaceAfterTableExpression;
        private ExpressionTester identificationVariable;
        private TableExpressionTester tableExpression;

        protected TableVariableDeclarationTester(TableExpressionTester tableExpression,
                                                 boolean hasAs,
                                                 ExpressionTester identificationVariable) {
            super();
            this.tableExpression              = tableExpression;
            this.hasAs                        = hasAs;
            this.identificationVariable       = identificationVariable;
            this.hasSpaceAfterTableExpression = hasAs || !identificationVariable.isNull();
            this.hasSpaceAfterAs              = hasAs && !identificationVariable.isNull();
        }

        @Override
        public void test(Expression expression) {
            assertInstance(expression, Expression.class);

            TableVariableDeclaration tableVariableDeclaration = (TableVariableDeclaration) expression;
            assertEquals(toString(), tableVariableDeclaration.toParsedText());
            assertEquals(!identificationVariable.isNull(), tableVariableDeclaration.hasIdentificationVariable());
            assertEquals(hasAs,                            tableVariableDeclaration.hasAs());
            assertEquals(hasSpaceAfterAs,                  tableVariableDeclaration.hasSpaceAfterAs());
            assertEquals(hasSpaceAfterTableExpression,     tableVariableDeclaration.hasSpaceAfterTableExpression());

            tableExpression       .test(tableVariableDeclaration.getTableExpression());
            identificationVariable.test(tableVariableDeclaration.getIdentificationVariable());
        }

        @Override
        public String toString() {
            StringBuilder sb = new StringBuilder();
            sb.append(tableExpression);
            if (hasSpaceAfterTableExpression) {
                sb.append(SPACE);
            }
            if (hasAs) {
                sb.append(AS);
            }
            if (hasSpaceAfterAs) {
                sb.append(SPACE);
            }
            sb.append(identificationVariable);
            return sb.toString();
        }
    }

    public static final class TreatExpressionTester extends AbstractEncapsulatedExpressionTester {

        private ExpressionTester collectionValuedPathExpression;
        private ExpressionTester entityTypeName;
        private boolean hasAs;
        public boolean hasSpaceAfterAs;
        public boolean hasSpaceAfterCollectionValuedPathExpression;

        protected TreatExpressionTester(ExpressionTester collectionValuedPathExpression,
                                        boolean hasAs,
                                        ExpressionTester entityTypeName) {
            super();
            this.hasAs           = hasAs;
            this.entityTypeName  = entityTypeName;
            this.hasSpaceAfterAs = hasAs;
            this.hasSpaceAfterCollectionValuedPathExpression = true;
            this.collectionValuedPathExpression              = collectionValuedPathExpression;
        }

        @Override
        protected Class<? extends AbstractEncapsulatedExpression> expressionType() {
            return TreatExpression.class;
        }

        @Override
        protected boolean hasEncapsulatedExpression() {
            return !collectionValuedPathExpression.isNull() || !entityTypeName.isNull() || hasAs;
        }

        @Override
        protected String identifier() {
            return TREAT;
        }

        @Override
        protected void toStringEncapsulatedExpression(StringBuilder sb) {
            sb.append(collectionValuedPathExpression);
            if (hasSpaceAfterCollectionValuedPathExpression) {
                sb.append(SPACE);
            }
            if (hasAs) {
                sb.append(AS);
            }
            if (hasSpaceAfterAs) {
                sb.append(SPACE);
            }
            sb.append(entityTypeName);
        }
    }

    public static final class TrimExpressionTester extends AbstractSingleEncapsulatedExpressionTester {

        private boolean hasFrom;
        public boolean hasSpaceAfterFrom;
        public boolean hasSpaceAfterSpecification;
        public boolean hasSpaceAfterTrimCharacter;
        private Specification specification;
        private ExpressionTester trimCharacter;

        protected TrimExpressionTester(Specification specification,
                                       ExpressionTester stringPrimary,
                                       ExpressionTester trimCharacter,
                                       boolean hasFrom) {

            super(stringPrimary);
            this.specification              = specification;
            this.trimCharacter              = trimCharacter;
            this.hasFrom                    = hasFrom;
            this.hasSpaceAfterFrom          = hasFrom;
            this.hasSpaceAfterTrimCharacter = !trimCharacter.isNull();
            this.hasSpaceAfterSpecification = specification != Specification.DEFAULT;
        }

        @Override
        protected Class<? extends AbstractSingleEncapsulatedExpression> expressionType() {
            return TrimExpression.class;
        }

        @Override
        protected String identifier() {
            return TRIM;
        }

        @Override
        public void test(Expression expression) {
            super.test(expression);

            TrimExpression trimExpression = (TrimExpression) expression;
            assertEquals(hasFrom,                                trimExpression.hasFrom());
            assertEquals(hasSpaceAfterFrom,                      trimExpression.hasSpaceAfterFrom());
            assertEquals(hasSpaceAfterTrimCharacter,             trimExpression.hasSpaceAfterTrimCharacter());
            assertEquals(!trimCharacter.isNull(),                trimExpression.hasTrimCharacter());
            assertEquals(specification != Specification.DEFAULT, trimExpression.hasSpecification());
            assertEquals(hasSpaceAfterSpecification,             trimExpression.hasSpaceAfterSpecification());

            trimCharacter.test(trimExpression.getTrimCharacter());
        }

        @Override
        protected void toStringEncapsulatedExpression(StringBuilder sb) {
            if (specification != Specification.DEFAULT) {
                sb.append(specification);
            }
            if (hasSpaceAfterSpecification) {
                sb.append(SPACE);
            }
            sb.append(trimCharacter);
            if (hasSpaceAfterTrimCharacter) {
                sb.append(SPACE);
            }
            if (hasFrom) {
                sb.append(FROM);
            }
            if (hasSpaceAfterFrom) {
                sb.append(SPACE);
            }
            super.toStringEncapsulatedExpression(sb);
        }
    }

    public static final class TypeExpressionTester extends AbstractSingleEncapsulatedExpressionTester {

        protected TypeExpressionTester(ExpressionTester identificationVariable) {
            super(identificationVariable);
        }

        @Override
        protected Class<? extends AbstractSingleEncapsulatedExpression> expressionType() {
            return TypeExpression.class;
        }

        @Override
        protected String identifier() {
            return TYPE;
        }
    }

    public static final class UnionClauseTester extends AbstractExpressionTester {

        private boolean hasAll;
        public boolean hasSpaceAfterAll;
        public boolean hasSpaceAfterIdentifier;
        private String identifier;
        private ExpressionTester subquery;

        protected UnionClauseTester(String identifier, boolean hasAll, ExpressionTester subquery) {
            super();
            this.identifier = identifier;
            this.hasAll     = hasAll;
            this.subquery   = subquery;
            this.hasSpaceAfterIdentifier = hasAll || !subquery.isNull();
            this.hasSpaceAfterAll        = hasAll && !subquery.isNull();
        }

        @Override
        public void test(Expression expression) {
            assertInstance(expression, UnionClause.class);

            UnionClause unionClause = (UnionClause) expression;
            assertEquals(toString(),              unionClause.toParsedText());
            assertEquals(identifier,              unionClause.getIdentifier());
            assertEquals(hasSpaceAfterIdentifier, unionClause.hasSpaceAfterIdentifier());
            assertEquals(hasAll,                  unionClause.hasAll());
            assertEquals(!subquery.isNull(),      unionClause.hasQuery());
            assertEquals(hasSpaceAfterAll,        unionClause.hasSpaceAfterAll());

            subquery.test(unionClause.getQuery());
        }

        @Override
        public String toString() {
            StringBuilder sb = new StringBuilder();
            sb.append(identifier);
            if (hasSpaceAfterIdentifier) {
                sb.append(SPACE);
            }
            if (hasAll) {
                sb.append(ALL);
            }
            if (hasSpaceAfterAll) {
                sb.append(SPACE);
            }
            sb.append(subquery);
            return sb.toString();
        }
    }

    public static final class UnknownExpressionTester extends AbstractExpressionTester {

        private final String unknownText;

        protected UnknownExpressionTester(String unknownText) {
            super();
            this.unknownText = unknownText;
        }

        @Override
        public void test(Expression expression) {
            assertInstance(expression, UnknownExpression.class);

            UnknownExpression unknownExpression = (UnknownExpression) expression;
            assertEquals(toString(), unknownExpression.toParsedText());
        }

        @Override
        public String toString() {
            return unknownText;
        }
    }

    public static final class UpdateClauseTester extends AbstractExpressionTester {

        public boolean hasSet;
        public boolean hasSpaceAfterRangeVariableDeclaration;
        public boolean hasSpaceAfterSet;
        public boolean hasSpaceAfterUpdate;
        private ExpressionTester rangeVariableDeclaration;
        private ExpressionTester updateItems;

        protected UpdateClauseTester(ExpressionTester rangeVariableDeclaration,
                                     ExpressionTester updateItems) {

            super();
            this.hasSet                                = true;
            this.hasSpaceAfterSet                      = true;
            this.hasSpaceAfterUpdate                   = true;
            this.updateItems                           = updateItems;
            this.rangeVariableDeclaration              = rangeVariableDeclaration;
            this.hasSpaceAfterRangeVariableDeclaration = !rangeVariableDeclaration.isNull();
        }

        @Override
        public void test(Expression expression) {
            assertInstance(expression, UpdateClause.class);

            UpdateClause updateClause = (UpdateClause) expression;
            assertEquals(toString(),                            updateClause.toParsedText());
            assertEquals(!rangeVariableDeclaration.isNull(),    updateClause.hasRangeVariableDeclaration());
            assertEquals(hasSet,                                updateClause.hasSet());
            assertEquals(hasSpaceAfterSet,                      updateClause.hasSpaceAfterSet());
            assertEquals(hasSpaceAfterUpdate,                   updateClause.hasSpaceAfterUpdate());
            assertEquals(!updateItems.isNull(),                 updateClause.hasUpdateItems());
            assertEquals(hasSpaceAfterRangeVariableDeclaration, updateClause.hasSpaceAfterRangeVariableDeclaration());

            rangeVariableDeclaration.test(updateClause.getRangeVariableDeclaration());
            updateItems.test(updateClause.getUpdateItems());
        }

        @Override
        public String toString() {
            StringBuilder sb = new StringBuilder();
            sb.append(UPDATE);
            if (hasSpaceAfterUpdate) {
                sb.append(SPACE);
            }
            sb.append(rangeVariableDeclaration);
            if (hasSpaceAfterRangeVariableDeclaration) {
                sb.append(SPACE);
            }
            if (hasSet) {
                sb.append(SET);
            }
            if (hasSpaceAfterSet) {
                sb.append(SPACE);
            }
            sb.append(updateItems);
            return sb.toString();
        }
    }

    public static final class UpdateItemTester extends AbstractExpressionTester {

        public boolean hasEqualSign;
        public boolean hasSpaceAfterEqualSign;
        public boolean hasSpaceAfterStateFieldPathExpression;
        private ExpressionTester newValue;
        private ExpressionTester stateFieldPathExpression;

        protected UpdateItemTester(ExpressionTester stateFieldPathExpression,
                                   ExpressionTester newValue) {

            super();
            this.stateFieldPathExpression = stateFieldPathExpression;
            this.newValue = newValue;
            this.hasSpaceAfterStateFieldPathExpression = true;
            this.hasSpaceAfterEqualSign = true;
            this.hasEqualSign = true;
        }

        @Override
        public void test(Expression expression) {
            assertInstance(expression, UpdateItem.class);

            UpdateItem updateItem = (UpdateItem) expression;
            assertEquals(toString(),                            updateItem.toParsedText());
            assertEquals(hasEqualSign,                          updateItem.hasEqualSign());
            assertEquals(!newValue.isNull(),                    updateItem.hasNewValue());
            assertEquals(hasSpaceAfterEqualSign,                updateItem.hasSpaceAfterEqualSign());
            assertEquals(hasSpaceAfterStateFieldPathExpression, updateItem.hasSpaceAfterStateFieldPathExpression());
            assertEquals(!stateFieldPathExpression.isNull(),    updateItem.hasStateFieldPathExpression());

            stateFieldPathExpression.test(updateItem.getStateFieldPathExpression());
            newValue.test(updateItem.getNewValue());
        }

        @Override
        public String toString() {
            StringBuilder sb = new StringBuilder();
            sb.append(stateFieldPathExpression);
            if (hasSpaceAfterStateFieldPathExpression) {
                sb.append(SPACE);
            }
            if (hasEqualSign) {
                sb.append(EQUAL);
            }
            if (hasSpaceAfterEqualSign) {
                sb.append(SPACE);
            }
            sb.append(newValue);
            return sb.toString();
        }
    }

    public static final class UpdateStatementTester extends AbstractExpressionTester {

        public boolean hasSpaceAfterUpdateClause;
        private ExpressionTester updateClause;
        private ExpressionTester whereClause;

        protected UpdateStatementTester(ExpressionTester updateClause, ExpressionTester whereClause) {
            super();
            this.updateClause = updateClause;
            this.whereClause  = whereClause;
            this.hasSpaceAfterUpdateClause = !whereClause.isNull();
        }

        @Override
        public void test(Expression expression) {
            assertInstance(expression, UpdateStatement.class);

            UpdateStatement updateStatement = (UpdateStatement) expression;
            assertEquals(toString(), updateStatement.toParsedText());
            assertEquals(hasSpaceAfterUpdateClause, updateStatement.hasSpaceAfterUpdateClause());
            assertEquals(!whereClause.isNull(),     updateStatement.hasWhereClause());

            updateClause.test(updateStatement.getUpdateClause());
            whereClause .test(updateStatement.getWhereClause());
        }

        @Override
        public String toString() {
            StringBuilder sb = new StringBuilder();
            sb.append(updateClause);

            if (hasSpaceAfterUpdateClause) {
                sb.append(SPACE);
            }

            sb.append(whereClause);
            return sb.toString();
        }
    }

    public static final class UpperExpressionTester extends AbstractSingleEncapsulatedExpressionTester {

        protected UpperExpressionTester(ExpressionTester expression) {
            super(expression);
        }

        @Override
        protected Class<? extends AbstractSingleEncapsulatedExpression> expressionType() {
            return UpperExpression.class;
        }

        @Override
        protected String identifier() {
            return UPPER;
        }
    }

    public static final class WhenClauseTester extends AbstractExpressionTester {

        public boolean hasSpaceAfterThen;
        public boolean hasSpaceAfterWhen;
        public boolean hasSpaceAfterWhenExpression;
        public boolean hasThen;
        private ExpressionTester thenExpression;
        private ExpressionTester whenExpression;

        protected WhenClauseTester(ExpressionTester whenExpression, ExpressionTester thenExpression) {
            super();
            this.hasSpaceAfterWhenExpression = true;
            this.hasSpaceAfterThen           = true;
            this.hasSpaceAfterWhen           = true;
            this.hasThen                     = true;
            this.thenExpression              = thenExpression;
            this.whenExpression              = whenExpression;
        }

        @Override
        public void test(Expression expression) {
            assertInstance(expression, WhenClause.class);

            WhenClause whenClause = (WhenClause) expression;
            assertEquals(toString(),                  whenClause.toParsedText());
            assertEquals(!whenExpression.isNull(),    whenClause.hasWhenExpression());
            assertEquals(hasSpaceAfterWhenExpression, whenClause.hasSpaceAfterWhenExpression());
            assertEquals(hasSpaceAfterThen,           whenClause.hasSpaceAfterThen());
            assertEquals(hasSpaceAfterWhen,           whenClause.hasSpaceAfterWhen());
            assertEquals(hasThen,                     whenClause.hasThen());
            assertEquals(!thenExpression.isNull(),    whenClause.hasThenExpression());

            whenExpression.test(whenClause.getWhenExpression());
            thenExpression.test(whenClause.getThenExpression());
        }

        @Override
        public String toString() {
            StringBuilder sb = new StringBuilder();
            sb.append(WHEN);
            if (hasSpaceAfterWhen) {
                sb.append(SPACE);
            }
            sb.append(whenExpression);
            if (hasSpaceAfterWhenExpression) {
                sb.append(SPACE);
            }
            if (hasThen) {
                sb.append(THEN);
            }
            if (hasSpaceAfterWhen) {
                sb.append(SPACE);
            }
            sb.append(thenExpression);
            return sb.toString();
        }
    }

    public static final class WhereClauseTester extends AbstractConditionalClauseTester {

        protected WhereClauseTester(ExpressionTester conditionalExpression) {
            super(conditionalExpression);
        }

        @Override
        protected Class<? extends AbstractConditionalClause> expressionType() {
            return WhereClause.class;
        }

        @Override
        protected String identifier() {
            return WHERE;
        }
    }
}