/*
 * 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.tools;

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import jpql.query.Address;
import jpql.query.Alias;
import jpql.query.CodeAssist;
import jpql.query.Customer;
import jpql.query.Employee;
import jpql.query.Product;
import org.eclipse.persistence.jpa.jpql.ExpressionTools;
import org.eclipse.persistence.jpa.jpql.utility.CollectionTools;
import org.junit.Assert;
import org.junit.Ignore;
import org.junit.Test;
import static org.eclipse.persistence.jpa.jpql.parser.Expression.*;

/**
 * This unit-test tests the JPQL content assist at various position within a JPQL query, which can
 * be complete, incomplete or invalid.
 *
 * @version 2.5.1
 * @since 2.3
 * @author Pascal Filion
 */
@SuppressWarnings("nls")
public abstract class AbstractContentAssistTest extends ContentAssistTest {

    /**
     * Creates the list of possible identifiers representing the clauses that is between the given
     * range of clauses.
     *
     * @param afterIdentifier The lower part of the range, which indicates from where to start, this
     * JPQL identifier is not added to the list
     * @param beforeIdentifier The upper part of the range, which indicates when to stop, this JPQL
     * identifier is not added to the list
     * @param subquery Determines whether the range is within a subquery or from the top-level query,
     * which filters out some JPQL identifiers
     * @return The list of JPQL identifiers representing the clauses within the specified range
     */
    protected List<String> clauses(String afterIdentifier, String beforeIdentifier, boolean subquery) {

        List<String> proposals = new ArrayList<>();

        if (afterIdentifier == SELECT) {

            if (beforeIdentifier != FROM) {
                proposals.add(FROM);
            }

            if (beforeIdentifier != FROM &&
                beforeIdentifier != WHERE) {

                proposals.add(WHERE);
            }

            if (beforeIdentifier != FROM  &&
                beforeIdentifier != WHERE &&
                beforeIdentifier != GROUP_BY) {

                proposals.add(GROUP_BY);
            }

            if (beforeIdentifier != FROM     &&
                beforeIdentifier != WHERE    &&
                beforeIdentifier != GROUP_BY &&
                beforeIdentifier != HAVING) {

                proposals.add(HAVING);
            }

            if (!subquery) {
                if (beforeIdentifier != FROM     &&
                    beforeIdentifier != WHERE    &&
                    beforeIdentifier != GROUP_BY &&
                    beforeIdentifier != HAVING   &&
                    beforeIdentifier != ORDER_BY) {

                    proposals.add(ORDER_BY);
                }
            }
        }
        else if (afterIdentifier == FROM) {

            if (beforeIdentifier != WHERE) {
                proposals.add(WHERE);
            }

            if (beforeIdentifier != WHERE &&
                beforeIdentifier != GROUP_BY) {

                proposals.add(GROUP_BY);
            }

            if (beforeIdentifier != WHERE    &&
                beforeIdentifier != GROUP_BY &&
                beforeIdentifier != HAVING) {

                proposals.add(HAVING);
            }

            if (!subquery) {
                if (beforeIdentifier != WHERE    &&
                    beforeIdentifier != GROUP_BY &&
                    beforeIdentifier != HAVING   &&
                    beforeIdentifier != ORDER_BY) {

                    proposals.add(ORDER_BY);
                }
            }
        }
        else if (afterIdentifier == WHERE) {

            if (beforeIdentifier != GROUP_BY) {
                proposals.add(GROUP_BY);
            }

            if (beforeIdentifier != GROUP_BY &&
                beforeIdentifier != HAVING) {

                proposals.add(HAVING);
            }

            if (!subquery) {
                if (beforeIdentifier != GROUP_BY &&
                    beforeIdentifier != HAVING   &&
                    beforeIdentifier != ORDER_BY) {

                    proposals.add(ORDER_BY);
                }
            }
        }
        else if (afterIdentifier == GROUP_BY) {

            if (beforeIdentifier != HAVING) {
                proposals.add(HAVING);
            }

            if (!subquery) {
                if (beforeIdentifier != HAVING   &&
                    beforeIdentifier != ORDER_BY) {

                    proposals.add(ORDER_BY);
                }
            }
        }
        else if (afterIdentifier == HAVING) {
            if (!subquery) {
                if (beforeIdentifier != ORDER_BY) {
                    proposals.add(ORDER_BY);
                }
            }
        }

        return proposals;
    }

    /**
     * Creates the list of JPQL identifiers of the clauses owned by the <code><b>FROM</b></code> clause.
     *
     * @param afterIdentifier The lower part of the range
     * @return The list of the clauses within the <code><b>FROM</b></code> clause that is within the
     * specified range
     */
    protected List<String> fromClauseInternalClauses(String afterIdentifier) {

        if (afterIdentifier == FROM) {

            List<String> proposals = joinIdentifiers();

            if (isJPA2_1()) {
                proposals.add(ON);
            }

            return proposals;
        }

        return Collections.emptyList();
    }

    protected Iterable<String> functionProposals() {

        List<String> identifiers = CollectionTools.list(
            bnfAccessor.conditionalExpressionsFunctions().iterator()
        );

        Collections.sort(identifiers);
        return identifiers;
    }

    /**
     * Determines whether a <code><b>JOIN FETCH</b></code> expression can be identified with an
     * identification variable.
     *
     * @return <code>true</code> if it can be identified by an identification variable;
     * <code>false</code> otherwise
     */
    protected abstract boolean isJoinFetchIdentifiable();

    @Test
    public final void test_Avg_01() {
        String jpqlQuery = "SELECT ";
        int position = jpqlQuery.length();
        testHasTheseProposals(jpqlQuery, position, AVG);
    }

    @Test
    public final void test_Avg_02() {
        String jpqlQuery = "SELECT A";
        int position = jpqlQuery.length();
        testHasTheseProposals(jpqlQuery, position, AVG);
    }

    @Test
    public final void test_Avg_03() {
        String jpqlQuery = "SELECT AV";
        int position = jpqlQuery.length();
        testHasTheseProposals(jpqlQuery, position, AVG);
    }

    @Test
    public final void test_Avg_04() {
        String jpqlQuery = "SELECT AVG";
        int position = jpqlQuery.length();
        testHasTheseProposals(jpqlQuery, position, AVG);
    }

    @Test
    public final void test_Avg_05() {

        String jpqlQuery = "SELECT AVG(";
        int position = jpqlQuery.length();

        List<String> proposals = new ArrayList<>();
        proposals.add(DISTINCT);
        CollectionTools.addAll(proposals, bnfAccessor.internalAggregateFunctionFunctions());

        testHasOnlyTheseProposals(jpqlQuery, position, proposals);
    }

    @Test
    public final void test_Avg_06() {

        String jpqlQuery = "SELECT AVG() From Employee e";
        int position = "SELECT AVG(".length();

        List<String> proposals = new ArrayList<>();
        proposals.add("e");
        proposals.add(DISTINCT);
        CollectionTools.addAll(proposals, bnfAccessor.internalAggregateFunctionFunctions());

        testHasOnlyTheseProposals(jpqlQuery, position, proposals);
    }

    @Test
    public final void test_Avg_07() {

        String jpqlQuery = "SELECT AVG(DISTINCT ) From Employee e";
        int position = "SELECT AVG(DISTINCT ".length();

        List<String> proposals = new ArrayList<>();
        proposals.add("e");
        CollectionTools.addAll(proposals, bnfAccessor.internalAggregateFunctionFunctions());

        testHasOnlyTheseProposals(jpqlQuery, position, proposals);
    }

    @Test
    public final void test_Avg_08() {
        String jpqlQuery = "SELECT AVG(D ) From Employee e";
        int position = "SELECT AVG(D".length();
        testHasOnlyTheseProposals(jpqlQuery, position, DISTINCT);
    }

    @Test
    public final void test_Avg_09() {
        String jpqlQuery = "SELECT AVG(DI ) From Employee e";
        int position = "SELECT AVG(DI".length();
        testHasOnlyTheseProposals(jpqlQuery, position, DISTINCT);
    }

    @Test
    public final void test_Avg_10() {
        String jpqlQuery = "SELECT AVG(DIS ) From Employee e";
        int position = "SELECT AVG(DIS".length();
        testHasOnlyTheseProposals(jpqlQuery, position, DISTINCT);
    }

    @Test
    public final void test_Avg_11() {
        String jpqlQuery = "SELECT AVG(DISTINCT e) From Employee e";
        int position = "SELECT AVG(".length();
        testHasOnlyTheseProposals(jpqlQuery, position, DISTINCT);
    }

    @Test
    public final void test_Avg_12() {
        String jpqlQuery = "SELECT AVG(DISTINCT e) From Employee e";
        int position = "SELECT AVG(D".length();
        testHasOnlyTheseProposals(jpqlQuery, position, DISTINCT);
    }

    @Test
    public final void test_Avg_13() {
        String jpqlQuery = "SELECT AVG(DISTINCT e) From Employee e";
        int position = "SELECT AVG(DI".length();
        testHasOnlyTheseProposals(jpqlQuery, position, DISTINCT);
    }

    @Test
    public final void test_Avg_14() {

        String jpqlQuery = "SELECT AVG(DISTINCT e) From Employee e";
        int position = "SELECT AVG(DISTINCT ".length();

        List<String> proposals = new ArrayList<>();
        proposals.add("e");
        CollectionTools.addAll(proposals, bnfAccessor.internalAggregateFunctionFunctions());

        testHasOnlyTheseProposals(jpqlQuery, position, proposals);
    }

    @Test
    public final void test_Avg_15() {

        String jpqlQuery = "SELECT AVG(DISTINCT e) From Employee e";
        int position = "SELECT AVG(DISTINCT e".length();

        List<String> proposals = new ArrayList<>();
        proposals.add("e");
        CollectionTools.addAll(proposals, filter(bnfAccessor.internalAggregateFunctionFunctions(), "e"));

        testHasOnlyTheseProposals(jpqlQuery, position, proposals);
    }

    @Test
    public final void test_Avg_16() {
        String jpqlQuery = "SELECT AVG(DISTINCT e) From Employee emp";
        int position = "SELECT AVG(DISTINCT e".length();

        List<String> proposals = new ArrayList<>();
        proposals.add("emp");
        CollectionTools.addAll(proposals, filter(bnfAccessor.internalAggregateFunctionFunctions(), "e"));

        testHasOnlyTheseProposals(jpqlQuery, position, proposals);
    }

    @Test
    public final void test_Avg_17() {

        String jpqlQuery = "SELECT AVG() From Employee emp";
        int position = "SELECT AVG(".length();

        List<String> proposals = new ArrayList<>();
        proposals.add("emp");
        proposals.add(DISTINCT);
        CollectionTools.addAll(proposals, bnfAccessor.internalAggregateFunctionFunctions());

        testHasOnlyTheseProposals(jpqlQuery, position, proposals);
    }

    @Test
    public final void test_Avg_18() {

        String jpqlQuery = "SELECT AVG(e) From Employee emp";
        int position = "SELECT AVG(e".length();

        List<String> proposals = new ArrayList<>();
        proposals.add("emp");
        CollectionTools.addAll(proposals, filter(bnfAccessor.internalAggregateFunctionFunctions(), "e"));

        testHasOnlyTheseProposals(jpqlQuery, position, proposals);
    }

    @Test
    public final void test_Avg_19() {
        String jpqlQuery = "SELECT AVG(em) From Employee emp";
        int position = "SELECT AVG(em".length();
        testHasOnlyTheseProposals(jpqlQuery, position, "emp");
    }

    @Test
    public final void test_Avg_20() {
        String jpqlQuery = "SELECT AVG(emp) From Employee emp";
        int position = "SELECT AVG(emp".length();
        testHasOnlyTheseProposals(jpqlQuery, position, "emp");
    }

    @Test
    public final void test_Avg_21() {

        String jpqlQuery = "SELECT AVG(emp) From Employee emp";
        int position = "SELECT AVG(e".length();

        List<String> proposals = new ArrayList<>();
        proposals.add("emp");
        CollectionTools.addAll(proposals, filter(bnfAccessor.internalAggregateFunctionFunctions(), "e"));

        testHasOnlyTheseProposals(jpqlQuery, position, proposals);
    }

    @Test
    public final void test_Avg_22() {
        String jpqlQuery = "SELECT AVG(emp) From Employee emp";
        int position = "SELECT AVG(em".length();
        testHasOnlyTheseProposals(jpqlQuery, position, "emp");
    }

    @Test
    public final void test_Avg_23() {

        String jpqlQuery = "SELECT AVG( From Employee emp";
        int position = "SELECT AVG(".length();

        List<String> proposals = new ArrayList<>();
        proposals.add("emp");
        proposals.add(DISTINCT);
        CollectionTools.addAll(proposals, bnfAccessor.internalAggregateFunctionFunctions());

        testHasOnlyTheseProposals(jpqlQuery, position, proposals);
    }

    @Test
    public final void test_Avg_24() {

        String jpqlQuery = "SELECT AVG(e From Employee emp";
        int position = "SELECT AVG(e".length();

        List<String> proposals = new ArrayList<>();
        proposals.add("emp");
        CollectionTools.addAll(proposals, filter(bnfAccessor.internalAggregateFunctionFunctions(), "e"));

        testHasOnlyTheseProposals(jpqlQuery, position, proposals);
    }

    @Test
    public final void test_Between_01() {
        String jpqlQuery = "SELECT e FROM Employee e WHERE ";
        int position = jpqlQuery.length();
        testDoesNotHaveTheseProposals(jpqlQuery, position, BETWEEN);
    }

    @Test
    public final void test_Between_02() {
        String jpqlQuery = "SELECT e FROM Employee e WHERE e.roomNumber ";
        int position = jpqlQuery.length();
        testHasTheseProposals(jpqlQuery, position, BETWEEN, NOT_BETWEEN);
    }

    @Test
    public final void test_Between_03() {
        String jpqlQuery = "SELECT e FROM Employee e WHERE e.roomNumber B";
        int position = jpqlQuery.length();
        testHasOnlyTheseProposals(jpqlQuery, position, BETWEEN);
    }

    @Test
    public final void test_Between_04() {
        String jpqlQuery = "SELECT e FROM Employee e WHERE e.roomNumber BE";
        int position = jpqlQuery.length();
        testHasOnlyTheseProposals(jpqlQuery, position, BETWEEN);
    }

    @Test
    public final void test_Between_05() {
        String jpqlQuery = "SELECT e FROM Employee e WHERE e.roomNumber BET";
        int position = jpqlQuery.length();
        testHasOnlyTheseProposals(jpqlQuery, position, BETWEEN);
    }

    @Test
    public final void test_Between_06() {
        String jpqlQuery = "SELECT e FROM Employee e WHERE e.roomNumber BETW";
        int position = jpqlQuery.length();
        testHasOnlyTheseProposals(jpqlQuery, position, BETWEEN);
    }

    @Test
    public final void test_Between_07() {
        String jpqlQuery = "SELECT e FROM Employee e WHERE e.roomNumber BETWE";
        int position = jpqlQuery.length();
        testHasOnlyTheseProposals(jpqlQuery, position, BETWEEN);
    }

    @Test
    public final void test_Between_08() {
        String jpqlQuery = "SELECT e FROM Employee e WHERE e.roomNumber BETWEE";
        int position = jpqlQuery.length();
        testHasOnlyTheseProposals(jpqlQuery, position, BETWEEN);
    }

    @Test
    public final void test_Between_09() {
        String jpqlQuery = "SELECT e FROM Employee e WHERE e.roomNumber BETWEEN";
        int position = jpqlQuery.length();
        testHasOnlyTheseProposals(jpqlQuery, position, BETWEEN, NOT_BETWEEN);
    }

    @Test
    public final void test_Between_10() {
        String jpqlQuery = "SELECT e FROM Employee e WHERE e.roomNumber NOT";
        int position = jpqlQuery.length();
        testHasTheseProposals(jpqlQuery, position, NOT_BETWEEN);
    }

    @Test
    public final void test_Between_11() {
        String jpqlQuery = "SELECT e FROM Employee e WHERE e.roomNumber NOT ";
        int position = jpqlQuery.length();
        testHasTheseProposals(jpqlQuery, position, NOT_BETWEEN);
    }

    @Test
    public final void test_Between_12() {
        String jpqlQuery = "SELECT e FROM Employee e WHERE e.roomNumber NOT B";
        int position = jpqlQuery.length();
        testHasOnlyTheseProposals(jpqlQuery, position, NOT_BETWEEN);
    }

    @Test
    public final void test_Between_13() {
        String jpqlQuery = "SELECT e FROM Employee e WHERE e.roomNumber BETWEEN 1 ";
        int position = jpqlQuery.length();
        testHasOnlyTheseProposals(jpqlQuery, position, AND);
    }

    @Test
    public final void test_Between_14() {
        String jpqlQuery = "SELECT e FROM Employee e WHERE e.roomNumber BETWEEN 1 A";
        int position = jpqlQuery.length();
        testHasOnlyTheseProposals(jpqlQuery, position, AND);
    }

    @Test
    public final void test_Between_15() {
        String jpqlQuery = "SELECT e FROM Employee e WHERE e.roomNumber BETWEEN 1 AN";
        int position = jpqlQuery.length();
        testHasOnlyTheseProposals(jpqlQuery, position, AND);
    }

    @Test
    public final void test_Between_16() {
        String jpqlQuery = "SELECT e FROM Employee e WHERE e.roomNumber BETWEEN 1 AND";
        int position = jpqlQuery.length();
        testHasOnlyTheseProposals(jpqlQuery, position, AND);
    }

    @Test
    public final void test_Between_17() {
        String jpqlQuery = "SELECT e FROM Employee e WHERE e.roomNumber BETWEEN 1 AND ";
        int position = jpqlQuery.length();
        testDoesNotHaveTheseProposals(jpqlQuery, position, AND);
    }

    @Test
    public final void test_Between_18() {
        String jpqlQuery = "SELECT e FROM Employee e WHERE e.roomNumber B";
        int position = "SELECT e FROM Employee e WHERE e.roomNumber ".length();
        testHasTheseProposals(jpqlQuery, position, BETWEEN);
    }

    @Test
    public final void test_Between_19() {
        String jpqlQuery = "SELECT e FROM Employee e WHERE e.roomNumber BE";
        int position = "SELECT e FROM Employee e WHERE e.roomNumber ".length();
        testHasTheseProposals(jpqlQuery, position, BETWEEN);
    }

    @Test
    public final void test_Between_20() {
        String jpqlQuery = "SELECT e FROM Employee e WHERE e.roomNumber BET";
        int position = "SELECT e FROM Employee e WHERE e.roomNumber ".length();
        testHasTheseProposals(jpqlQuery, position, BETWEEN);
    }

    @Test
    public final void test_Between_21() {
        String jpqlQuery = "SELECT e FROM Employee e WHERE e.roomNumber BETW";
        int position = "SELECT e FROM Employee e WHERE e.roomNumber ".length();
        testHasTheseProposals(jpqlQuery, position, BETWEEN);
    }

    @Test
    public final void test_Between_22() {
        String jpqlQuery = "SELECT e FROM Employee e WHERE e.roomNumber BETWE";
        int position = "SELECT e FROM Employee e WHERE e.roomNumber ".length();
        testHasTheseProposals(jpqlQuery, position, BETWEEN);
    }

    @Test
    public final void test_Between_32() {
        String jpqlQuery = "SELECT e FROM Employee e WHERE e.roomNumber BETWEE";
        int position = "SELECT e FROM Employee e WHERE e.roomNumber ".length();
        testHasTheseProposals(jpqlQuery, position, BETWEEN);
    }

    @Test
    public final void test_Between_33() {
        String jpqlQuery = "SELECT e FROM Employee e WHERE e.roomNumber BETWEEN";
        int position = "SELECT e FROM Employee e WHERE e.roomNumber ".length();
        testHasTheseProposals(jpqlQuery, position, BETWEEN);
    }

    @Test
    public final void test_CollectionMember_01() {
        String jpqlQuery = "SELECT e FROM Employee e WHERE ";
        int position = jpqlQuery.length();
        testDoesNotHaveTheseProposals(jpqlQuery, position, MEMBER);
    }

    @Test
    public final void test_CollectionMember_02() {
        String jpqlQuery = "SELECT e FROM Employee e WHERE e ";
        int position = jpqlQuery.length();
        testHasTheseProposals(jpqlQuery, position, MEMBER, NOT_MEMBER);
    }

    @Test
    public final void test_CollectionMember_03() {
        String jpqlQuery = "SELECT e FROM Employee e WHERE e N";
        int position = jpqlQuery.length();
        testHasTheseProposals(jpqlQuery, position, NOT_MEMBER);
    }

    @Test
    public final void test_CollectionMember_04() {
        String jpqlQuery = "SELECT e FROM Employee e WHERE e NO";
        int position = jpqlQuery.length();
        testHasTheseProposals(jpqlQuery, position, NOT_MEMBER);
    }

    @Test
    public final void test_CollectionMember_05() {
        String jpqlQuery = "SELECT e FROM Employee e WHERE e.name NOT";
        int position = jpqlQuery.length();
        testHasTheseProposals(jpqlQuery, position, NOT_MEMBER);
    }

    @Test
    public final void test_CollectionMember_06() {
        String jpqlQuery = "SELECT e FROM Employee e WHERE e.name NOT ";
        int position = jpqlQuery.length();
        testHasTheseProposals(jpqlQuery, position, NOT_MEMBER);
    }

    @Test
    public final void test_CollectionMember_07() {
        String jpqlQuery = "SELECT e FROM Employee e WHERE e.name NOT M";
        int position = jpqlQuery.length();
        testHasOnlyTheseProposals(jpqlQuery, position, NOT_MEMBER, NOT_MEMBER_OF);
    }

    @Test
    public final void test_CollectionMember_08() {
        String jpqlQuery = "SELECT e FROM Employee e WHERE e.name NOT ME";
        int position = jpqlQuery.length();
        testHasOnlyTheseProposals(jpqlQuery, position, NOT_MEMBER, NOT_MEMBER_OF);
    }

    @Test
    public final void test_CollectionMember_09() {
        String jpqlQuery = "SELECT e FROM Employee e WHERE e.name NOT MEM";
        int position = jpqlQuery.length();
        testHasOnlyTheseProposals(jpqlQuery, position, NOT_MEMBER, NOT_MEMBER_OF);
    }

    @Test
    public final void test_CollectionMember_10() {
        String jpqlQuery = "SELECT e FROM Employee e WHERE e NOT MEMB";
        int position = jpqlQuery.length();
        testHasOnlyTheseProposals(jpqlQuery, position, NOT_MEMBER, NOT_MEMBER_OF);
    }

    @Test
    public final void test_CollectionMember_11() {
        String jpqlQuery = "SELECT e FROM Employee e WHERE e NOT MEMBE";
        int position = jpqlQuery.length();
        testHasOnlyTheseProposals(jpqlQuery, position, NOT_MEMBER, NOT_MEMBER_OF);
    }

    @Test
    public final void test_CollectionMember_12() {
        String jpqlQuery = "SELECT e FROM Employee e WHERE e.name NOT MEMBER";
        int position = jpqlQuery.length();
        testHasOnlyTheseProposals(jpqlQuery, position, MEMBER, MEMBER_OF, NOT_MEMBER, NOT_MEMBER_OF);
    }

    @Test
    public final void test_CollectionMember_13() {
        String jpqlQuery = "SELECT e FROM Employee e WHERE e.name NOT MEMBER ";
        int position = jpqlQuery.length();
        testHasOnlyTheseProposals(jpqlQuery, position, "e", OF);
    }

    @Test
    public final void test_CollectionMember_14() {
        String jpqlQuery = "SELECT e FROM Employee e WHERE e.name NOT MEMBER O";
        int position = jpqlQuery.length();
        testHasOnlyTheseProposals(jpqlQuery, position, OF);
    }

    @Test
    public final void test_CollectionMember_15() {
        String jpqlQuery = "SELECT e FROM Employee e WHERE e.name NOT MEMBER OF";
        int position = jpqlQuery.length();
        testHasOnlyTheseProposals(jpqlQuery, position, MEMBER, MEMBER_OF, NOT_MEMBER_OF, NOT_MEMBER);
    }

    @Test
    public final void test_CollectionMember_16() {
        String jpqlQuery = "SELECT e FROM Employee e WHERE e.name M";
        int position = jpqlQuery.length();
        testHasTheseProposals(jpqlQuery, position, MEMBER);
    }

    @Test
    public final void test_CollectionMember_17() {
        String jpqlQuery = "SELECT e FROM Employee e WHERE e.name ME";
        int position = jpqlQuery.length();
        testHasTheseProposals(jpqlQuery, position, MEMBER);
    }

    @Test
    public final void test_CollectionMember_18() {
        String jpqlQuery = "SELECT e FROM Employee e WHERE e.name MEM";
        int position = jpqlQuery.length();
        testHasTheseProposals(jpqlQuery, position, MEMBER);
    }

    @Test
    public final void test_CollectionMember_19() {
        String jpqlQuery = "SELECT e FROM Employee e WHERE e.name MEMB";
        int position = jpqlQuery.length();
        testHasTheseProposals(jpqlQuery, position, MEMBER);
    }

    @Test
    public final void test_CollectionMember_20() {
        String jpqlQuery = "SELECT e FROM Employee e WHERE e.name MEMBE";
        int position = jpqlQuery.length();
        testHasTheseProposals(jpqlQuery, position, MEMBER);
    }

    @Test
    public final void test_CollectionMember_21() {
        String jpqlQuery = "SELECT e FROM Employee e WHERE e.name MEMBER";
        int position = jpqlQuery.length();
        testHasTheseProposals(jpqlQuery, position, MEMBER);
    }

    @Test
    public final void test_CollectionMember_22() {
        String jpqlQuery = "SELECT e FROM Employee e WHERE e.name MEMBER ";
        int position = jpqlQuery.length();
        testHasOnlyTheseProposals(jpqlQuery, position, "e", OF);
    }

    @Test
    public final void test_CollectionMember_23() {
        String jpqlQuery = "SELECT e FROM Employee e WHERE e.name MEMBER O";
        int position = jpqlQuery.length();
        testHasOnlyTheseProposals(jpqlQuery, position, OF);
    }

    @Test
    public final void test_CollectionMember_24() {
        String jpqlQuery = "SELECT e FROM Employee e WHERE e.name MEMBER OF";
        int position = jpqlQuery.length();
        testHasOnlyTheseProposals(jpqlQuery, position, MEMBER, MEMBER_OF, NOT_MEMBER, NOT_MEMBER_OF);
    }

    @Test
    public final void test_CollectionMember_25() {
        String jpqlQuery = "SELECT e FROM Employee e WHERE e.name MEMBER OF ";
        int position = jpqlQuery.length();
        testHasOnlyTheseProposals(jpqlQuery, position, "e");
    }

    @Test
    public final void test_CollectionMember_26() {
        String jpqlQuery = "SELECT e FROM Employee e JOIN e.employees emp WHERE e MEMBER OF ";
        int position = jpqlQuery.length();
        testHasOnlyTheseProposals(jpqlQuery, position, "e", "emp");
    }

    @Test
    public final void test_CollectionMember_27() {
        String jpqlQuery = "SELECT e FROM Employee e JOIN e.employees emp WHERE e MEMBER ";
        int position = jpqlQuery.length();
        testHasOnlyTheseProposals(jpqlQuery, position, "e", "emp", OF);
    }

    @Test
    public final void test_CollectionMember_28() {
        String jpqlQuery = "SELECT e FROM Employee e WHERE e.name MEMBER OF e.employees";
        int position = jpqlQuery.length() - "EMBER OF e.employees".length();
        testHasOnlyTheseProposals(jpqlQuery, position, MEMBER, MEMBER_OF, NOT_MEMBER, NOT_MEMBER_OF);
    }

    @Test
    public final void test_CollectionMember_29() {
        String jpqlQuery = "SELECT e FROM Employee e WHERE e.name ";
        int position = jpqlQuery.length();
        testHasTheseProposals(jpqlQuery, position, MEMBER, NOT_MEMBER);
    }

    @Test
    public final void test_CollectionMemberDeclaration_01() {
        String jpqlQuery = "SELECT e FROM Employee e, I";
        int position = jpqlQuery.length();
        testHasTheseProposals(jpqlQuery, position, IN);
    }

    @Test
    public final void test_CollectionMemberDeclaration_02() {
        String jpqlQuery = "SELECT e FROM ";
        int position = jpqlQuery.length();
        testDoesNotHaveTheseProposals(jpqlQuery, position, IN);
    }

    @Test
    public final void test_CollectionMemberDeclaration_03() {
        String jpqlQuery = "SELECT e FROM Employee e, IN(e.names) AS f";
        int position = jpqlQuery.length() - "e, IN(e.names) AS f".length();
        testDoesNotHaveTheseProposals(jpqlQuery, position, IN);
    }

    @Test
    public final void test_CollectionMemberDeclaration_04() {
        String jpqlQuery = "SELECT e FROM Employee e, ";
        int position = jpqlQuery.length();
        testHasTheseProposals(jpqlQuery, position, IN);
    }

    @Test
    public final void test_CollectionMemberDeclaration_05() {
        String jpqlQuery = "SELECT e FROM Employee e, IN";
        int position = jpqlQuery.length();
        testHasTheseProposals(jpqlQuery, position, IN);
    }

    @Test
    public final void test_CollectionMemberDeclaration_06() {
        String jpqlQuery = "SELECT e FROM Employee e, IN(e.name) ";
        int position = jpqlQuery.length();
        testHasTheseProposals(jpqlQuery, position, AS);
        testDoesNotHaveTheseProposals(jpqlQuery, position, IN);
    }

    @Test
    public final void test_CollectionMemberDeclaration_07() {
        String jpqlQuery = "SELECT e FROM Employee e, IN(e.name) A";
        int position = jpqlQuery.length();
        testHasOnlyTheseProposals(jpqlQuery, position, AS);
    }

    @Test
    public final void test_CollectionMemberDeclaration_08() {
        String jpqlQuery = "SELECT e FROM Employee e, IN(e.name) AS";
        int position = jpqlQuery.length();
        testHasOnlyTheseProposals(jpqlQuery, position, AS);
    }

    @Test
    public final void test_CollectionMemberDeclaration_09() {
        String jpqlQuery = "SELECT e FROM Employee e, IN(e.name) AS ";
        int position = jpqlQuery.length();
        testDoesNotHaveTheseProposals(jpqlQuery, position, AS);
    }

    @Test
    public final void test_CollectionMemberDeclaration_10() {
        String jpqlQuery = "SELECT e FROM Employee e, IN(e.name) AS n";
        int position = jpqlQuery.length();
        testDoesNotHaveTheseProposals(jpqlQuery, position, AS);
    }

    @Test
    public final void test_CollectionMemberDeclaration_11() {
        String jpqlQuery = "SELECT e FROM Employee e, IN(e.name) AS n";
        int position = "SELECT e FROM Employee e, ".length();
        testHasTheseProposals(jpqlQuery, position, IN);
    }

    @Test
    public final void test_CollectionMemberDeclaration_12() {
        String jpqlQuery = "SELECT e FROM Employee e, IN(e.name) AS n";
        int position = "SELECT e FROM Employee e, I".length();
        testHasOnlyTheseProposals(jpqlQuery, position, IN);
    }

    @Test
    public final void test_CollectionMemberDeclaration_13() {
        String jpqlQuery = "SELECT e FROM Employee e, IN(e.name) AS n";
        int position = "SELECT e FROM Employee e, IN".length();
        testHasTheseProposals(jpqlQuery, position, IN);
    }

    @Test
    public final void test_CollectionMemberDeclaration_14() {

        String jpqlQuery = "SELECT e FROM Employee e, IN(e.name) AS n";
        int position = "SELECT e FROM Employee e, IN(".length();

        List<String> proposals = new ArrayList<>();
        proposals.add("e");
        CollectionTools.addAll(proposals, bnfAccessor.collectionMemberDeclarationParameters());

        testHasOnlyTheseProposals(jpqlQuery, position, proposals);
    }

    @Test
    public final void test_CollectionMemberDeclaration_16() {

        String jpqlQuery = "SELECT e FROM Employee e, IN(";
        int position = jpqlQuery.length();

        List<String> proposals = new ArrayList<>();
        proposals.add("e");
        CollectionTools.addAll(proposals, bnfAccessor.collectionMemberDeclarationParameters());

        testHasOnlyTheseProposals(jpqlQuery, position, proposals);
    }

    @Test
    public final void test_CollectionMemberDeclaration_17() {

        String jpqlQuery = "SELECT e FROM Employee e, IN(e.name) AS n";
        int position = "SELECT e FROM Employee e, IN(".length();

        List<String> proposals = new ArrayList<>();
        proposals.add("e");
        CollectionTools.addAll(proposals, bnfAccessor.collectionMemberDeclarationParameters());

        testHasOnlyTheseProposals(jpqlQuery, position, proposals);
    }

    @Test
    public final void test_CollectionMemberDeclaration_18() {
        String jpqlQuery = "SELECT e FROM Employee e, IN(e.name) AS n";
        int position = "SELECT e FROM Employee e, IN(e.name) ".length();
        testHasOnlyTheseProposals(jpqlQuery, position, AS);
    }

    @Test
    public final void test_CollectionMemberDeclaration_19() {
        String jpqlQuery = "SELECT e FROM Employee e, IN(e.name) AS n";
        int position = "SELECT e FROM Employee e, IN(e.name) A".length();
        testHasOnlyTheseProposals(jpqlQuery, position, AS);
    }

    @Test
    public final void test_CollectionMemberDeclaration_20() {
        String jpqlQuery = "SELECT e FROM Employee e, IN(e.name) AS n";
        int position = "SELECT e FROM Employee e, IN(e.name) AS ".length();
        testDoesNotHaveTheseProposals(jpqlQuery, position, AS);
    }

    @Test
    public final void test_CollectionMemberDeclaration_23() {
        String jpqlQuery = "SELECT e FROM Employee e, IN(K";
        int position = jpqlQuery.length();
        testHasOnlyTheseProposals(jpqlQuery, position, KEY);
    }

    @Test
    public final void test_CollectionMemberDeclaration_24() {
        String jpqlQuery = "SELECT e FROM Employee e, IN(KEY(a)) AS a";
        int position = "SELECT e FROM Employee e, IN(K".length();
        testHasOnlyTheseProposals(jpqlQuery, position, KEY);
    }

    @Test
    public final void test_Comparison_01() {
        String jpqlQuery = "SELECT e FROM Employee e WHERE ";
        int position = jpqlQuery.length();
        testDoesNotHaveTheseProposals(jpqlQuery, position, bnfAccessor.comparators());
    }

    @Test
    public final void test_Comparison_02() {
        String jpqlQuery = "SELECT e FROM Employee e WHERE e.roomNumber ";
        int position = jpqlQuery.length();
        testHasTheseProposals(jpqlQuery, position, bnfAccessor.comparators());
    }

    @Test
    public final void test_Comparison_03() {
        String jpqlQuery = "SELECT e FROM Employee e WHERE e.roomNumber <";
        int position = jpqlQuery.length();
        testHasTheseProposals(jpqlQuery, position, bnfAccessor.comparators());
    }

    @Test
    public final void test_Comparison_04() {
        String jpqlQuery = "SELECT e FROM Employee e WHERE e.roomNumber >";
        int position = jpqlQuery.length();
        testHasTheseProposals(jpqlQuery, position, bnfAccessor.comparators());
    }

    @Test
    public final void test_Comparison_05() {
        String jpqlQuery = "SELECT e FROM Employee e WHERE e.roomNumber =";
        int position = jpqlQuery.length();
        testHasTheseProposals(jpqlQuery, position, bnfAccessor.comparators());
    }

    @Test
    public final void test_Comparison_06() {
        String jpqlQuery = "SELECT e FROM Employee e WHERE e.roomNumber <=";
        int position = jpqlQuery.length();
        testHasTheseProposals(jpqlQuery, position, bnfAccessor.comparators());
    }

    @Test
    public final void test_Comparison_07() {
        String jpqlQuery = "SELECT e FROM Employee e WHERE e.roomNumber >=";
        int position = jpqlQuery.length();
        testHasTheseProposals(jpqlQuery, position, bnfAccessor.comparators());
    }

    @Test
    public final void test_Comparison_08() {
        String jpqlQuery = "SELECT e FROM Employee e WHERE e.roomNumber <>";
        int position = jpqlQuery.length();
        testHasTheseProposals(jpqlQuery, position, bnfAccessor.comparators());
    }

    @Test
    public final void test_Comparison_09() {
        String jpqlQuery = "SELECT e FROM Employee e WHERE e.roomNumber IS ";
        int position = jpqlQuery.length();
        testDoesNotHaveTheseProposals(jpqlQuery, position, bnfAccessor.comparators());
    }

    @Test
    public final void test_Comparison_10() {

        String jpqlQuery = "delete from Address as a where current_date ";
        int position = jpqlQuery.length();

        List<String> proposals = new ArrayList<>();
        CollectionTools.addAll(proposals, bnfAccessor.comparators());
        CollectionTools.addAll(proposals, bnfAccessor.arithmetics());
        CollectionTools.addAll(proposals, bnfAccessor.conditionalExpressionsCompoundFunctions());

        // These are filtered out
        proposals.remove(IS_EMPTY);
        proposals.remove(IS_NOT_EMPTY);

        testHasOnlyTheseProposals(jpqlQuery, position, proposals);
    }

    protected final void test_CompoundFunction(String identifier) {

        String jpqlQuery = "SELECT e FROM Employee e " + identifier + " e.roomNumber ";
        int position = jpqlQuery.length();

        List<String> proposals = new ArrayList<>();
        CollectionTools.addAll(proposals, bnfAccessor.conditionalExpressionsAggregates());
        CollectionTools.addAll(proposals, bnfAccessor.conditionalExpressionsCompoundFunctions());

        // These are filtered out
        proposals.remove(AND);
        proposals.remove(OR);
        proposals.remove(IS_EMPTY);
        proposals.remove(IS_NOT_EMPTY);

        testHasOnlyTheseProposals(jpqlQuery, position, proposals);
    }

    @Test
    public final void test_CompoundFunction_01() {
        test_CompoundFunction(WHERE);
    }

    @Test
    public final void test_CompoundFunction_02() {
        test_CompoundFunction(HAVING);
    }

    @Test
    public final void test_CompoundFunction_03() {
        test_CompoundFunction("WHERE CASE WHEN");
    }

    @Test
    public final void test_Concat_34() {

        String jpqlQuery = "SELECT e FROM Employee e WHERE CONCAT(e.name, AS e)";
        int position = "SELECT e FROM Employee e WHERE CONCAT(e.name, ".length();

        List<String> proposals = new ArrayList<>();
        proposals.add("e");
        CollectionTools.addAll(proposals, bnfAccessor.internalConcatExpressionFunctions());

        testHasOnlyTheseProposals(jpqlQuery, position, proposals);
    }

    @Test
    public final void test_Concat_35() {
        String jpqlQuery = "SELECT e FROM Employee e WHERE CONCAT(e.name, AS e)";
        int position = "SELECT e FROM Employee e WHERE CONCAT(e.name, A".length();
        Iterable<String> proposals = filter(bnfAccessor.internalConcatExpressionFunctions(), "A");
        testHasOnlyTheseProposals(jpqlQuery, position, proposals);
    }

    @Test
    public final void test_Concat_36() {
        String jpqlQuery = "SELECT e FROM Employee e WHERE CONCAT(e.name, AS e.name)";
        int position = "SELECT e FROM Employee e WHERE CONCAT(e.name, AS e.".length();
        testHasNoProposals(jpqlQuery, position);
    }

    @Test
    public final void test_Concat_37() {
        String jpqlQuery = "SELECT e FROM Employee e WHERE CONCAT(e.name, S)";
        int position = "SELECT e FROM Employee e WHERE CONCAT(e.name, S".length();
        Iterable<String> proposals = filter(bnfAccessor.internalConcatExpressionFunctions(), "S");
        testHasOnlyTheseProposals(jpqlQuery, position, proposals);
    }

    @Test
    public final void test_Concat_38() {

        String jpqlQuery = "SELECT e FROM Employee e WHERE CONCAT(e.name, ()";
        int position = "SELECT e FROM Employee e WHERE CONCAT(e.name, (".length();

        List<String> proposals = new ArrayList<>();
        proposals.add("e");
        CollectionTools.addAll(proposals, bnfAccessor.internalConcatExpressionFunctions());
        CollectionTools.addAll(proposals, bnfAccessor.internalConcatExpressionClauses());

        testHasOnlyTheseProposals(jpqlQuery, position, proposals);
    }

    @Test
    public final void test_Concat_39() {

        String jpqlQuery = "SELECT e FROM Employee e WHERE CONCAT(e.name, (S)";
        int position = "SELECT e FROM Employee e WHERE CONCAT(e.name, (S".length();

        List<String> proposals = new ArrayList<>();
        CollectionTools.addAll(proposals, filter(bnfAccessor.internalConcatExpressionFunctions(), "S"));
        CollectionTools.addAll(proposals, filter(bnfAccessor.internalConcatExpressionClauses(), "S"));

        testHasOnlyTheseProposals(jpqlQuery, position, proposals);
    }

    protected final void test_ConditionalClause_01(String identifier) {
        test_ConditionalClause_01(identifier, ExpressionTools.EMPTY_STRING);
    }

    protected final void test_ConditionalClause_01(String identifier, String prepend) {
        String jpqlQuery = "SELECT e FROM Employee e " + prepend;
        int position = jpqlQuery.length();
        testHasTheseProposals(jpqlQuery, position, identifier);
    }

    protected final void test_ConditionalClause_02(String identifier) {
        test_ConditionalClause_02(identifier, ExpressionTools.EMPTY_STRING);
    }

    protected final void test_ConditionalClause_02(String identifier, String prepend) {
        String jpqlQuery = "SELECT e FROM Employee e "+ prepend + identifier + " COUNT(e) >= 5";
        int position = ("SELECT e FROM Employee e " + prepend).length();
        testHasTheseProposals(jpqlQuery, position, identifier);
    }

    protected final void test_ConditionalClause_03(String identifier) {
        test_ConditionalClause_03(identifier, ExpressionTools.EMPTY_STRING);
    }

    protected final void test_ConditionalClause_03(String identifier, String prepend) {

        String fragment = "SELECT e FROM Employee e " + prepend;

        for (int index = 0, count = identifier.length(); index <= count; index++) {

            String jpqlQuery = fragment + identifier.substring(0, index);

            for (int positionIndex = fragment.length(), count2 = jpqlQuery.length(); positionIndex <= count2; positionIndex++) {
                testHasTheseProposals(jpqlQuery, positionIndex, identifier);
            }
        }
    }

    protected final void test_ConditionalClause_04(String identifier) {
        test_ConditionalClause_04(identifier, ExpressionTools.EMPTY_STRING);
    }

    protected final void test_ConditionalClause_04(String identifier, String prepend) {

        String jpqlQuery = "SELECT e FROM Employee e " + prepend + identifier + " (e.name = 'Pascal') ";
        int position = jpqlQuery.length();

        List<String> proposals = new ArrayList<>();
        CollectionTools.addAll(proposals, clauses(identifier, null, false));

        testHasTheseProposals(jpqlQuery, position, proposals);
    }

    protected final void test_ConditionalClause_05(String identifier) {
        test_ConditionalClause_05(identifier, ExpressionTools.EMPTY_STRING);
    }

    protected final void test_ConditionalClause_05(String identifier, String prepend) {

        String jpqlQuery = "SELECT e FROM Employee e " + prepend + identifier + " e.roomNumber ";
        int position = jpqlQuery.length();

        List<String> proposals = new ArrayList<>();
        CollectionTools.addAll(proposals, clauses(identifier, null, false));

        testDoesNotHaveTheseProposals(jpqlQuery, position, proposals);
    }

    protected final void test_ConditionalClause_06(String identifier) {
        test_ConditionalClause_06(identifier, ExpressionTools.EMPTY_STRING);
    }

    protected final void test_ConditionalClause_06(String identifier, String prepend) {

        String jpqlQuery = "SELECT e FROM Employee e " + prepend + identifier + " AVG(e.age) ";
        int position = jpqlQuery.length();

        List<String> proposals = new ArrayList<>();
        CollectionTools.addAll(proposals, clauses(identifier, null, false));

        testDoesNotHaveTheseProposals(jpqlQuery, position, proposals);
    }

    protected final void test_ConditionalClause_07(String identifier) {
        test_ConditionalClause_07(identifier, ExpressionTools.EMPTY_STRING);
    }

    protected final void test_ConditionalClause_07(String identifier, String prepend) {

        String jpqlQuery = "SELECT e FROM Employee e " + prepend + identifier + " ?1 ";
        int position = jpqlQuery.length();

        List<String> proposals = new ArrayList<>();
        CollectionTools.addAll(proposals, clauses(identifier, null, false));

        testDoesNotHaveTheseProposals(jpqlQuery, position, proposals);
    }

    @Test
    public final void test_ConditionalExpression_01() throws Exception {
        String jpqlQuery = "SELECT e FROM Employee e WHERE e.";
        int position = jpqlQuery.length();
        testHasOnlyTheseProposals(jpqlQuery, position, nonTransientFieldNames(Employee.class));
    }

    @Test
    public final void test_Constructor_01() {
        String jpqlQuery = "SELECT ";
        int position = jpqlQuery.length();
        testHasTheseProposals(jpqlQuery, position, NEW);
    }

    @Test
    public final void test_Constructor_02() {
        String jpqlQuery = "SELECT N";
        int position = "SELECT ".length();
        testHasTheseProposals(jpqlQuery, position, NEW);
    }

    @Test
    public final void test_Constructor_03() {
        String jpqlQuery = "SELECT N";
        int position = jpqlQuery.length();
        testHasTheseProposals(jpqlQuery, position, NEW);
    }

    @Test
    public final void test_Constructor_04() {
        String jpqlQuery = "SELECT e, NEW (";
        int position = "SELECT e, ".length();
        testHasTheseProposals(jpqlQuery, position, NEW);
    }

    @Test
    public final void test_Constructor_05() {
        String jpqlQuery = "SELECT e, NEW (";
        int position = "SELECT e, N".length();
        testHasTheseProposals(jpqlQuery, position, NEW);
    }

    @Test
    public final void test_Constructor_06() {

        String jpqlQuery = "SELECT NEW String() From Employee e";
        int position = "SELECT NEW String(".length();

        List<String> proposals = new ArrayList<>();
        proposals.add("e");
        CollectionTools.addAll(proposals, bnfAccessor.constructorItemFunctions());

        testHasOnlyTheseProposals(jpqlQuery, position, proposals);
    }

    @Test
    public final void test_Constructor_07() {

        String jpqlQuery = "SELECT NEW String(e) From Employee e";
        int position = "SELECT NEW String(e".length();

        List<String> proposals = new ArrayList<>();
        proposals.add("e");
        CollectionTools.addAll(proposals, filter(bnfAccessor.constructorItemFunctions(), "e"));

        testHasOnlyTheseProposals(jpqlQuery, position, proposals);
    }

    @Test
    public final void test_Constructor_08() {
        String jpqlQuery = "SELECT e, NEW java.lang.String(e.name)";
        int position = "SELECT e, N".length();
        testHasTheseProposals(jpqlQuery, position, NEW);
    }

    @Test
    public final void test_Constructor_09() {
        String jpqlQuery = "SELECT e, NEW java.lang.String(e.name)";
        int position = "SELECT e, NE".length();
        testHasTheseProposals(jpqlQuery, position, NEW);
    }

    @Test
    public final void test_Constructor_10() {
        String jpqlQuery = "SELECT e, NEW(java.lang.String)";
        int position = "SELECT e, NEW".length();
        testHasTheseProposals(jpqlQuery, position, NEW);
    }

    @Test
    public final void test_Constructor_11() {
        String jpqlQuery = "SELECT new com.titan.domain.Name(c.firstName, c.lastName) FROM Customer c";
        int position = "SELECT new com.titan.domain.Name(c.".length();
        testHasTheseProposals(jpqlQuery, position, "firstName", "hasGoodCredit", "id", "lastName", "address", "home");
    }

    @Test
    public final void test_Constructor_12() {

        String jpqlQuery = "SELECT new com.titan.domain.Name(c.firstName, c.lastName) FROM Customer c";
        int position = "SELECT new com.titan.domain.Name(c.firstName, ".length();

        List<String> proposals = new ArrayList<>();
        proposals.add("c");
        CollectionTools.addAll(proposals, bnfAccessor.constructorItemFunctions());

        testHasOnlyTheseProposals(jpqlQuery, position, proposals);
    }

    @Test
    public final void test_Constructor_13() {

        String jpqlQuery = "SELECT new com.titan.domain.Name(c.firstName, c.lastName) FROM Customer c";
        int position = "SELECT new com.titan.domain.Name(c.firstName, c".length();

        List<String> proposals = new ArrayList<>();
        proposals.add("c");
        CollectionTools.addAll(proposals, filter(bnfAccessor.constructorItemFunctions(), "c"));

        testHasOnlyTheseProposals(jpqlQuery, position, proposals);
    }

    @Test
    public final void test_Constructor_15() {
        String jpqlQuery = "SELECT NE";
        int position = jpqlQuery.length();
        testHasOnlyTheseProposals(jpqlQuery, position, NEW);
    }

    @Test
    public final void test_Constructor_16() {
        String jpqlQuery = "SELECT e, NE";
        int position = jpqlQuery.length();
        testHasOnlyTheseProposals(jpqlQuery, position, NEW);
    }

    @Test
    public final void test_Constructor_17() {
        String jpqlQuery = "SELECT e, NEW";
        int position = jpqlQuery.length();
        testHasTheseProposals(jpqlQuery, position, NEW);
    }

    @Test
    public final void test_Constructor_18() {
        String jpqlQuery = "SELECT NE";
        int position = jpqlQuery.length();
        testHasTheseProposals(jpqlQuery, position, NEW);
    }

    @Test
    public final void test_Constructor_19() {
        String jpqlQuery = "SELECT NEW";
        int position = jpqlQuery.length();
        testHasTheseProposals(jpqlQuery, position, NEW);
    }

    @Test
    public final void test_Constructor_20() {
        String jpqlQuery = "SELECT e, NEW";
        int position = jpqlQuery.length();
        testHasOnlyTheseProposals(jpqlQuery, position, NEW);
    }

    @Test
    public final void test_Constructor_21() {
        String jpqlQuery = "SELECT e, NEW java.lang.String(e.name)";
        int position = "SELECT e, ".length();
        testHasTheseProposals(jpqlQuery, position, NEW);
    }

    @Test
    public final void test_Count_01() {
        String jpqlQuery = "SELECT ";
        int position = jpqlQuery.length();
        testHasTheseProposals(jpqlQuery, position, COUNT);
    }

    @Test
    public final void test_Count_02() {
        String jpqlQuery = "SELECT C";
        int position = jpqlQuery.length();
        testHasTheseProposals(jpqlQuery, position, COUNT);
    }

    @Test
    public final void test_Count_03() {
        String jpqlQuery = "SELECT CO";
        int position = jpqlQuery.length();
        testHasTheseProposals(jpqlQuery, position, COUNT);
    }

    @Test
    public final void test_Count_04() {
        String jpqlQuery = "SELECT COU";
        int position = jpqlQuery.length();
        testHasTheseProposals(jpqlQuery, position, COUNT);
    }

    @Test
    public final void test_Count_05() {
        String jpqlQuery = "SELECT COUN";
        int position = jpqlQuery.length();
        testHasTheseProposals(jpqlQuery, position, COUNT);
    }

    @Test
    public final void test_Count_06() {
        String jpqlQuery = "SELECT COUNT";
        int position = jpqlQuery.length();
        testHasTheseProposals(jpqlQuery, position, COUNT);
    }

    @Test
    public final void test_Count_07() {

        String jpqlQuery = "SELECT COUNT(";
        int position = jpqlQuery.length();

        List<String> proposals = new ArrayList<>();
        proposals.add(DISTINCT);
        CollectionTools.addAll(proposals, bnfAccessor.countFunctions());

        testHasOnlyTheseProposals(jpqlQuery, position, proposals);
    }

    @Test
    public final void test_Count_08() {

        String jpqlQuery = "SELECT COUNT() From Employee e";
        int position = "SELECT COUNT(".length();

        List<String> proposals = new ArrayList<>();
        proposals.add("e");
        proposals.add(DISTINCT);
        CollectionTools.addAll(proposals, bnfAccessor.countFunctions());

        testHasOnlyTheseProposals(jpqlQuery, position, proposals);
    }

    @Test
    public final void test_Count_09() {

        String jpqlQuery = "SELECT COUNT(DISTINCT ) From Employee e";
        int position = "SELECT COUNT(DISTINCT ".length();

        List<String> proposals = new ArrayList<>();
        proposals.add("e");
        CollectionTools.addAll(proposals, bnfAccessor.countFunctions());

        testHasOnlyTheseProposals(jpqlQuery, position, proposals);
    }

    @Test
    public final void test_Count_10() {
        String jpqlQuery = "SELECT COUNT(D ) From Employee e";
        int position = "SELECT COUNT(D".length();
        testHasOnlyTheseProposals(jpqlQuery, position, DISTINCT);
    }

    @Test
    public final void test_Count_11() {
        String jpqlQuery = "SELECT COUNT(DI ) From Employee e";
        int position = "SELECT COUNT(DI".length();
        testHasOnlyTheseProposals(jpqlQuery, position, DISTINCT);
    }

    @Test
    public final void test_Count_12() {
        String jpqlQuery = "SELECT COUNT(DIS ) From Employee e";
        int position = "SELECT COUNT(DIS".length();
        testHasOnlyTheseProposals(jpqlQuery, position, DISTINCT);
    }

    @Test
    public final void test_Count_13() {
        String jpqlQuery = "SELECT COUNT(DISTINCT e) From Employee e";
        int position = "SELECT COUNT(".length();
        testHasOnlyTheseProposals(jpqlQuery, position, DISTINCT);
    }

    @Test
    public final void test_Count_14() {
        String jpqlQuery = "SELECT COUNT(DISTINCT e) From Employee e";
        int position = "SELECT COUNT(D".length();
        testHasOnlyTheseProposals(jpqlQuery, position, DISTINCT);
    }

    @Test
    public final void test_Count_15() {
        String jpqlQuery = "SELECT COUNT(DISTINCT e) From Employee e";
        int position = "SELECT COUNT(DI".length();
        testHasOnlyTheseProposals(jpqlQuery, position, DISTINCT);
    }

    @Test
    public final void test_Count_16() {

        String jpqlQuery = "SELECT COUNT(DISTINCT e) From Employee e";
        int position = "SELECT COUNT(DISTINCT ".length();

        List<String> proposals = new ArrayList<>();
        proposals.add("e");
        CollectionTools.addAll(proposals, bnfAccessor.countFunctions());

        testHasOnlyTheseProposals(jpqlQuery, position, proposals);
    }

    @Test
    public final void test_Count_17() {

        String jpqlQuery = "SELECT COUNT(DISTINCT e) From Employee e";
        int position = "SELECT COUNT(DISTINCT e".length();

        List<String> proposals = new ArrayList<>();
        proposals.add("e");
        CollectionTools.addAll(proposals, filter(bnfAccessor.countFunctions(), "e"));

        testHasOnlyTheseProposals(jpqlQuery, position, proposals);
    }

    @Test
    public final void test_Count_18() {

        String jpqlQuery = "SELECT COUNT(DISTINCT e) From Employee emp";
        int position = "SELECT COUNT(DISTINCT e".length();

        List<String> proposals = new ArrayList<>();
        proposals.add("emp");
        CollectionTools.addAll(proposals, filter(bnfAccessor.countFunctions(), "e"));

        testHasOnlyTheseProposals(jpqlQuery, position, proposals);
    }

    @Test
    public final void test_Count_19() {
        String jpqlQuery = "SELECT COUNT() From Employee emp";
        int position = "SELECT COUNT(".length();

        List<String> proposals = new ArrayList<>();
        proposals.add("emp");
        proposals.add(DISTINCT);
        CollectionTools.addAll(proposals, bnfAccessor.countFunctions());

        testHasOnlyTheseProposals(jpqlQuery, position, proposals);
    }

    @Test
    public final void test_Count_20() {

        String jpqlQuery = "SELECT COUNT(e) From Employee emp";
        int position = "SELECT COUNT(e".length();

        List<String> proposals = new ArrayList<>();
        proposals.add("emp");
        CollectionTools.addAll(proposals, filter(bnfAccessor.countFunctions(), "e"));

        testHasOnlyTheseProposals(jpqlQuery, position, proposals);
    }

    @Test
    public final void test_Count_21() {

        String jpqlQuery = "SELECT COUNT(em) From Employee emp";
        int position = "SELECT COUNT(em".length();

        List<String> proposals = new ArrayList<>();
        proposals.add("emp");
        CollectionTools.addAll(proposals, filter(bnfAccessor.countFunctions(), "em"));

        testHasOnlyTheseProposals(jpqlQuery, position, proposals);
    }

    @Test
    public final void test_Count_22() {

        String jpqlQuery = "SELECT COUNT(emp) From Employee emp";
        int position = "SELECT COUNT(emp".length();

        List<String> proposals = new ArrayList<>();
        proposals.add("emp");
        CollectionTools.addAll(proposals, filter(bnfAccessor.countFunctions(), "emp"));

        testHasOnlyTheseProposals(jpqlQuery, position, proposals);
    }

    @Test
    public final void test_Count_23() {

        String jpqlQuery = "SELECT COUNT(emp) From Employee emp";
        int position = "SELECT COUNT(e".length();

        List<String> proposals = new ArrayList<>();
        proposals.add("emp");
        CollectionTools.addAll(proposals, filter(bnfAccessor.countFunctions(), "e"));

        testHasOnlyTheseProposals(jpqlQuery, position, proposals);
    }

    @Test
    public final void test_Count_24() {

        String jpqlQuery = "SELECT COUNT(emp) From Employee emp";
        int position = "SELECT COUNT(em".length();

        List<String> proposals = new ArrayList<>();
        proposals.add("emp");
        CollectionTools.addAll(proposals, filter(bnfAccessor.countFunctions(), "em"));

        testHasOnlyTheseProposals(jpqlQuery, position, proposals);
    }

    @Test
    public final void test_Count_25() {

        String jpqlQuery = "SELECT COUNT( From Employee emp";
        int position = "SELECT COUNT(".length();

        List<String> proposals = new ArrayList<>();
        proposals.add("emp");
        proposals.add(DISTINCT);
        CollectionTools.addAll(proposals, bnfAccessor.countFunctions());

        testHasOnlyTheseProposals(jpqlQuery, position, proposals);
    }

    @Test
    public final void test_Count_26() {

        String jpqlQuery = "SELECT COUNT(e From Employee emp";
        int position = "SELECT COUNT(e".length();

        List<String> proposals = new ArrayList<>();
        proposals.add("emp");
        CollectionTools.addAll(proposals, filter(bnfAccessor.countFunctions(), "e"));

        testHasOnlyTheseProposals(jpqlQuery, position, proposals);
    }

    @Test
    public final void test_DateTime_01() {
        String jpqlQuery = "SELECT e FROM Employee e WHERE ";
        int position = jpqlQuery.length();
        testHasTheseProposals(jpqlQuery, position, CURRENT_DATE, CURRENT_TIME, CURRENT_TIMESTAMP);
    }

    @Test
    public final void test_DateTime_02() {
        String jpqlQuery = "SELECT e FROM Employee e WHERE e.hiredTime < ";
        int position = jpqlQuery.length();
        testHasTheseProposals(jpqlQuery, position, CURRENT_DATE, CURRENT_TIME, CURRENT_TIMESTAMP);
    }

    @Test
    public final void test_DateTime_03() {
        String jpqlQuery = "SELECT e FROM Employee e WHERE C";
        int position = jpqlQuery.length();
        testHasTheseProposals(jpqlQuery, position, CURRENT_DATE, CURRENT_TIME, CURRENT_TIMESTAMP);
    }

    @Test
    public final void test_DateTime_04() {
        String jpqlQuery = "SELECT e FROM Employee e WHERE CU";
        int position = jpqlQuery.length();
        testHasTheseProposals(jpqlQuery, position, CURRENT_DATE, CURRENT_TIME, CURRENT_TIMESTAMP);
    }

    @Test
    public final void test_DateTime_05() {
        String jpqlQuery = "SELECT e FROM Employee e WHERE CUR";
        int position = jpqlQuery.length();
        testHasTheseProposals(jpqlQuery, position, CURRENT_DATE, CURRENT_TIME, CURRENT_TIMESTAMP);
    }

    @Test
    public final void test_DateTime_06() {
        String jpqlQuery = "SELECT e FROM Employee e WHERE CURR";
        int position = jpqlQuery.length();
        testHasTheseProposals(jpqlQuery, position, CURRENT_DATE, CURRENT_TIME, CURRENT_TIMESTAMP);
    }

    @Test
    public final void test_DateTime_07() {
        String jpqlQuery = "SELECT e FROM Employee e WHERE CURRE";
        int position = jpqlQuery.length();
        testHasTheseProposals(jpqlQuery, position, CURRENT_DATE, CURRENT_TIME, CURRENT_TIMESTAMP);
    }

    @Test
    public final void test_DateTime_08() {
        String jpqlQuery = "SELECT e FROM Employee e WHERE CURREN";
        int position = jpqlQuery.length();
        testHasTheseProposals(jpqlQuery, position, CURRENT_DATE, CURRENT_TIME, CURRENT_TIMESTAMP);
    }

    @Test
    public final void test_DateTime_09() {
        String jpqlQuery = "SELECT e FROM Employee e WHERE CURRENT";
        int position = jpqlQuery.length();
        testHasTheseProposals(jpqlQuery, position, CURRENT_DATE, CURRENT_TIME, CURRENT_TIMESTAMP);
    }

    @Test
    public final void test_DateTime_10() {
        String jpqlQuery = "SELECT e FROM Employee e WHERE CURRENT_";
        int position = jpqlQuery.length();
        testHasTheseProposals(jpqlQuery, position, CURRENT_DATE, CURRENT_TIME, CURRENT_TIMESTAMP);
    }

    @Test
    public final void test_DateTime_11() {
        String jpqlQuery = "SELECT e FROM Employee e WHERE CURRENT_D";
        int position = jpqlQuery.length();
        testHasOnlyTheseProposals(jpqlQuery, position, CURRENT_DATE);
    }

    @Test
    public final void test_DateTime_12() {
        String jpqlQuery = "SELECT e FROM Employee e WHERE CURRENT_DA";
        int position = jpqlQuery.length();
        testHasOnlyTheseProposals(jpqlQuery, position, CURRENT_DATE);
    }

    @Test
    public final void test_DateTime_13() {
        String jpqlQuery = "SELECT e FROM Employee e WHERE CURRENT_DAT";
        int position = jpqlQuery.length();
        testHasOnlyTheseProposals(jpqlQuery, position, CURRENT_DATE);
    }

    @Test
    public final void test_DateTime_14() {
        String jpqlQuery = "SELECT e FROM Employee e WHERE CURRENT_DATE";
        int position = jpqlQuery.length();
        testHasOnlyTheseProposals(jpqlQuery, position, CURRENT_DATE, CURRENT_TIME, CURRENT_TIMESTAMP);
    }

    @Test
    public final void test_DateTime_15() {
        String jpqlQuery = "SELECT e FROM Employee e WHERE CURRENT_T";
        int position = jpqlQuery.length();
        testHasOnlyTheseProposals(jpqlQuery, position, CURRENT_TIME, CURRENT_TIMESTAMP);
    }

    @Test
    public final void test_DateTime_16() {
        String jpqlQuery = "SELECT e FROM Employee e WHERE CURRENT_TI";
        int position = jpqlQuery.length();
        testHasOnlyTheseProposals(jpqlQuery, position, CURRENT_TIME, CURRENT_TIMESTAMP);
    }

    @Test
    public final void test_DateTime_17() {
        String jpqlQuery = "SELECT e FROM Employee e WHERE CURRENT_TIM";
        int position = jpqlQuery.length();
        testHasOnlyTheseProposals(jpqlQuery, position, CURRENT_TIME, CURRENT_TIMESTAMP);
    }

    @Test
    public final void test_DateTime_18() {
        String jpqlQuery = "SELECT e FROM Employee e WHERE CURRENT_TIME";
        int position = jpqlQuery.length();
        testHasOnlyTheseProposals(jpqlQuery, position, CURRENT_DATE, CURRENT_TIME, CURRENT_TIMESTAMP);
    }

    @Test
    public final void test_DateTime_19() {
        String jpqlQuery = "SELECT e FROM Employee e WHERE CURRENT_TIMES";
        int position = jpqlQuery.length();
        testHasOnlyTheseProposals(jpqlQuery, position, CURRENT_TIMESTAMP);
    }

    @Test
    public final void test_DateTime_20() {
        String jpqlQuery = "SELECT e FROM Employee e WHERE CURRENT_TIMEST";
        int position = jpqlQuery.length();
        testHasOnlyTheseProposals(jpqlQuery, position, CURRENT_TIMESTAMP);
    }

    @Test
    public final void test_DateTime_21() {
        String jpqlQuery = "SELECT e FROM Employee e WHERE CURRENT_TIMESTA";
        int position = jpqlQuery.length();
        testHasOnlyTheseProposals(jpqlQuery, position, CURRENT_TIMESTAMP);
    }

    @Test
    public final void test_DateTime_22() {
        String jpqlQuery = "SELECT e FROM Employee e WHERE CURRENT_TIMESTAM";
        int position = jpqlQuery.length();
        testHasOnlyTheseProposals(jpqlQuery, position, CURRENT_TIMESTAMP);
    }

    @Test
    public final void test_DateTime_23() {
        String jpqlQuery = "SELECT e FROM Employee e WHERE CURRENT_TIMESTAMP";
        int position = jpqlQuery.length();
        testHasOnlyTheseProposals(jpqlQuery, position, CURRENT_DATE, CURRENT_TIME, CURRENT_TIMESTAMP);
    }

    @Test
    public final void test_Delete_01() {
        String jpqlQuery = "D";
        int position = jpqlQuery.length();
        testHasOnlyTheseProposals(jpqlQuery, position, DELETE_FROM);
    }

    @Test
    public final void test_Delete_02() {
        String jpqlQuery = "DE";
        int position = jpqlQuery.length();
        testHasOnlyTheseProposals(jpqlQuery, position, DELETE_FROM);
    }

    @Test
    public final void test_Delete_03() {
        String jpqlQuery = "DEL";
        int position = jpqlQuery.length();
        testHasOnlyTheseProposals(jpqlQuery, position, DELETE_FROM);
    }

    @Test
    public final void test_Delete_04() {
        String jpqlQuery = "DELE";
        int position = jpqlQuery.length();
        testHasOnlyTheseProposals(jpqlQuery, position, DELETE_FROM);
    }

    @Test
    public final void test_Delete_05() {
        String jpqlQuery = "DELET";
        int position = jpqlQuery.length();
        testHasOnlyTheseProposals(jpqlQuery, position, DELETE_FROM);
    }

    @Test
    public final void test_Delete_06() {
        String jpqlQuery = "DELETE";
        int position = jpqlQuery.length();
        testHasOnlyTheseProposals(jpqlQuery, position, DELETE_FROM);
    }

    @Test
    public final void test_Delete_07() {
        String jpqlQuery = "DELETE ";
        int position = jpqlQuery.length();
        testHasOnlyTheseProposals(jpqlQuery, position, DELETE_FROM);
    }

    @Test
    public final void test_Delete_08() {
        String jpqlQuery = "DELETE F";
        int position = jpqlQuery.length();
        testHasOnlyTheseProposals(jpqlQuery, position, DELETE_FROM);
    }

    @Test
    public final void test_Delete_09() {
        String jpqlQuery = "DELETE FR";
        int position = jpqlQuery.length();
        testHasOnlyTheseProposals(jpqlQuery, position, DELETE_FROM);
    }

    @Test
    public final void test_Delete_10() {
        String jpqlQuery = "DELETE FRO";
        int position = jpqlQuery.length();
        testHasOnlyTheseProposals(jpqlQuery, position, DELETE_FROM);
    }

    @Test
    public final void test_Delete_11() {
        String jpqlQuery = "DELETE FROM";
        int position = jpqlQuery.length();
        testHasOnlyTheseProposals(jpqlQuery, position, DELETE_FROM);
    }

    @Test
    public final void test_Delete_12() {
        String jpqlQuery = "DELETE FROM Employee";
        int position = "D".length();
        testHasOnlyTheseProposals(jpqlQuery, position, DELETE_FROM);
    }

    @Test
    public final void test_Delete_13() {
        String jpqlQuery = "DELETE FROM Employee";
        int position = "DE".length();
        testHasOnlyTheseProposals(jpqlQuery, position, DELETE_FROM);
    }

    @Test
    public final void test_Delete_14() {
        String jpqlQuery = "DELETE FROM Employee";
        int position = "DEL".length();
        testHasOnlyTheseProposals(jpqlQuery, position, DELETE_FROM);
    }

    @Test
    public final void test_Delete_15() {
        String jpqlQuery = "DELETE FROM Employee";
        int position = "DELE".length();
        testHasOnlyTheseProposals(jpqlQuery, position, DELETE_FROM);
    }

    @Test
    public final void test_Delete_16() {
        String jpqlQuery = "DELETE FROM Employee";
        int position = "DELET".length();
        testHasOnlyTheseProposals(jpqlQuery, position, DELETE_FROM);
    }

    @Test
    public final void test_Delete_17() {
        String jpqlQuery = "DELETE FROM Employee";
        int position = "DELETE".length();
        testHasOnlyTheseProposals(jpqlQuery, position, DELETE_FROM);
    }

    @Test
    public final void test_Delete_18() {
        String jpqlQuery = "DELETE FROM Employee";
        int position = "DELETE ".length();
        testHasOnlyTheseProposals(jpqlQuery, position, DELETE_FROM);
    }

    @Test
    public final void test_Delete_19() {
        String jpqlQuery = "DELETE FROM Employee";
        int position = "DELETE F".length();
        testHasOnlyTheseProposals(jpqlQuery, position, DELETE_FROM);
    }

    @Test
    public final void test_Delete_20() {
        String jpqlQuery = "DELETE FROM Employee";
        int position = "DELETE FR".length();
        testHasOnlyTheseProposals(jpqlQuery, position, DELETE_FROM);
    }

    @Test
    public final void test_Delete_21() {
        String jpqlQuery = "DELETE FROM Employee";
        int position = "DELETE FRO".length();
        testHasOnlyTheseProposals(jpqlQuery, position, DELETE_FROM);
    }

    @Test
    public final void test_Delete_22() {
        String jpqlQuery = "DELETE FROM Employee";
        int position = "DELETE FROM".length();
        testHasOnlyTheseProposals(jpqlQuery, position, DELETE_FROM);
    }

    @Test
    public final void test_Delete_23() {
        String jpqlQuery = "DELETE FROM Employee e WHERE";
        int position = jpqlQuery.length();
        testDoesNotHaveTheseProposals(jpqlQuery, position, DELETE_FROM);
    }

    @Test
    public final void test_Delete_24() {
        String jpqlQuery = "DELETE FROM WHERE";
        int position = jpqlQuery.length();
        testDoesNotHaveTheseProposals(jpqlQuery, position, DELETE_FROM);
    }

    @Test
    public final void test_Delete_25() throws Exception {
        String jpqlQuery = "DELETE FROM ";
        int position = jpqlQuery.length();
        testHasOnlyTheseProposals(jpqlQuery, position, entityNames());
    }

    @Test
    public final void test_Delete_26() throws Exception {
        String jpqlQuery = "DELETE FROM P";
        int position = jpqlQuery.length();
        testHasOnlyTheseProposals(jpqlQuery, position, filter(entityNames(), "P"));
    }

    @Test
    public final void test_Delete_27() {
        String jpqlQuery = "DELETE FROM Employee WHERE n";
        int position = "DELETE FROM Employee ".length();
        testHasOnlyTheseProposals(jpqlQuery, position, AS);
    }

    @Test
    public final void test_Delete_28() {
        String jpqlQuery = "DELETE FROM Employee A WHERE";
        int position = jpqlQuery.length() - " WHERE".length();
        testHasOnlyTheseProposals(jpqlQuery, position, AS);
    }

    @Test
    public final void test_Delete_29() {
        String jpqlQuery = "DELETE FROM Employee A ";
        int position = jpqlQuery.length() - 1;
        testHasOnlyTheseProposals(jpqlQuery, position, AS);
    }

    @Test
    public final void test_Delete_30() {
        String jpqlQuery = "DELETE FROM Employee AS e ";
        int position = jpqlQuery.length();
        testHasOnlyTheseProposals(jpqlQuery, position, WHERE);
    }

    @Test
    public final void test_Delete_31() {
        String jpqlQuery = "DELETE FROM Employee AS e W";
        int position = jpqlQuery.length();
        testHasOnlyTheseProposals(jpqlQuery, position, WHERE);
    }

    @Test
    public final void test_Delete_32() {
        String jpqlQuery = "DELETE FROM Employee AS e WH";
        int position = jpqlQuery.length();
        testHasOnlyTheseProposals(jpqlQuery, position, WHERE);
    }

    @Test
    public final void test_Delete_33() {
        String jpqlQuery = "DELETE FROM Employee AS e WHE";
        int position = jpqlQuery.length();
        testHasOnlyTheseProposals(jpqlQuery, position, WHERE);
    }

    @Test
    public final void test_Delete_34() {
        String jpqlQuery = "DELETE FROM Employee AS e WHER";
        int position = jpqlQuery.length();
        testHasOnlyTheseProposals(jpqlQuery, position, WHERE);
    }

    @Test
    public final void test_Delete_35() {
        String jpqlQuery = "DELETE FROM Employee AS e WHERE";
        int position = jpqlQuery.length();
        testHasTheseProposals(jpqlQuery, position, WHERE);
    }

    @Test
    public final void test_EmptyCollectionComparison_01() {
        String jpqlQuery = "SELECT e FROM Employee e WHERE ";
        int position = jpqlQuery.length();
        testDoesNotHaveTheseProposals(jpqlQuery, position, IS_EMPTY, IS_NOT_EMPTY);
    }

    @Test
    public final void test_EmptyCollectionComparison_02() {
        String jpqlQuery = "SELECT e FROM Employee e WHERE e.phoneNumbers ";
        int position = jpqlQuery.length();
        testHasTheseProposals(jpqlQuery, position, IS_EMPTY, IS_NOT_EMPTY);
    }

    @Test
    public final void test_EmptyCollectionComparison_03() {
        String jpqlQuery = "SELECT e FROM Employee e WHERE e.phoneNumbers I";
        int position = jpqlQuery.length();
        testHasTheseProposals(jpqlQuery, position, IS_EMPTY, IS_NOT_EMPTY);
    }

    @Test
    public final void test_EmptyCollectionComparison_04() {
        String jpqlQuery = "SELECT e FROM Employee e WHERE e.phoneNumbers IS";
        int position = jpqlQuery.length();
        testHasTheseProposals(jpqlQuery, position, IS_EMPTY, IS_NOT_EMPTY);
    }

    @Test
    public final void test_EmptyCollectionComparison_05() {
        String jpqlQuery = "SELECT e FROM Employee e WHERE e.phoneNumbers IS N";
        int position = jpqlQuery.length();
        testHasOnlyTheseProposals(jpqlQuery, position, IS_NULL, IS_NOT_NULL, IS_NOT_EMPTY);
    }

    @Test
    public final void test_EmptyCollectionComparison_06() {
        String jpqlQuery = "SELECT e FROM Employee e WHERE e.phoneNumbers IS NO";
        int position = jpqlQuery.length();
        testHasOnlyTheseProposals(jpqlQuery, position, IS_NOT_NULL, IS_NOT_EMPTY);
    }

    @Test
    public final void test_EmptyCollectionComparison_07() {
        String jpqlQuery = "SELECT e FROM Employee e WHERE e.phoneNumbers IS NOT";
        int position = jpqlQuery.length();
        testHasOnlyTheseProposals(jpqlQuery, position, IS_NOT_EMPTY, IS_NOT_NULL);
    }

    @Test
    public final void test_EmptyCollectionComparison_08() {
        String jpqlQuery = "SELECT e FROM Employee e WHERE e.phoneNumbers IS NOT ";
        int position = jpqlQuery.length();
        testHasOnlyTheseProposals(jpqlQuery, position, IS_NOT_EMPTY, IS_NOT_NULL);
    }

    @Test
    public final void test_EmptyCollectionComparison_09() {
        String jpqlQuery = "SELECT e FROM Employee e WHERE e.phoneNumbers IS NOT E";
        int position = jpqlQuery.length();
        testHasOnlyTheseProposals(jpqlQuery, position, IS_NOT_EMPTY);
    }

    @Test
    public final void test_EmptyCollectionComparison_10() {
        String jpqlQuery = "SELECT e FROM Employee e WHERE e.phoneNumbers IS NOT EM";
        int position = jpqlQuery.length();
        testHasOnlyTheseProposals(jpqlQuery, position, IS_NOT_EMPTY);
    }

    @Test
    public final void test_EmptyCollectionComparison_11() {
        String jpqlQuery = "SELECT e FROM Employee e WHERE e.phoneNumbers IS NOT EMP";
        int position = jpqlQuery.length();
        testHasOnlyTheseProposals(jpqlQuery, position, IS_NOT_EMPTY);
    }

    @Test
    public final void test_EmptyCollectionComparison_12() {
        String jpqlQuery = "SELECT e FROM Employee e WHERE e.phoneNumbers IS NOT EMPT";
        int position = jpqlQuery.length();
        testHasOnlyTheseProposals(jpqlQuery, position, IS_NOT_EMPTY);
    }

    @Test
    public final void test_EmptyCollectionComparison_13() {
        String jpqlQuery = "SELECT e FROM Employee e WHERE e.phoneNumbers IS NOT EMPTY";
        int position = jpqlQuery.length();
        testHasOnlyTheseProposals(jpqlQuery, position, IS_EMPTY, IS_NOT_EMPTY);
    }

    @Test
    public final void test_EmptyCollectionComparison_14() {
        String jpqlQuery = "SELECT e FROM Employee e WHERE e.phoneNumbers IS E";
        int position = jpqlQuery.length();
        testHasOnlyTheseProposals(jpqlQuery, position, IS_EMPTY);
    }

    @Test
    public final void test_EmptyCollectionComparison_15() {
        String jpqlQuery = "SELECT e FROM Employee e WHERE e.phoneNumbers IS EM";
        int position = jpqlQuery.length();
        testHasOnlyTheseProposals(jpqlQuery, position, IS_EMPTY);
    }

    @Test
    public final void test_EmptyCollectionComparison_16() {
        String jpqlQuery = "SELECT e FROM Employee e WHERE e.phoneNumbers IS EMP";
        int position = jpqlQuery.length();
        testHasOnlyTheseProposals(jpqlQuery, position, IS_EMPTY);
    }

    @Test
    public final void test_EmptyCollectionComparison_17() {
        String jpqlQuery = "SELECT e FROM Employee e WHERE e.phoneNumbers IS EMPT";
        int position = jpqlQuery.length();
        testHasOnlyTheseProposals(jpqlQuery, position, IS_EMPTY);
    }

    @Test
    public final void test_EmptyCollectionComparison_18() {
        String jpqlQuery = "SELECT e FROM Employee e WHERE e.phoneNumbers IS EMPTY";
        int position = jpqlQuery.length();
        testHasOnlyTheseProposals(jpqlQuery, position, IS_EMPTY, IS_NOT_EMPTY);
    }

    @Test
    public final void test_EmptyCollectionComparison_19() {
        String jpqlQuery = "SELECT e FROM Employee e WHERE ";
        int position = jpqlQuery.length();
        testDoesNotHaveTheseProposals(jpqlQuery, position, IS_EMPTY, IS_NOT_EMPTY);
    }

    @Test
    public final void test_EmptyCollectionComparison_20() {
        String jpqlQuery = "SELECT e FROM Employee e WHERE e.name ";
        int position = jpqlQuery.length();
        testDoesNotHaveTheseProposals(jpqlQuery, position, IS_EMPTY, IS_NOT_EMPTY);
    }

    @Test
    public final void test_EmptyCollectionComparison_21() {
        String jpqlQuery = "SELECT e FROM Employee e WHERE e.name I";
        int position = jpqlQuery.length();
        testDoesNotHaveTheseProposals(jpqlQuery, position, IS_EMPTY, IS_NOT_EMPTY);
    }

    @Test
    public final void test_EmptyCollectionComparison_22() {
        String jpqlQuery = "SELECT e FROM Employee e WHERE e.name IS";
        int position = jpqlQuery.length();
        testDoesNotHaveTheseProposals(jpqlQuery, position, IS_EMPTY, IS_NOT_EMPTY);
    }

    @Test
    public final void test_EmptyCollectionComparison_23() {
        String jpqlQuery = "SELECT e FROM Employee e WHERE e.name IS N";
        int position = jpqlQuery.length();
        testDoesNotHaveTheseProposals(jpqlQuery, position, IS_NOT_EMPTY);
    }

    @Test
    public final void test_EmptyCollectionComparison_24() {
        String jpqlQuery = "SELECT e FROM Employee e WHERE e.name IS NO";
        int position = jpqlQuery.length();
        testDoesNotHaveTheseProposals(jpqlQuery, position, IS_NOT_EMPTY);
    }

    @Test
    public final void test_EmptyCollectionComparison_25() {
        String jpqlQuery = "SELECT e FROM Employee e WHERE e.name IS NOT";
        int position = jpqlQuery.length();
        testDoesNotHaveTheseProposals(jpqlQuery, position, IS_NOT_EMPTY);
    }

    @Test
    public final void test_EmptyCollectionComparison_26() {
        String jpqlQuery = "SELECT e FROM Employee e WHERE e.name IS NOT ";
        int position = jpqlQuery.length();
        testDoesNotHaveTheseProposals(jpqlQuery, position, IS_NOT_EMPTY);
    }

    @Test
    public final void test_EmptyCollectionComparison_27() {
        String jpqlQuery = "SELECT e FROM Employee e WHERE e.name IS NOT E";
        int position = jpqlQuery.length();
        testDoesNotHaveTheseProposals(jpqlQuery, position, IS_NOT_EMPTY);
    }

    @Test
    public final void test_EmptyCollectionComparison_28() {
        String jpqlQuery = "SELECT e FROM Employee e WHERE e.name IS NOT EM";
        int position = jpqlQuery.length();
        testDoesNotHaveTheseProposals(jpqlQuery, position, IS_NOT_EMPTY);
    }

    @Test
    public final void test_EmptyCollectionComparison_29() {
        String jpqlQuery = "SELECT e FROM Employee e WHERE e.name IS NOT EMP";
        int position = jpqlQuery.length();
        testDoesNotHaveTheseProposals(jpqlQuery, position, IS_NOT_EMPTY);
    }

    @Test
    public final void test_EmptyCollectionComparison_30() {
        String jpqlQuery = "SELECT e FROM Employee e WHERE e.name IS NOT EMPT";
        int position = jpqlQuery.length();
        testDoesNotHaveTheseProposals(jpqlQuery, position, IS_NOT_EMPTY);
    }

    @Test
    public final void test_EmptyCollectionComparison_31() {
        String jpqlQuery = "SELECT e FROM Employee e WHERE e.name IS NOT EMPTY";
        int position = jpqlQuery.length();
        testHasOnlyTheseProposals(jpqlQuery, position, IS_EMPTY, IS_NOT_EMPTY);
    }

    @Test
    public final void test_EmptyCollectionComparison_32() {
        String jpqlQuery = "SELECT e FROM Employee e WHERE e.name IS E";
        int position = jpqlQuery.length();
        testDoesNotHaveTheseProposals(jpqlQuery, position, IS_EMPTY);
    }

    @Test
    public final void test_EmptyCollectionComparison_33() {
        String jpqlQuery = "SELECT e FROM Employee e WHERE e.name IS EM";
        int position = jpqlQuery.length();
        testDoesNotHaveTheseProposals(jpqlQuery, position, IS_EMPTY);
    }

    @Test
    public final void test_EmptyCollectionComparison_34() {
        String jpqlQuery = "SELECT e FROM Employee e WHERE e.name IS EMP";
        int position = jpqlQuery.length();
        testDoesNotHaveTheseProposals(jpqlQuery, position, IS_EMPTY);
    }

    @Test
    public final void test_EmptyCollectionComparison_35() {
        String jpqlQuery = "SELECT e FROM Employee e WHERE e.name IS EMPT";
        int position = jpqlQuery.length();
        testDoesNotHaveTheseProposals(jpqlQuery, position, IS_EMPTY);
    }

    @Test
    public final void test_EmptyCollectionComparison_36() {
        String jpqlQuery = "SELECT e FROM Employee e WHERE e.name IS EMPTY";
        int position = jpqlQuery.length();
        testHasOnlyTheseProposals(jpqlQuery, position, IS_EMPTY, IS_NOT_EMPTY);
    }

    @Test
    public final void test_From_01() {
        String jpqlQuery = "SELECT ";
        int position = jpqlQuery.length();
        testDoesNotHaveTheseProposals(jpqlQuery, position, FROM);
    }

    @Test
    public final void test_From_02() {
        String jpqlQuery = "SELECT F";
        int position = jpqlQuery.length();
        testDoesNotHaveTheseProposals(jpqlQuery, position, FROM);
    }

    @Test
    public final void test_From_03() {
        String jpqlQuery = "SELECT AVG(e.roomNumber)";
        int position = jpqlQuery.length();
        testHasTheseProposals(jpqlQuery, position, FROM);
    }

    @Test
    public final void test_From_04() {
        String jpqlQuery = "SELECT AVG(e.roomNumber) ";
        int position = jpqlQuery.length();
        testHasTheseProposals(jpqlQuery, position, FROM);
    }

    @Test
    public final void test_From_05() {
        String jpqlQuery = "SELECT AVG(e.roomNumber) F";
        int position = jpqlQuery.length();
        testHasOnlyTheseProposals(jpqlQuery, position, FROM);
    }

    @Test
    public final void test_From_06() {
        String jpqlQuery = "SELECT f ";
        int position = jpqlQuery.length();
        testHasTheseProposals(jpqlQuery, position, FROM);
    }

    @Test
    public final void test_From_07() {
        String jpqlQuery = "SELECT a, ";
        int position = jpqlQuery.length();
        testDoesNotHaveTheseProposals(jpqlQuery, position, FROM);
    }

    @Test
    public final void test_From_08() {
        String jpqlQuery = "SELECT AVG( ";
        int position = jpqlQuery.length();
        testDoesNotHaveTheseProposals(jpqlQuery, position, FROM);
    }

    @Test
    public final void test_From_09() {
        String jpqlQuery = "SELECT AVG(a ";
        int position = jpqlQuery.length();
        testDoesNotHaveTheseProposals(jpqlQuery, position, FROM);
    }

    @Test
    public final void test_From_10() {
        String jpqlQuery = "SELECT AVG(e.roomNumber ";
        int position = jpqlQuery.length();
        testDoesNotHaveTheseProposals(jpqlQuery, position, FROM);
    }

    @Test
    public final void test_From_11() {
        String jpqlQuery = "SELECT F F";
        int position = "SELECT F".length();
        testDoesNotHaveTheseProposals(jpqlQuery, position, FROM);
    }

    @Test
    public final void test_From_12() {

        String jpqlQuery = "SELECT e FROM Address a," +
                           "              Employee emp JOIN emp.customers emp_c, " +
                           "              Address ea " +
                           "WHERE ALL(SELECT a e";

        int position = jpqlQuery.length();
        testHasNoProposals(jpqlQuery, position);
    }

    @Test
    public final void test_From_13() {
        String jpqlQuery = "SELECT e F";
        int position = jpqlQuery.length();
        testHasOnlyTheseProposals(jpqlQuery, position, FROM);
    }

    @Test
    public final void test_From_14() {
        String jpqlQuery = "SELECT e F, E";
        int position = "SELECT e F".length();
        testDoesNotHaveTheseProposals(jpqlQuery, position, FROM);
    }

    @Test
    public final void test_From_15() {

        String jpqlQuery = "SELECT e FROM Address a," +
                           "              Employee emp JOIN emp.customers emp_c, " +
                           "              Address ea " +
                           "WHERE ALL(SELECT a w";

        int position = jpqlQuery.length();
        testHasNoProposals(jpqlQuery, position);
    }

    @Test
    public final void test_FromAs_01() {
        String jpqlQuery = "SELECT o FROM Countries ";
        int position = jpqlQuery.length();
        testHasOnlyTheseProposals(jpqlQuery, position, AS);
    }

    @Test
    public final void test_FromAs_02() {
        String jpqlQuery = "SELECT o FROM Countries A";
        int position = "SELECT o FROM Countries ".length();
        testHasOnlyTheseProposals(jpqlQuery, position, AS);
    }

    @Test
    public final void test_FromAs_03() {
        String jpqlQuery = "SELECT e FROM Employee AS";
        int position = jpqlQuery.length();
        testHasOnlyTheseProposals(jpqlQuery, position, AS);
    }

    @Test
    public final void test_FromAs_04() {
        String jpqlQuery = "SELECT o FROM Countries j";
        int position = jpqlQuery.length();
        testHasNoProposals(jpqlQuery, position);
    }

    @Test
    public final void test_FromAs_05() {
        String jpqlQuery = "SELECT e FROM Employee AS e";
        int position = "SELECT e FROM Employee ".length();
        testHasOnlyTheseProposals(jpqlQuery, position, AS);
    }

    @Test
    public final void test_FromAs_06() {
        String jpqlQuery = "SELECT o FROM Countries o ";
        int position = jpqlQuery.length();
        testDoesNotHaveTheseProposals(jpqlQuery, position, AS);
    }

    @Test
    public final void test_FromAs_07() {
        String jpqlQuery = "SELECT e FROM Employee AS e";
        int position = "SELECT e FROM Employee A".length();
        testHasOnlyTheseProposals(jpqlQuery, position, AS);
    }

    @Test
    public final void test_FromAs_08() {
        String jpqlQuery = "SELECT o FROM Countries A o";
        int position = "SELECT o FROM Countries A".length();
        testHasOnlyTheseProposals(jpqlQuery, position, AS);
    }

    @Test
    public final void test_FromAs_09() {
        String jpqlQuery = "SELECT e FROM Employee AS e";
        int position = "SELECT e FROM Employee AS".length();
        testHasOnlyTheseProposals(jpqlQuery, position, AS);
    }

    @Test
    public final void test_FromAs_10() {
        String jpqlQuery = "SELECT o FROM Countries AS o";
        int position = "SELECT o FROM Countries AS ".length();
        testHasNoProposals(jpqlQuery, position);
    }

    @Test
    public final void test_FromAs_11() {
        // To test GROUP BY is not added
        String jpqlQuery = "SELECT o FROM Countries g";
        int position = jpqlQuery.length();
        testHasNoProposals(jpqlQuery, position);
    }

    @Test
    public final void test_FromAs_12() {
        // To test HAVING is not added
        String jpqlQuery = "SELECT o FROM Countries h";
        int position = jpqlQuery.length();
        testHasNoProposals(jpqlQuery, position);
    }

    @Test
    public final void test_FromAs_13() {
        // To test ORDER BY is not added
        String jpqlQuery = "SELECT o FROM Countries o";
        int position = jpqlQuery.length();
        testHasNoProposals(jpqlQuery, position);
    }

    @Test
    public final void test_FromAs_14() {
        // To test GROUP BY/ORDER BY are not added
        String jpqlQuery = "SELECT o FROM Countries b";
        int position = jpqlQuery.length();
        testHasNoProposals(jpqlQuery, position);
    }

    @Test
    public final void test_FromAs_15() {
        // To test UNION is not added (specific to EclipseLink 2.4 or later)
        String jpqlQuery = "SELECT o FROM Countries u";
        int position = jpqlQuery.length();
        testHasNoProposals(jpqlQuery, position);
    }

    @Test
    public final void test_FromAs_16() {
        // To test START WITH is not added (specific to EclipseLink 2.5 or later)
        String jpqlQuery = "SELECT o FROM Countries s";
        int position = jpqlQuery.length();
        testHasNoProposals(jpqlQuery, position);
    }

    @Test
    public final void test_FromAs_17() {
        // To test AS OF is not added (specific to EclipseLink 2.5 or later)
        String jpqlQuery = "SELECT o FROM Countries AS o";
        int position = jpqlQuery.length();
        testHasNoProposals(jpqlQuery, position);
    }

    @Test
    public final void test_FromClause_01() throws Exception {

        String jpqlQuery = "SELECT e FROM Employee e";
        int position = "SELECT e FROM ".length();

        List<String> proposals = new ArrayList<>();
        CollectionTools.addAll(proposals, entityNames());
        CollectionTools.addAll(proposals, classNames());
        CollectionTools.addAll(proposals, bnfAccessor.internalFromClauseIdentifiers());

        // Not supported for the first "root" object
        proposals.remove(IN);
        proposals.remove(TABLE);

        testHasOnlyTheseProposals(jpqlQuery, position, proposals);
    }

    @Test
    public final void test_FromClause_02() throws Exception {

        String jpqlQuery = "SELECT i FROM Investment i";
        int position = "SELECT i FROM I".length();

        List<String> proposals = new ArrayList<>();
        CollectionTools.addAll(proposals, filter(entityNames(), "I"));
        CollectionTools.addAll(proposals, filter(classNames(), "I"));
        CollectionTools.addAll(proposals, filter(bnfAccessor.internalFromClauseIdentifiers(), "I"));

        // Not supported for the first "root" object
        proposals.remove(IN);
        proposals.remove(TABLE);

        testHasOnlyTheseProposals(jpqlQuery, position, proposals);
    }

    @Test
    public final void test_FromClause_03() throws Exception {

        String jpqlQuery = "SELECT t FROM Tax t";
        int position = "SELECT t FROM T".length();

        List<String> proposals = new ArrayList<>();
        CollectionTools.addAll(proposals, filter(entityNames(), "T"));
        CollectionTools.addAll(proposals, filter(classNames(), "T"));
        CollectionTools.addAll(proposals, filter(bnfAccessor.internalFromClauseIdentifiers(), "T"));

        // Not supported for the first "root" object
        proposals.remove(IN);
        proposals.remove(TABLE);

        testHasOnlyTheseProposals(jpqlQuery, position, proposals);
    }

    @Test
    public final void test_FromClause_04() throws Exception {

        String jpqlQuery = "SELECT AVG(e.roomNumber) FROM ";
        int position = jpqlQuery.length();

        List<String> proposals = new ArrayList<>();
        CollectionTools.addAll(proposals, entityNames());
        CollectionTools.addAll(proposals, classNames());
        CollectionTools.addAll(proposals, bnfAccessor.internalFromClauseIdentifiers());

        // Not supported for the first "root" object
        proposals.remove(IN);
        proposals.remove(TABLE);

        testHasOnlyTheseProposals(jpqlQuery, position, proposals);
    }

    @Test
    public final void test_FromClause_05() throws Exception {

        String jpqlQuery = "SELECT e FROM ";
        int position = jpqlQuery.length();

        List<String> proposals = new ArrayList<>();
        CollectionTools.addAll(proposals, entityNames());
        CollectionTools.addAll(proposals, classNames());
        CollectionTools.addAll(proposals, bnfAccessor.internalFromClauseIdentifiers());

        // Not supported for the first "root" object
        proposals.remove(IN);
        proposals.remove(TABLE);

        testHasOnlyTheseProposals(jpqlQuery, position, proposals);
    }

    @Test
    public final void test_FromClause_06() throws Exception {

        String jpqlQuery = "SELECT e FROM E";
        int position = jpqlQuery.length();

        List<String> proposals = new ArrayList<>();
        CollectionTools.addAll(proposals, filter(entityNames(), "E"));
        CollectionTools.addAll(proposals, filter(classNames(), "E"));
        CollectionTools.addAll(proposals, filter(bnfAccessor.internalFromClauseIdentifiers(), "E"));

        // Not supported for the first "root" object
        proposals.remove(IN);
        proposals.remove(TABLE);

        testHasOnlyTheseProposals(jpqlQuery, position, proposals);
    }

    @Test
    public final void test_FromClause_07() throws Exception {

        String jpqlQuery = "SELECT e FROM Employee e, ";
        int position = jpqlQuery.length();

        List<String> proposals = new ArrayList<>();
        CollectionTools.addAll(proposals, entityNames());
        CollectionTools.addAll(proposals, classNames());
        CollectionTools.addAll(proposals, bnfAccessor.internalFromClauseIdentifiers());

        testHasOnlyTheseProposals(jpqlQuery, position, proposals);
    }

    @Test
    public final void test_FromClause_08() throws Exception {

        String jpqlQuery = "SELECT e FROM Employee e, Address a";
        int position = "SELECT e FROM ".length();

        List<String> proposals = new ArrayList<>();
        CollectionTools.addAll(proposals, entityNames());
        CollectionTools.addAll(proposals, classNames());
        CollectionTools.addAll(proposals, bnfAccessor.internalFromClauseIdentifiers());

        // Not supported for the first "root" object
        proposals.remove(IN);
        proposals.remove(TABLE);

        testHasOnlyTheseProposals(jpqlQuery, position, proposals);
    }

    @Test
    public final void test_FromClause_09() throws Exception {

        String jpqlQuery = "SELECT e FROM Employee e ";
        int position = jpqlQuery.length();

        List<String> proposals = new ArrayList<>();
        CollectionTools.addAll(proposals, entityNames());
        CollectionTools.addAll(proposals, classNames());
        CollectionTools.addAll(proposals, bnfAccessor.internalFromClauseIdentifiers());

        testDoesNotHaveTheseProposals(jpqlQuery, position, proposals);
    }

    @Test
    public final void test_FromClause_10() throws Exception {

        String jpqlQuery = "SELECT e FROM Employee e, Address a ";
        int position = jpqlQuery.length();

        List<String> proposals = new ArrayList<>();
        CollectionTools.addAll(proposals, entityNames());
        CollectionTools.addAll(proposals, classNames());
        CollectionTools.addAll(proposals, bnfAccessor.internalFromClauseIdentifiers());

        testDoesNotHaveTheseProposals(jpqlQuery, position, proposals);
    }

    @Test
    public final void test_FromClause_11() throws Exception {

        String jpqlQuery = "SELECT e FROM Employee e ";
        int position = "SELECT e FROM ".length();

        List<String> proposals = new ArrayList<>();
        CollectionTools.addAll(proposals, entityNames());
        CollectionTools.addAll(proposals, classNames());
        CollectionTools.addAll(proposals, bnfAccessor.internalFromClauseIdentifiers());

        // Not supported for the first "root" object
        proposals.remove(IN);
        proposals.remove(TABLE);

        testHasOnlyTheseProposals(jpqlQuery, position, proposals);
    }

    @Test
    public final void test_FromClause_12() throws Exception {

        String jpqlQuery = "SELECT e FROM Employee e ";
        int position = "SELECT e FROM E".length();

        List<String> proposals = new ArrayList<>();
        CollectionTools.addAll(proposals, filter(entityNames(), "E"));
        CollectionTools.addAll(proposals, filter(classNames(), "E"));
        CollectionTools.addAll(proposals, filter(bnfAccessor.internalFromClauseIdentifiers(), "E"));

        testHasOnlyTheseProposals(jpqlQuery, position, proposals);
    }

    @Test
    public final void test_FromClause_13() throws Exception {

        String jpqlQuery = "SELECT e FROM Employee e ";
        int position = "SELECT e FROM Employee".length();

        List<String> proposals = new ArrayList<>();
        CollectionTools.addAll(proposals, filter(entityNames(), "Employee"));
        CollectionTools.addAll(proposals, filter(classNames(), "Employee"));
        CollectionTools.addAll(proposals, filter(bnfAccessor.internalFromClauseIdentifiers(), "Employee"));

        testHasOnlyTheseProposals(jpqlQuery, position, proposals);
    }

    @Test
    public final void test_FromClause_14() throws Exception {

        String jpqlQuery = "SELECT e FROM Employee e, Address a ";
        int position = "SELECT e FROM Employee e, ".length();

        List<String> proposals = new ArrayList<>();
        CollectionTools.addAll(proposals, entityNames());
        CollectionTools.addAll(proposals, classNames());
        CollectionTools.addAll(proposals, bnfAccessor.internalFromClauseIdentifiers());

        testHasOnlyTheseProposals(jpqlQuery, position, proposals);
    }

    @Test
    public final void test_FromClause_15() throws Exception {

        String jpqlQuery = "SELECT e FROM Employee e, Address a ";
        int position = "SELECT e FROM Employee e, A".length();

        List<String> proposals = new ArrayList<>();
        CollectionTools.addAll(proposals, filter(entityNames(), "A"));
        CollectionTools.addAll(proposals, filter(classNames(), "A"));
        CollectionTools.addAll(proposals, filter(bnfAccessor.internalFromClauseIdentifiers(), "A"));

        testHasOnlyTheseProposals(jpqlQuery, position, proposals);
    }

    @Test
    public final void test_FromClause_16() throws Exception {

        String jpqlQuery = "SELECT e FROM Employee e, I";
        int position = "SELECT e FROM Employee e, I".length();

        List<String> proposals = new ArrayList<>();
        CollectionTools.addAll(proposals, filter(entityNames(), "I"));
        CollectionTools.addAll(proposals, filter(classNames(), "I"));
        CollectionTools.addAll(proposals, filter(bnfAccessor.internalFromClauseIdentifiers(), "I"));

        testHasOnlyTheseProposals(jpqlQuery, position, proposals);
    }

    @Test
    public final void test_FromClause_17() throws Exception {

        String jpqlQuery = "SELECT e FROM Employee e, A";
        int position = "SELECT e FROM Employee e, A".length();

        List<String> proposals = new ArrayList<>();
        CollectionTools.addAll(proposals, filter(entityNames(), "A"));
        CollectionTools.addAll(proposals, filter(classNames(), "A"));
        CollectionTools.addAll(proposals, filter(bnfAccessor.internalFromClauseIdentifiers(), "A"));

        testHasOnlyTheseProposals(jpqlQuery, position, proposals);
    }

    @Test
    public final void test_FromClause_18() {
        String jpqlQuery = "SELECT e FROM Employee e";
        int position = "SELECT e FROM Employee ".length();
        testHasOnlyTheseProposals(jpqlQuery, position, AS);
    }

    @Test
    public final void test_FromClause_19() throws Exception {

        String jpqlQuery = "SELECT e FROM Employee e, , Address a";
        int position = "SELECT e FROM Employee e,".length();

        List<String> proposals = new ArrayList<>();
        CollectionTools.addAll(proposals, entityNames());
        CollectionTools.addAll(proposals, classNames());
        CollectionTools.addAll(proposals, bnfAccessor.internalFromClauseIdentifiers());

        testHasOnlyTheseProposals(jpqlQuery, position, proposals);
    }

    @Test
    public final void test_FromClause_20() throws Exception {

        String jpqlQuery = "SELECT e FROM Employee e, , Address a";
        int position = "SELECT e FROM Employee e, ".length();

        List<String> proposals = new ArrayList<>();
        CollectionTools.addAll(proposals, entityNames());
        CollectionTools.addAll(proposals, classNames());
        CollectionTools.addAll(proposals, bnfAccessor.internalFromClauseIdentifiers());

        testHasOnlyTheseProposals(jpqlQuery, position, proposals);
    }

    @Test
    public final void test_FromClause_21() throws Exception {

        String jpqlQuery = "SELECT e FROM Employee e,, Address a";
        int position = "SELECT e FROM Employee e,".length();

        List<String> proposals = new ArrayList<>();
        CollectionTools.addAll(proposals, entityNames());
        CollectionTools.addAll(proposals, classNames());
        CollectionTools.addAll(proposals, bnfAccessor.internalFromClauseIdentifiers());

        testHasOnlyTheseProposals(jpqlQuery, position, proposals);
    }

    @Test
    public final void test_FromClause_22() {

        String jpqlQuery = "SELECT e FROM Employee e J";
        int position = jpqlQuery.length();

        List<String> proposals = new ArrayList<>();
        CollectionTools.addAll(proposals, filter(fromClauseInternalClauses(FROM), "J"));
        CollectionTools.addAll(proposals, filter(clauses(FROM, null, false), "J"));

        testHasOnlyTheseProposals(jpqlQuery, position, proposals);
    }

    @Test
    public final void test_FromClause_23() {

        String jpqlQuery = "SELECT e FROM Employee e E";
        int position = jpqlQuery.length();

        List<String> proposals = new ArrayList<>();
        CollectionTools.addAll(proposals, filter(fromClauseInternalClauses(FROM), "e"));
        CollectionTools.addAll(proposals, filter(clauses(FROM, null, false), "e"));

        testHasOnlyTheseProposals(jpqlQuery, position, proposals);
    }

    @Test
    public final void test_FromClause_24() {
        String jpqlQuery = "SELECT e FROM Employee e Order b, Address e";
        int position = "SELECT e FROM Employee e Order b".length();
        testHasNoProposals(jpqlQuery, position);
    }

    @Test
    public final void test_FromClause_25() {
        String jpqlQuery = "SELECT e FROM Employee e Order b WHERE e.name = 'JPQL'";
        int position = "SELECT e FROM Employee e Order b".length();
        testHasNoProposals(jpqlQuery, position);
    }

    protected final void test_Function(String fragment,
                                       String ending,
                                       boolean subqueryAllowed) throws Exception {

        test_Function(fragment, ending, subqueryAllowed, new TweakFunctionIdentifiers());
    }

    protected final void test_Function(String fragment,
                                       String ending,
                                       boolean subqueryAllowed,
                                       TweakFunctionIdentifiers tweaker) throws Exception {

        // Test all functions (example: MAX)
        for (String identifier : functionProposals()) {

            // Test by cutting the identifier from all the characters making the identifier up to cutting none
            for (int index = 0; index <= identifier.length(); index++) {

                String identifierFragment = identifier.substring(0, index);
                String jpqlQuery = fragment + identifierFragment + ending;

                // Now move the cursor position from the beginning of the fragment identifier to the end of it
                for (int positionIndex = 0; positionIndex <= index; positionIndex++) {

                    int position = fragment.length() + positionIndex;
                    String filter = identifier.substring(0, positionIndex);

                    List<String> proposals = new ArrayList<>();
                    CollectionTools.addAll(proposals, filter(functionProposals(), filter));
                    CollectionTools.addAll(proposals, filter(new String[] { "e" }, filter));

                    if (subqueryAllowed) {
                        CollectionTools.addAll(proposals, filter(new String[] { SELECT }, filter));
                    }

                    tweaker.tweak(proposals, identifier, identifierFragment, positionIndex);

                    // Now to the test
                    try {
                        testHasOnlyTheseProposals(jpqlQuery, position, proposals);
                    }
                    catch (AssertionError e) {
                        StringBuilder sb = new StringBuilder();
                        sb.append(e.getMessage());
                        sb.append(" \"");
                        sb.append(jpqlQuery.substring(0, position));
                        sb.append("|");
                        sb.append(jpqlQuery.substring(position, jpqlQuery.length()));
                        sb.append("\" [");
                        sb.append(position);
                        sb.append("]");
                        Assert.fail(sb.toString());
                    }
                    finally {
                        tearDown();
                    }
                }
            }
        }
    }

    @Test
    public final void test_Function_01() throws Exception {
        String fragment = "select e from Employee e where ";
        test_Function(fragment, ExpressionTools.EMPTY_STRING, false);
    }

    @Test
    public final void test_Function_02() throws Exception {
        String fragment = "select e from Employee e where ";
        test_Function(fragment, "(", false);
    }

    @Test
    public final void test_Function_03() throws Exception {
        String fragment = "select e from Employee e where (";
        test_Function(fragment, ExpressionTools.EMPTY_STRING, true);
    }

    @Test
    public final void test_Function_04() throws Exception {
        String fragment = "select e from Employee e where (";
        test_Function(fragment, "(", true);
    }

    @Test
    public final void test_Function_05() throws Exception {
        String fragment = "select e from Employee e where (";
        test_Function(fragment, ")", true);
    }

    @Test
    public final void test_Function_06() throws Exception {
        String fragment = "select e from Employee e where ";
        test_Function(fragment, " + ABS(e.roomNumber)", false);
    }

    @Test
    public final void test_GroupBy_01() {
        String jpqlQuery = "SELECT e FROM Employee e ";
        int position = jpqlQuery.length();
        testHasTheseProposals(jpqlQuery, position, GROUP_BY);
    }

    @Test
    public final void test_GroupBy_02() {
        String jpqlQuery = "SELECT e FROM Employee e GROUP BY e.name";
        int position = "SELECT e FROM Employee e ".length();
        testHasTheseProposals(jpqlQuery, position, GROUP_BY);
    }

    @Test
    public final void test_GroupBy_03() {
        String jpqlQuery = "SELECT e FROM Employee e G";
        int position = jpqlQuery.length();
        testHasOnlyTheseProposals(jpqlQuery, position, GROUP_BY);
    }

    @Test
    public final void test_GroupBy_04() {
        String jpqlQuery = "SELECT e FROM Employee e GR";
        int position = jpqlQuery.length();
        testHasTheseProposals(jpqlQuery, position, GROUP_BY);
    }

    @Test
    public final void test_GroupBy_05() {
        String jpqlQuery = "SELECT e FROM Employee e GRO";
        int position = jpqlQuery.length();
        testHasTheseProposals(jpqlQuery, position, GROUP_BY);
    }

    @Test
    public final void test_GroupBy_06() {
        String jpqlQuery = "SELECT e FROM Employee e GROU";
        int position = jpqlQuery.length();
        testHasTheseProposals(jpqlQuery, position, GROUP_BY);
    }

    @Test
    public final void test_GroupBy_07() {
        String jpqlQuery = "SELECT e FROM Employee e GROUP";
        int position = jpqlQuery.length();
        testHasTheseProposals(jpqlQuery, position, GROUP_BY);
    }

    @Test
    public final void test_GroupBy_08() {
        String jpqlQuery = "SELECT e FROM Employee e GROUP ";
        int position = jpqlQuery.length();
        testHasOnlyTheseProposals(jpqlQuery, position, AS, GROUP_BY);
    }

    @Test
    public final void test_GroupBy_09() {
        String jpqlQuery = "SELECT e FROM Employee e GROUP B";
        int position = jpqlQuery.length();
        testHasOnlyTheseProposals(jpqlQuery, position, GROUP_BY);
    }

    @Test
    public final void test_GroupBy_10() {
        String jpqlQuery = "SELECT e FROM Employee e GROUP BY";
        int position = jpqlQuery.length();
        testHasOnlyTheseProposals(jpqlQuery, position, GROUP_BY);
    }

    @Test
    public final void test_GroupBy_11() {
        String jpqlQuery = "SELECT e FROM Employee e WHERE (e.name = 'Pascal') ";
        int position = jpqlQuery.length();
        testHasTheseProposals(jpqlQuery, position, GROUP_BY);
    }

    @Test
    public final void test_GroupBy_12() {
        String jpqlQuery = "SELECT e FROM Employee e WHERE (e.name = 'Pascal') G";
        int position = jpqlQuery.length();
        testHasOnlyTheseProposals(jpqlQuery, position, GROUP_BY);
    }

    @Test
    public final void test_GroupBy_13() {
        String jpqlQuery = "SELECT e FROM Employee e WHERE e.roomNumber";
        int position = jpqlQuery.length();
        testDoesNotHaveTheseProposals(jpqlQuery, position, GROUP_BY);
    }

    @Test
    public final void test_GroupBy_14() {
        String jpqlQuery = "SELECT e FROM Employee e, GROUP";
        int position = jpqlQuery.length();
        testDoesNotHaveTheseProposals(jpqlQuery, position, GROUP_BY);
    }

    @Test
    public final void test_GroupBy_15() {
        String jpqlQuery = "SELECT e FROM Employee e GROUP, Address a";
        int position = "SELECT e FROM Employee e GROUP".length();
        testDoesNotHaveTheseProposals(jpqlQuery, position, GROUP_BY);
    }

    @Test
    public final void test_Having_01() {
        test_ConditionalClause_01(HAVING);
    }

    @Test
    public final void test_Having_02() {
        test_ConditionalClause_02(HAVING);
    }

    @Test
    public final void test_Having_03() {
        test_ConditionalClause_03(HAVING);
    }

    @Test
    public final void test_Having_04() {
        test_ConditionalClause_04(HAVING);
    }

    @Test
    public final void test_Having_05() {
        test_ConditionalClause_05(HAVING);
    }

    @Test
    public final void test_Having_06() {
        test_ConditionalClause_06(HAVING);
    }
    @Test
    public final void test_Having_07() {
        test_ConditionalClause_07(HAVING);
    }

    @Test
    public final void test_Having_08() {

        String fragment = "SELECT e FROM Employee e WHERE (e.name = 'Pascal') ";

        for (int index = 0, count = HAVING.length(); index <= count; index++) {

            String jpqlQuery = fragment + HAVING.substring(0, index);

            for (int positionIndex = fragment.length(), count2 = jpqlQuery.length(); positionIndex <= count2; positionIndex++) {
                testHasTheseProposals(jpqlQuery, positionIndex, HAVING);
            }
        }
    }

    @Test
    public final void test_IncompleteCollectionExpressionVisitor_01() {
        String jpqlQuery = "SELECT e FROM Employee e GROUP B";
        int position = jpqlQuery.length();
        testHasOnlyTheseProposals(jpqlQuery, position, GROUP_BY);
    }

    @Test
    public final void test_IncompleteCollectionExpressionVisitor_02() {
        String jpqlQuery = "SELECT e FROM Employee e ORDER B";
        int position = jpqlQuery.length();
        testHasOnlyTheseProposals(jpqlQuery, position, ORDER_BY);
    }

    @Test
    public final void test_IncompleteCollectionExpressionVisitor_03() {
        String jpqlQuery = "SELECT e FROM Employee e ORDER B HAVING e.name = 'JPQL'";
        int position = "SELECT e FROM Employee e ORDER B".length();
        testHasNoProposals(jpqlQuery, position);
    }

    @Test
    public final void test_IncompleteCollectionExpressionVisitor_04() {
        String jpqlQuery = "SELECT e FROM Employee e GROUP B HAVING e.name = 'JPQL'";
        int position = "SELECT e FROM Employee e GROUP B".length();
        testHasOnlyTheseProposals(jpqlQuery, position, GROUP_BY);
    }

    @Test
    public final void test_IncompleteCollectionExpressionVisitor_05() {
        String jpqlQuery = "SELECT e FROM Employee e GROUP B HAVING e.name = 'JPQL'";
        int position = "SELECT e FROM Employee e GROUP B".length();
        testHasOnlyTheseProposals(jpqlQuery, position, GROUP_BY);
    }

    @Test
    public final void test_IncompleteCollectionExpressionVisitor_06() {
        String jpqlQuery = "SELECT e FROM Employee e HAVING e.name = 'JPQL' ORDER B";
        int position = jpqlQuery.length();
        testHasOnlyTheseProposals(jpqlQuery, position, ORDER_BY);
    }

    @Test
    public final void test_IncompleteCollectionExpressionVisitor_07() {
        String jpqlQuery = "SELECT e FROM Employee e WHERE ALL(SELECT a FROM Address a HAVING e.name = 'JPQL' ORDER B";
        int position = jpqlQuery.length();
        testHasNoProposals(jpqlQuery, position);
    }

    @Test
    public final void test_IncompleteCollectionExpressionVisitor_08() {
        String jpqlQuery = "SELECT e FROM Employee e GROUP B ORT b a";
        int position = "SELECT e FROM Employee e GROUP B".length();
        testHasNoProposals(jpqlQuery, position);
    }

    @Test
    public final void test_Invalid_01() {
        String jpqlQuery = "SELECT e FROM Employee e WHERE e.name IS e.name";
        int position = "SELECT e FROM Employee e WHERE e.name IS e.".length();
        testHasNoProposals(jpqlQuery, position);
    }

    @Test
    public final void test_Invalid_02() {
        String jpqlQuery = "SELECT e FROM Employee e WHERE e.name IS CONCAT(";
        int position = jpqlQuery.length();
        testHasNoProposals(jpqlQuery, position);
    }

    @Test
    public final void test_Is_01() {
        String jpqlQuery = "select e from Employee e where e.managerEmployee is not ";
        int position = jpqlQuery.length();
        testHasOnlyTheseProposals(jpqlQuery, position, IS_NOT_NULL);
    }

    @Test
    public final void test_Is_02() {
        String jpqlQuery = "select e from Employee e where e.department is ";
        int position = jpqlQuery.length();
        testHasOnlyTheseProposals(jpqlQuery, position, IS_NULL, IS_NOT_NULL);
    }

    @Test
    public final void test_Is_03() {
        String jpqlQuery = "SELECT e FROM Employee e WHERE e.name IS e.name";
        int position = "SELECT e FROM Employee e WHERE e.name IS ".length();
        testHasOnlyTheseProposals(jpqlQuery, position, IS_NULL, IS_NOT_NULL);
    }

    @Test
    public final void test_Is_04() {
        String jpqlQuery = "SELECT e FROM Employee e WHERE e.name IS WHERE";
        int position = "SELECT e FROM Employee e WHERE e.name IS ".length();
        testHasOnlyTheseProposals(jpqlQuery, position, IS_NULL, IS_NOT_NULL);
    }

    @Test
    public final void test_Is_05() {
        String jpqlQuery = "select e from Employee e where (SELECT a FROM Address a) is ";
        int position = jpqlQuery.length();
        testDoesNotHaveTheseProposals(jpqlQuery, position, IS_NULL, IS_NOT_NULL);
    }

    @Test
    public final void test_Join_01() {
        String jpqlQuery = "SELECT pub FROM Publisher pub LEFT JOIN";
        int position = "SELECT pub FROM Publisher pub ".length();
        testHasOnlyTheseProposals(jpqlQuery, position, joinIdentifiers());
    }

    @Test
    public final void test_Join_02() {
        String jpqlQuery = "SELECT pub FROM Publisher pub LEFT JOIN";
        int position = "SELECT pub FROM Publisher pub L".length();
        testHasOnlyTheseProposals(jpqlQuery, position, joinIdentifiers());
    }

    @Test
    public final void test_Join_03() {
        String jpqlQuery = "SELECT pub FROM Publisher pub LEFT JOIN";
        int position = "SELECT pub FROM Publisher pub LE".length();
        testHasOnlyTheseProposals(jpqlQuery, position, joinIdentifiers());
    }

    @Test
    public final void test_Join_04() {
        String jpqlQuery = "SELECT pub FROM Publisher pub LEFT JOIN";
        int position = "SELECT pub FROM Publisher pub LEF".length();
        testHasOnlyTheseProposals(jpqlQuery, position, joinIdentifiers());
    }

    @Test
    public final void test_Join_05() {
        String jpqlQuery = "SELECT pub FROM Publisher pub LEFT JOIN";
        int position = "SELECT pub FROM Publisher pub LEFT".length();
        testHasOnlyTheseProposals(jpqlQuery, position, joinIdentifiers());
    }

    @Test
    public final void test_Join_06() {
        String jpqlQuery = "SELECT pub FROM Publisher pub LEFT JOIN";
        int position = "SELECT pub FROM Publisher pub LEFT ".length();
        testHasOnlyTheseProposals(jpqlQuery, position, joinIdentifiers());
    }

    @Test
    public final void test_Join_07() {
        String jpqlQuery = "SELECT pub FROM Publisher pub LEFT JOIN";
        int position = "SELECT pub FROM Publisher pub LEFT J".length();
        testHasOnlyTheseProposals(jpqlQuery, position, joinIdentifiers());
    }

    @Test
    public final void test_Join_08() {
        String jpqlQuery = "SELECT pub FROM Publisher pub LEFT JOIN";
        int position = "SELECT pub FROM Publisher pub LEFT JO".length();
        testHasOnlyTheseProposals(jpqlQuery, position, joinIdentifiers());
    }

    @Test
    public final void test_Join_09() {
        String jpqlQuery = "SELECT pub FROM Publisher pub LEFT JOIN";
        int position = "SELECT pub FROM Publisher pub LEFT JOI".length();
        testHasOnlyTheseProposals(jpqlQuery, position, joinIdentifiers());
    }

    @Test
    public final void test_Join_10() {
        String jpqlQuery = "SELECT pub FROM Publisher pub LEFT JOIN";
        int position = jpqlQuery.length();
        testHasOnlyTheseProposals(jpqlQuery, position, joinIdentifiers());
    }

    @Test
    public final void test_Join_11() {
        String jpqlQuery = "SELECT pub FROM Publisher pub JOIN";
        int position = "SELECT pub FROM Publisher pub ".length();
        testHasOnlyTheseProposals(jpqlQuery, position, joinIdentifiers());
    }

    @Test
    public final void test_Join_12() {
        String jpqlQuery = "SELECT pub FROM Publisher pub JOIN";
        int position = "SELECT pub FROM Publisher pub J".length();
        testHasOnlyTheseProposals(jpqlQuery, position, joinIdentifiers());
    }

    @Test
    public final void test_Join_13() {
        String jpqlQuery = "SELECT pub FROM Publisher pub JOIN";
        int position = "SELECT pub FROM Publisher pub JO".length();
        testHasOnlyTheseProposals(jpqlQuery, position, joinIdentifiers());
    }

    @Test
    public final void test_Join_14() {
        String jpqlQuery = "SELECT pub FROM Publisher pub JOIN";
        int position = "SELECT pub FROM Publisher pub JOI".length();
        testHasOnlyTheseProposals(jpqlQuery, position, joinIdentifiers());
    }

    @Test
    public final void test_Join_15() {
        String jpqlQuery = "SELECT pub FROM Publisher pub JOIN";
        int position = jpqlQuery.length();
        testHasOnlyTheseProposals(jpqlQuery, position, joinIdentifiers());
    }

    @Test
    public final void test_Join_16() {
        String jpqlQuery = "SELECT pub FROM Publisher pub LEFT OUTER JOIN";
        int position = "SELECT pub FROM Publisher pub ".length();
        testHasOnlyTheseProposals(jpqlQuery, position, joinIdentifiers());
    }

    @Test
    public final void test_Join_17() {
        String jpqlQuery = "SELECT pub FROM Publisher pub LEFT OUTER JOIN";
        int position = "SELECT pub FROM Publisher pub L".length();
        testHasOnlyTheseProposals(jpqlQuery, position, joinIdentifiers());
    }

    @Test
    public final void test_Join_18() {
        String jpqlQuery = "SELECT pub FROM Publisher pub LEFT OUTER JOIN";
        int position = "SELECT pub FROM Publisher pub LE".length();
        testHasOnlyTheseProposals(jpqlQuery, position, joinIdentifiers());
    }

    @Test
    public final void test_Join_19() {
        String jpqlQuery = "SELECT pub FROM Publisher pub LEFT OUTER JOIN";
        int position = "SELECT pub FROM Publisher pub LEF".length();
        testHasOnlyTheseProposals(jpqlQuery, position, joinIdentifiers());
    }

    @Test
    public final void test_Join_20() {
        String jpqlQuery = "SELECT pub FROM Publisher pub LEFT OUTER JOIN";
        int position = "SELECT pub FROM Publisher pub LEFT".length();
        testHasOnlyTheseProposals(jpqlQuery, position, joinIdentifiers());
    }

    @Test
    public final void test_Join_21() {
        String jpqlQuery = "SELECT pub FROM Publisher pub LEFT OUTER JOIN";
        int position = "SELECT pub FROM Publisher pub LEFT ".length();
        testHasOnlyTheseProposals(jpqlQuery, position, joinIdentifiers());
    }

    @Test
    public final void test_Join_22() {
        String jpqlQuery = "SELECT pub FROM Publisher pub LEFT OUTER JOIN";
        int position = "SELECT pub FROM Publisher pub LEFT O".length();
        testHasOnlyTheseProposals(jpqlQuery, position, joinIdentifiers());
    }

    @Test
    public final void test_Join_23() {
        String jpqlQuery = "SELECT pub FROM Publisher pub LEFT OUTER JOIN";
        int position = "SELECT pub FROM Publisher pub LEFT OU".length();
        testHasOnlyTheseProposals(jpqlQuery, position, joinIdentifiers());
    }

    @Test
    public final void test_Join_24() {
        String jpqlQuery = "SELECT pub FROM Publisher pub LEFT OUTER JOIN";
        int position = "SELECT pub FROM Publisher pub LEFT OUT".length();
        testHasOnlyTheseProposals(jpqlQuery, position, joinIdentifiers());
    }

    @Test
    public final void test_Join_25() {
        String jpqlQuery = "SELECT pub FROM Publisher pub LEFT OUTER JOIN";
        int position = "SELECT pub FROM Publisher pub LEFT OUTE".length();
        testHasOnlyTheseProposals(jpqlQuery, position, joinIdentifiers());
    }

    @Test
    public final void test_Join_26() {
        String jpqlQuery = "SELECT pub FROM Publisher pub LEFT OUTER JOIN";
        int position = "SELECT pub FROM Publisher pub LEFT OUTER".length();
        testHasOnlyTheseProposals(jpqlQuery, position, joinIdentifiers());
    }

    @Test
    public final void test_Join_27() {
        String jpqlQuery = "SELECT pub FROM Publisher pub LEFT OUTER JOIN";
        int position = "SELECT pub FROM Publisher pub LEFT OUTER ".length();
        testHasOnlyTheseProposals(jpqlQuery, position, joinIdentifiers());
    }

    @Test
    public final void test_Join_28() {
        String jpqlQuery = "SELECT pub FROM Publisher pub LEFT OUTER JOIN";
        int position = "SELECT pub FROM Publisher pub LEFT OUTER J".length();
        testHasOnlyTheseProposals(jpqlQuery, position, joinIdentifiers());
    }

    @Test
    public final void test_Join_29() {
        String jpqlQuery = "SELECT pub FROM Publisher pub LEFT OUTER JOIN";
        int position = "SELECT pub FROM Publisher pub LEFT OUTER JO".length();
        testHasOnlyTheseProposals(jpqlQuery, position, joinIdentifiers());
    }

    @Test
    public final void test_Join_30() {
        String jpqlQuery = "SELECT pub FROM Publisher pub LEFT OUTER JOIN";
        int position = "SELECT pub FROM Publisher pub LEFT OUTER JOI".length();
        testHasOnlyTheseProposals(jpqlQuery, position, joinIdentifiers());
    }

    @Test
    public final void test_Join_31() {
        String jpqlQuery = "SELECT pub FROM Publisher pub LEFT OUTER JOIN";
        int position = "SELECT pub FROM Publisher pub LEFT OUTER JOIN".length();
        testHasOnlyTheseProposals(jpqlQuery, position, joinIdentifiers());
    }

    @Test
    public final void test_Join_32() {
        String jpqlQuery = "SELECT pub FROM Publisher pub JOIN pub.magazines AS mag";
        int position = "SELECT pub FROM Publisher pub JOIN pub.magazines ".length();
        testHasOnlyTheseProposals(jpqlQuery, position, AS);
    }

    @Test
    public final void test_Join_33() {
        String jpqlQuery = "SELECT pub FROM Publisher pub JOIN pub.magazines AS mag";
        int position = "SELECT pub FROM Publisher pub JOIN pub.magazines A".length();
        testHasOnlyTheseProposals(jpqlQuery, position, AS);
    }

    @Test
    public final void test_Join_34() {
        String jpqlQuery = "SELECT pub FROM Publisher pub JOIN pub.magazines AS mag";
        int position = "SELECT pub FROM Publisher pub JOIN pub.magazines AS".length();
        testHasOnlyTheseProposals(jpqlQuery, position, AS);
    }

    @Test
    public final void test_Join_35() {
        String jpqlQuery = "SELECT e FROM Employee e INNER JOIN e.magazines mags";
        int position = "SELECT e FROM Employee e ".length();
        testHasOnlyTheseProposals(jpqlQuery, position, joinIdentifiers());
    }

    @Test
    public final void test_Join_36() {

        String jpqlQuery = "SELECT e FROM Employee e INNER JOIN e.magazines mags ";
        int position = jpqlQuery.length();

        List<String> proposals = new ArrayList<>();
        CollectionTools.addAll(proposals, fromClauseInternalClauses(FROM));
        CollectionTools.addAll(proposals, clauses(FROM, null, false));

        testHasOnlyTheseProposals(jpqlQuery, position, proposals);
    }

    @Test
    public final void test_Join_37() {

        String jpqlQuery = "SELECT e FROM Employee e INNER JOIN e.mags mags";
        int position = "SELECT e FROM Employee e INNER".length();

        if (isJoinFetchIdentifiable()) {
            testHasOnlyTheseProposals(jpqlQuery, position, joinIdentifiers());
        }
        else {
            testHasOnlyTheseProposals(jpqlQuery, position, joinOnlyIdentifiers());
        }
    }

    @Test
    public final void test_Join_38() {
        String jpqlQuery = "SELECT o from Countries o JOIN o.locationsList e LEFT ";
        int position = jpqlQuery.length();
        testHasOnlyTheseProposals(jpqlQuery, position, filter(joinIdentifiers(), "LEFT "));
    }

    @Test
    public final void test_Join_39() {
        String jpqlQuery = "SELECT o from Countries o JOIN o.locationsList e LEFT OUTER JOIN FETCH  ";
        int position = jpqlQuery.length();
        testHasOnlyTheseProposals(jpqlQuery, position, "o", "e");
    }

    @Test
    public final void test_Join_40() {
        String jpqlQuery = "select o.city from Address o ,";
        int position = "select o.city from Address o ".length();
        testHasOnlyTheseProposals(jpqlQuery, position, joinIdentifiers());
    }

    @Test
    public final void test_Join_41() {
        String jpqlQuery = "SELECT o from Countries o JOIN o.locationsList ";
        int position = jpqlQuery.length();
        testHasOnlyTheseProposals(jpqlQuery, position, AS);
    }

    @Test
    public final void test_Join_42() {
        String jpqlQuery = "SELECT o from Countries o JOIN o.locationsList A";
        int position = jpqlQuery.length();
        testHasOnlyTheseProposals(jpqlQuery, position, AS);
    }

    @Test
    public final void test_Join_43() {
        String jpqlQuery = "SELECT o from Countries o JOIN o.locationsList J";
        int position = jpqlQuery.length();
        testDoesNotHaveTheseProposals(jpqlQuery, position, AS);
    }

    @Test
    public final void test_Join_44() {
        String jpqlQuery = "SELECT o from Countries o JOIN o.locationsList J LEFT JOIN ";
        int position = jpqlQuery.length();
        testHasOnlyTheseProposals(jpqlQuery, position, "o", "J");
    }

    @Test
    public final void test_Join_45() {
        String jpqlQuery = "SELECT o from Countries o JOIN o.locationsList J LEFT JOIN L";
        int position = jpqlQuery.length();
        testDoesNotHaveTheseProposals(jpqlQuery, position, "o");
    }

    @Test
    public final void test_Keyword_01() {
        String jpqlQuery = "UPDATE Employee e SET e.isEnrolled = TRUE";
        int position = "UPDATE Employee e SET e.isEnrolled = ".length();
        testHasTheseProposals(jpqlQuery, position, TRUE);
    }

    @Test
    public final void test_Keyword_02() {
        String jpqlQuery = "UPDATE Employee e SET e.isEnrolled = TRUE";
        int position = "UPDATE Employee e SET e.isEnrolled = T".length();
        testHasTheseProposals(jpqlQuery, position, TRUE);
    }

    @Test
    public final void test_Keyword_03() {
        String jpqlQuery = "UPDATE Employee e SET e.isEnrolled = TRUE";
        int position = "UPDATE Employee e SET e.isEnrolled = TR".length();
        testHasTheseProposals(jpqlQuery, position, TRUE);
    }

    @Test
    public final void test_Keyword_04() {
        String jpqlQuery = "UPDATE Employee e SET e.isEnrolled = TRUE";
        int position = "UPDATE Employee e SET e.isEnrolled = TRU".length();
        testHasTheseProposals(jpqlQuery, position, TRUE);
    }

    @Test
    public final void test_Keyword_05() {
        String jpqlQuery = "UPDATE Employee e SET e.isEnrolled = TRUE";
        int position = jpqlQuery.length();
        testHasOnlyTheseProposals(jpqlQuery, position, TRUE, FALSE, NULL);
    }

    @Test
    public final void test_Keyword_06() {
        String jpqlQuery = "UPDATE Employee e SET e.isEnrolled = FALSE";
        int position = "UPDATE Employee e SET e.isEnrolled = ".length();
        testHasTheseProposals(jpqlQuery, position, FALSE);
    }

    @Test
    public final void test_Keyword_07() {
        String jpqlQuery = "UPDATE Employee e SET e.isEnrolled = FALSE";
        int position = "UPDATE Employee e SET e.isEnrolled = F".length();
        testHasTheseProposals(jpqlQuery, position, FALSE);
    }

    @Test
    public final void test_Keyword_08() {
        String jpqlQuery = "UPDATE Employee e SET e.isEnrolled = FALSE";
        int position = "UPDATE Employee e SET e.isEnrolled = FA".length();
        testHasTheseProposals(jpqlQuery, position, FALSE);
    }

    @Test
    public final void test_Keyword_09() {
        String jpqlQuery = "UPDATE Employee e SET e.isEnrolled = FALSE";
        int position = "UPDATE Employee e SET e.isEnrolled = FAL".length();
        testHasTheseProposals(jpqlQuery, position, FALSE);
    }

    @Test
    public final void test_Keyword_10() {
        String jpqlQuery = "UPDATE Employee e SET e.isEnrolled = FALSE";
        int position = "UPDATE Employee e SET e.isEnrolled = FALS".length();
        testHasTheseProposals(jpqlQuery, position, FALSE);
    }

    @Test
    public final void test_Keyword_11() {
        String jpqlQuery = "UPDATE Employee e SET e.isEnrolled = FALSE";
        int position = jpqlQuery.length();
        testHasOnlyTheseProposals(jpqlQuery, position, TRUE, FALSE, NULL);
    }

    @Test
    public final void test_Keyword_12() {
        String jpqlQuery = "UPDATE Employee e SET e.isEnrolled = NULL";
        int position = "UPDATE Employee e SET e.isEnrolled = ".length();
        testHasTheseProposals(jpqlQuery, position, NULL);
    }

    @Test
    public final void test_Keyword_13() {
        String jpqlQuery = "UPDATE Employee e SET e.isEnrolled = NULL";
        int position = "UPDATE Employee e SET e.isEnrolled = N".length();
        testHasTheseProposals(jpqlQuery, position, NULL);
    }

    @Test
    public final void test_Keyword_14() {
        String jpqlQuery = "UPDATE Employee e SET e.isEnrolled = NULL";
        int position = "UPDATE Employee e SET e.isEnrolled = NU".length();
        testHasTheseProposals(jpqlQuery, position, NULL);
    }

    @Test
    public final void test_Keyword_15() {
        String jpqlQuery = "UPDATE Employee e SET e.isEnrolled = NULL";
        int position = "UPDATE Employee e SET e.isEnrolled = NUL".length();
        testHasTheseProposals(jpqlQuery, position, NULL);
    }

    @Test
    public final void test_Keyword_16() {
        String jpqlQuery = "UPDATE Employee e SET e.isEnrolled = NULL";
        int position = jpqlQuery.length();
        testHasOnlyTheseProposals(jpqlQuery, position, NULL, TRUE, FALSE, NULLIF);
    }

    @Test
    public final void test_Keyword_17() {
        String jpqlQuery = "SELECT e FROM Employee e WHERE e.hired = TRUE";
        int position = "SELECT e FROM Employee e WHERE e.hired = ".length();
        testHasTheseProposals(jpqlQuery, position, TRUE);
    }

    @Test
    public final void test_Keyword_18() {
        String jpqlQuery = "SELECT e FROM Employee e WHERE e.hired = TRUE";
        int position = "SELECT e FROM Employee e WHERE e.hired = T".length();
        testHasTheseProposals(jpqlQuery, position, TRUE);
    }

    @Test
    public final void test_Keyword_19() {
        String jpqlQuery = "SELECT e FROM Employee e WHERE e.hired = TRUE";
        int position = "SELECT e FROM Employee e WHERE e.hired = TR".length();
        testHasTheseProposals(jpqlQuery, position, TRUE);
    }

    @Test
    public final void test_Keyword_20() {
        String jpqlQuery = "SELECT e FROM Employee e WHERE e.hired = TRUE";
        int position = "SELECT e FROM Employee e WHERE e.hired = TRU".length();
        testHasTheseProposals(jpqlQuery, position, TRUE);
    }

    @Test
    public final void test_Keyword_21() {
        String jpqlQuery = "SELECT e FROM Employee e WHERE e.hired = TRUE";
        int position = jpqlQuery.length();
        testHasOnlyTheseProposals(jpqlQuery, position, TRUE, FALSE, NULL);
    }

    @Test
    public final void test_Keyword_22() {
        String jpqlQuery = "SELECT e FROM Employee e WHERE e.hired = FALSE";
        int position = "SELECT e FROM Employee e WHERE e.hired = ".length();
        testHasTheseProposals(jpqlQuery, position, FALSE);
    }

    @Test
    public final void test_Keyword_23() {
        String jpqlQuery = "SELECT e FROM Employee e WHERE e.hired = FALSE";
        int position = "SELECT e FROM Employee e WHERE e.hired = F".length();
        testHasTheseProposals(jpqlQuery, position, FALSE);
    }

    @Test
    public final void test_Keyword_24() {
        String jpqlQuery = "SELECT e FROM Employee e WHERE e.hired = FALSE";
        int position = "SELECT e FROM Employee e WHERE e.hired = FA".length();
        testHasTheseProposals(jpqlQuery, position, FALSE);
    }

    @Test
    public final void test_Keyword_25() {
        String jpqlQuery = "SELECT e FROM Employee e WHERE e.hired = FALSE";
        int position = "SELECT e FROM Employee e WHERE e.hired = FAL".length();
        testHasTheseProposals(jpqlQuery, position, FALSE);
    }

    @Test
    public final void test_Keyword_26() {
        String jpqlQuery = "SELECT e FROM Employee e WHERE e.hired = FALSE";
        int position = "SELECT e FROM Employee e WHERE e.hired = FALS".length();
        testHasTheseProposals(jpqlQuery, position, FALSE);
    }

    @Test
    public final void test_Keyword_27() {
        String jpqlQuery = "SELECT e FROM Employee e WHERE e.hired = FALSE";
        int position = jpqlQuery.length();
        testHasOnlyTheseProposals(jpqlQuery, position, TRUE, FALSE, NULL);
    }

    @Test
    public final void test_Keyword_28() {
        String jpqlQuery = "SELECT e FROM Employee e WHERE e.hired = NULL";
        int position = "SELECT e FROM Employee e WHERE e.hired = ".length();
        testHasTheseProposals(jpqlQuery, position, NULL);
    }

    @Test
    public final void test_Keyword_29() {
        String jpqlQuery = "SELECT e FROM Employee e WHERE e.hired = NULL";
        int position = "SELECT e FROM Employee e WHERE e.hired = N".length();
        testHasTheseProposals(jpqlQuery, position, NULL);
    }

    @Test
    public final void test_Keyword_30() {
        String jpqlQuery = "SELECT e FROM Employee e WHERE e.hired = NULL";
        int position = "SELECT e FROM Employee e WHERE e.hired = NU".length();
        testHasTheseProposals(jpqlQuery, position, NULL);
    }

    @Test
    public final void test_Keyword_31() {
        String jpqlQuery = "SELECT e FROM Employee e WHERE e.hired = NULL";
        int position = "SELECT e FROM Employee e WHERE e.hired = NUL".length();
        testHasTheseProposals(jpqlQuery, position, NULL);
    }

    @Test
    public final void test_Keyword_32() {
        String jpqlQuery = "SELECT e FROM Employee e WHERE e.hired = NULL";
        int position = jpqlQuery.length();
        testHasOnlyTheseProposals(jpqlQuery, position, NULL, TRUE, FALSE, NULLIF);
    }

    @Test
    public final void test_Keyword_33() {
        String jpqlQuery = "SELECT e FROM Employee e WHERE ";
        int position = jpqlQuery.length();
        testHasTheseProposals(jpqlQuery, position, NULL, TRUE, FALSE);
    }

    @Test
    public final void test_Keyword_34() {
        String jpqlQuery = "SELECT e FROM Employee e WHERE e.hired =";
        int position = jpqlQuery.length();
        testHasTheseProposals(jpqlQuery, position, NULL, TRUE, FALSE);
    }

    @Test
    public final void test_Keyword_35() {
        String jpqlQuery = "SELECT e FROM Employee e WHERE e.hired = ";
        int position = jpqlQuery.length();
        testHasTheseProposals(jpqlQuery, position, NULL, TRUE, FALSE);
    }

    @Test
    public final void test_Keyword_36() {

        String jpqlQuery = "SELECT e FROM Employee e WHERE e.hired = NULL ";
        int position = jpqlQuery.length();

        List<String> proposals = new ArrayList<>();
        CollectionTools.addAll(proposals, bnfAccessor.logicalIdentifiers());
        CollectionTools.addAll(proposals, clauses(WHERE, null, false));

        testHasOnlyTheseProposals(jpqlQuery, position, proposals);
    }

    @Test
    public final void test_Like_01() {
        String jpqlQuery = "SELECT e FROM Employee e WHERE ";
        int position = jpqlQuery.length();
        testDoesNotHaveTheseProposals(jpqlQuery, position, LIKE, NOT_LIKE);
    }

    @Test
    public final void test_Like_02() {
        String jpqlQuery = "SELECT e FROM Employee e WHERE e.name ";
        int position = jpqlQuery.length();
        testHasTheseProposals(jpqlQuery, position, LIKE, NOT_LIKE);
    }

    @Test
    public final void test_Like_03() {
        String jpqlQuery = "SELECT e FROM Employee e WHERE e.name L";
        int position = jpqlQuery.length();
        testHasOnlyTheseProposals(jpqlQuery, position, LIKE);
    }

    @Test
    public final void test_Like_04() {
        String jpqlQuery = "SELECT e FROM Employee e WHERE e.name LI";
        int position = jpqlQuery.length();
        testHasOnlyTheseProposals(jpqlQuery, position, LIKE);
    }

    @Test
    public final void test_Like_05() {
        String jpqlQuery = "SELECT e FROM Employee e WHERE e.name LIKE";
        int position = jpqlQuery.length();
        testHasOnlyTheseProposals(jpqlQuery, position, LIKE, NOT_LIKE);
    }

    @Test
    public final void test_Like_06() {
        String jpqlQuery = "SELECT e FROM Employee e WHERE e.name N";
        int position = jpqlQuery.length();
        testHasTheseProposals(jpqlQuery, position, NOT_LIKE);
    }

    @Test
    public final void test_Like_07() {
        String jpqlQuery = "SELECT e FROM Employee e WHERE e.name NO";
        int position = jpqlQuery.length();
        testHasTheseProposals(jpqlQuery, position, NOT_LIKE);
    }

    @Test
    public final void test_Like_08() {
        String jpqlQuery = "SELECT e FROM Employee e WHERE e.name NOT";
        int position = jpqlQuery.length();
        testHasTheseProposals(jpqlQuery, position, NOT_LIKE);
    }

    @Test
    public final void test_Like_09() {
        String jpqlQuery = "SELECT e FROM Employee e WHERE e.name NOT LIKE";
        int position = "SELECT e FROM Employee e WHERE e.name ".length();
        testHasTheseProposals(jpqlQuery, position, NOT_LIKE);
    }

    @Test
    public final void test_Like_10() {
        String jpqlQuery = "SELECT e FROM Employee e WHERE e.name NOT LIKE";
        int position = "SELECT e FROM Employee e WHERE e.name N".length();
        testHasTheseProposals(jpqlQuery, position, NOT_LIKE);
    }

    @Test
    public final void test_Like_11() {
        String jpqlQuery = "SELECT e FROM Employee e WHERE e.name NOT LIKE";
        int position = "SELECT e FROM Employee e WHERE e.name NO".length();
        testHasTheseProposals(jpqlQuery, position, NOT_LIKE);
    }

    @Test
    public final void test_Like_12() {
        String jpqlQuery = "SELECT e FROM Employee e WHERE e.name NOT LIKE";
        int position = "SELECT e FROM Employee e WHERE e.name NOT ".length();
        testHasTheseProposals(jpqlQuery, position, NOT_LIKE);
    }

    @Test
    public final void test_Like_13() {
        String jpqlQuery = "SELECT e FROM Employee e WHERE e.name NOT LIKE";
        int position = "SELECT e FROM Employee e WHERE e.name NOT L".length();
        testHasTheseProposals(jpqlQuery, position, NOT_LIKE);
    }

    @Test
    public final void test_Like_14() {
        String jpqlQuery = "SELECT e FROM Employee e WHERE e.name NOT LIKE";
        int position = "SELECT e FROM Employee e WHERE e.name NOT LI".length();
        testHasTheseProposals(jpqlQuery, position, NOT_LIKE);
    }

    @Test
    public final void test_Like_15() {
        String jpqlQuery = "SELECT e FROM Employee e WHERE e.name NOT LIKE";
        int position = "SELECT e FROM Employee e WHERE e.name NOT LIK".length();
        testHasTheseProposals(jpqlQuery, position, NOT_LIKE);
    }

    @Test
    public final void test_Like_16() {
        String jpqlQuery = "SELECT e FROM Employee e WHERE e.name NOT LIKE";
        int position = jpqlQuery.length();
        testHasOnlyTheseProposals(jpqlQuery, position, LIKE, NOT_LIKE);
    }

    @Test
    public final void test_Locate_01() {
        String jpqlQuery = "SELECT e FROM Employee e WHERE ";
        int position = jpqlQuery.length();
        testHasTheseProposals(jpqlQuery, position, LOCATE);
    }

    @Test
    public final void test_Locate_02() {
        String jpqlQuery = "SELECT e FROM Employee e WHERE L";
        int position = jpqlQuery.length();
        testHasTheseProposals(jpqlQuery, position, LOCATE);
    }

    @Test
    public final void test_Locate_03() {
        String jpqlQuery = "SELECT e FROM Employee e WHERE LO";
        int position = jpqlQuery.length();
        testHasTheseProposals(jpqlQuery, position, LOCATE);
    }

    @Test
    public final void test_Locate_04() {
        String jpqlQuery = "SELECT e FROM Employee e WHERE LOC";
        int position = jpqlQuery.length();
        testHasTheseProposals(jpqlQuery, position, LOCATE);
    }

    @Test
    public final void test_Locate_05() {
        String jpqlQuery = "SELECT e FROM Employee e WHERE LOCA";
        int position = jpqlQuery.length();
        testHasTheseProposals(jpqlQuery, position, LOCATE);
    }

    @Test
    public final void test_Locate_06() {
        String jpqlQuery = "SELECT e FROM Employee e WHERE LOCAT";
        int position = jpqlQuery.length();
        testHasTheseProposals(jpqlQuery, position, LOCATE);
    }

    @Test
    public final void test_Locate_07() {
        String jpqlQuery = "SELECT e FROM Employee e WHERE LOCATE";
        int position = jpqlQuery.length();
        testHasTheseProposals(jpqlQuery, position, LOCATE);
    }

    @Test
    public final void test_Locate_08() {
        String jpqlQuery = "SELECT e FROM Employee e WHERE LOCATE(";
        int position = jpqlQuery.length() - 1;
        testHasTheseProposals(jpqlQuery, position, LOCATE);
    }

    @Test
    public final void test_Locate_09() {
        String jpqlQuery = "SELECT e FROM Employee e WHERE (";
        int position = jpqlQuery.length();
        testHasTheseProposals(jpqlQuery, position, LOCATE);
    }

    @Test
    public final void test_Locate_10() {
        String jpqlQuery = "SELECT e FROM Employee e WHERE (L";
        int position = jpqlQuery.length();
        testHasTheseProposals(jpqlQuery, position, LOCATE);
    }

    @Test
    public final void test_Locate_11() {
        String jpqlQuery = "SELECT e FROM Employee e WHERE (LO";
        int position = jpqlQuery.length();
        testHasTheseProposals(jpqlQuery, position, LOCATE);
    }

    @Test
    public final void test_Locate_12() {
        String jpqlQuery = "SELECT e FROM Employee e WHERE (LOC";
        int position = jpqlQuery.length();
        testHasTheseProposals(jpqlQuery, position, LOCATE);
    }

    @Test
    public final void test_Locate_13() {
        String jpqlQuery = "SELECT e FROM Employee e WHERE (LOCA";
        int position = jpqlQuery.length();
        testHasTheseProposals(jpqlQuery, position, LOCATE);
    }

    @Test
    public final void test_Locate_14() {
        String jpqlQuery = "SELECT e FROM Employee e WHERE (LOCAT";
        int position = jpqlQuery.length();
        testHasTheseProposals(jpqlQuery, position, LOCATE);
    }

    @Test
    public final void test_Locate_15() {
        String jpqlQuery = "SELECT e FROM Employee e WHERE (LOCATE";
        int position = jpqlQuery.length();
        testHasTheseProposals(jpqlQuery, position, LOCATE);
    }

    @Test
    public final void test_Locate_16() {
        String jpqlQuery = "SELECT e FROM Employee e WHERE (LOCATE)";
        int position = jpqlQuery.length() - 1;
        testHasTheseProposals(jpqlQuery, position, LOCATE);
    }

    @Test
    public final void test_Locate_17() {
        String jpqlQuery = "SELECT e FROM Employee e WHERE ()";
        int position = jpqlQuery.length() - 1;
        testHasTheseProposals(jpqlQuery, position, LOCATE);
    }

    @Test
    public final void test_Logical_01() {
        String jpqlQuery = "SELECT e FROM Employee e WHERE e.roomNumber BETWEEN 1 AND 3 ";
        int position = jpqlQuery.length();
        testHasTheseProposals(jpqlQuery, position, AND, OR);
    }

    @Test
    public final void test_Max_01() {
        String jpqlQuery = "SELECT ";
        int position = jpqlQuery.length();
        testHasTheseProposals(jpqlQuery, position, MAX);
    }

    @Test
    public final void test_Max_02() {
        String jpqlQuery = "SELECT M";
        int position = jpqlQuery.length();
        testHasTheseProposals(jpqlQuery, position, MAX);
    }

    @Test
    public final void test_Max_03() {
        String jpqlQuery = "SELECT MA";
        int position = jpqlQuery.length();
        testHasTheseProposals(jpqlQuery, position, MAX);
    }

    @Test
    public final void test_Max_04() {
        String jpqlQuery = "SELECT MAX";
        int position = jpqlQuery.length();
        testHasTheseProposals(jpqlQuery, position, MAX);
    }

    @Test
    public final void test_Max_05() {

        String jpqlQuery = "SELECT MAX(";
        int position = jpqlQuery.length();

        List<String> proposals = new ArrayList<>();
        proposals.add(DISTINCT);
        CollectionTools.addAll(proposals, bnfAccessor.internalAggregateFunctionFunctions());

        testHasOnlyTheseProposals(jpqlQuery, position, proposals);
    }

    @Test
    public final void test_Max_06() {

        String jpqlQuery = "SELECT MAX() From Employee e";
        int position = "SELECT MAX(".length();

        List<String> proposals = new ArrayList<>();
        proposals.add("e");
        proposals.add(DISTINCT);
        CollectionTools.addAll(proposals, bnfAccessor.internalAggregateFunctionFunctions());

        testHasOnlyTheseProposals(jpqlQuery, position, proposals);
    }

    @Test
    public final void test_Max_07() {

        String jpqlQuery = "SELECT MAX(DISTINCT ) From Employee e";
        int position = "SELECT MAX(DISTINCT ".length();

        List<String> proposals = new ArrayList<>();
        proposals.add("e");
        CollectionTools.addAll(proposals, bnfAccessor.internalAggregateFunctionFunctions());

        testHasOnlyTheseProposals(jpqlQuery, position, proposals);
    }

    @Test
    public final void test_Max_08() {
        String jpqlQuery = "SELECT MAX(D ) From Employee e";
        int position = "SELECT MAX(D".length();
        testHasOnlyTheseProposals(jpqlQuery, position, DISTINCT);
    }

    @Test
    public final void test_Max_09() {
        String jpqlQuery = "SELECT MAX(DI ) From Employee e";
        int position = "SELECT MAX(DI".length();
        testHasOnlyTheseProposals(jpqlQuery, position, DISTINCT);
    }

    @Test
    public final void test_Max_10() {
        String jpqlQuery = "SELECT MAX(DIS ) From Employee e";
        int position = "SELECT MAX(DIS".length();
        testHasOnlyTheseProposals(jpqlQuery, position, DISTINCT);
    }

    @Test
    public final void test_Max_11() {
        String jpqlQuery = "SELECT MAX(DISTINCT e) From Employee e";
        int position = "SELECT MAX(".length();
        testHasOnlyTheseProposals(jpqlQuery, position, DISTINCT);
    }

    @Test
    public final void test_Max_12() {
        String jpqlQuery = "SELECT MAX(DISTINCT e) From Employee e";
        int position = "SELECT MAX(D".length();
        testHasOnlyTheseProposals(jpqlQuery, position, DISTINCT);
    }

    @Test
    public final void test_Max_13() {
        String jpqlQuery = "SELECT MAX(DISTINCT e) From Employee e";
        int position = "SELECT MAX(DI".length();
        testHasOnlyTheseProposals(jpqlQuery, position, DISTINCT);
    }

    @Test
    public final void test_Max_14() {

        String jpqlQuery = "SELECT MAX(DISTINCT e) From Employee e";
        int position = "SELECT MAX(DISTINCT ".length();

        List<String> proposals = new ArrayList<>();
        proposals.add("e");
        CollectionTools.addAll(proposals, bnfAccessor.internalAggregateFunctionFunctions());

        testHasOnlyTheseProposals(jpqlQuery, position, proposals);
    }

    @Test
    public final void test_Max_15() {

        String jpqlQuery = "SELECT MAX(DISTINCT e) From Employee e";
        int position = "SELECT MAX(DISTINCT e".length();

        List<String> proposals = new ArrayList<>();
        proposals.add("e");
        CollectionTools.addAll(proposals, filter(bnfAccessor.internalAggregateFunctionFunctions(), "e"));

        testHasOnlyTheseProposals(jpqlQuery, position, proposals);
    }

    @Test
    public final void test_Max_16() {

        String jpqlQuery = "SELECT MAX(DISTINCT e) From Employee emp";
        int position = "SELECT MAX(DISTINCT e".length();

        List<String> proposals = new ArrayList<>();
        proposals.add("emp");
        CollectionTools.addAll(proposals, filter(bnfAccessor.internalAggregateFunctionFunctions(), "e"));

        testHasOnlyTheseProposals(jpqlQuery, position, proposals);
    }

    @Test
    public final void test_Max_17() {

        String jpqlQuery = "SELECT MAX() From Employee emp";
        int position = "SELECT MAX(".length();

        List<String> proposals = new ArrayList<>();
        proposals.add("emp");
        proposals.add(DISTINCT);
        CollectionTools.addAll(proposals, bnfAccessor.internalAggregateFunctionFunctions());

        testHasOnlyTheseProposals(jpqlQuery, position, proposals);
    }

    @Test
    public final void test_Max_18() {

        String jpqlQuery = "SELECT MAX(e) From Employee emp";
        int position = "SELECT MAX(e".length();

        List<String> proposals = new ArrayList<>();
        proposals.add("emp");
        CollectionTools.addAll(proposals, filter(bnfAccessor.internalAggregateFunctionFunctions(), "e"));

        testHasOnlyTheseProposals(jpqlQuery, position, proposals);
    }

    @Test
    public final void test_Max_19() {
        String jpqlQuery = "SELECT MAX(em) From Employee emp";
        int position = "SELECT MAX(em".length();
        testHasOnlyTheseProposals(jpqlQuery, position, "emp");
    }

    @Test
    public final void test_Max_20() {
        String jpqlQuery = "SELECT MAX(emp) From Employee emp";
        int position = "SELECT MAX(emp".length();
        testHasOnlyTheseProposals(jpqlQuery, position, "emp");
    }

    @Test
    public final void test_Max_21() {

        String jpqlQuery = "SELECT MAX(emp) From Employee emp";
        int position = "SELECT MAX(e".length();

        List<String> proposals = new ArrayList<>();
        proposals.add("emp");
        CollectionTools.addAll(proposals, filter(bnfAccessor.internalAggregateFunctionFunctions(), "e"));

        testHasOnlyTheseProposals(jpqlQuery, position, proposals);
    }

    @Test
    public final void test_Max_22() {
        String jpqlQuery = "SELECT MAX(emp) From Employee emp";
        int position = "SELECT MAX(em".length();
        testHasOnlyTheseProposals(jpqlQuery, position, "emp");
    }

    @Test
    public final void test_Max_23() {

        String jpqlQuery = "SELECT MAX( From Employee emp";
        int position = "SELECT MAX(".length();

        List<String> proposals = new ArrayList<>();
        proposals.add("emp");
        proposals.add(DISTINCT);
        CollectionTools.addAll(proposals, bnfAccessor.internalAggregateFunctionFunctions());

        testHasOnlyTheseProposals(jpqlQuery, position, proposals);
    }

    @Test
    public final void test_Max_24() {

        String jpqlQuery = "SELECT MAX(e From Employee emp";
        int position = "SELECT MAX(e".length();

        List<String> proposals = new ArrayList<>();
        proposals.add("emp");
        CollectionTools.addAll(proposals, filter(bnfAccessor.internalAggregateFunctionFunctions(), "e"));

        testHasOnlyTheseProposals(jpqlQuery, position, proposals);
    }

    @Test
    public final void test_Min_01() {
        String jpqlQuery = "SELECT ";
        int position = jpqlQuery.length();
        testHasTheseProposals(jpqlQuery, position, MIN);
    }

    @Test
    public final void test_Min_02() {
        String jpqlQuery = "SELECT M";
        int position = jpqlQuery.length();
        testHasTheseProposals(jpqlQuery, position, MIN);
    }

    @Test
    public final void test_Min_03() {
        String jpqlQuery = "SELECT MI";
        int position = jpqlQuery.length();
        testHasTheseProposals(jpqlQuery, position, MIN);
    }

    @Test
    public final void test_Min_04() {
        String jpqlQuery = "SELECT MIN";
        int position = jpqlQuery.length();
        testHasTheseProposals(jpqlQuery, position, MIN);
    }

    @Test
    public final void test_Min_05() {

        String jpqlQuery = "SELECT MIN(";
        int position = jpqlQuery.length();

        List<String> proposals = new ArrayList<>();
        proposals.add(DISTINCT);
        CollectionTools.addAll(proposals, bnfAccessor.internalAggregateFunctionFunctions());

        testHasOnlyTheseProposals(jpqlQuery, position, proposals);
    }

    @Test
    public final void test_Min_06() {

        String jpqlQuery = "SELECT MIN() From Employee e";
        int position = "SELECT MIN(".length();

        List<String> proposals = new ArrayList<>();
        proposals.add("e");
        proposals.add(DISTINCT);
        CollectionTools.addAll(proposals, bnfAccessor.internalAggregateFunctionFunctions());

        testHasOnlyTheseProposals(jpqlQuery, position, proposals);
    }

    @Test
    public final void test_Min_07() {

        String jpqlQuery = "SELECT MIN(DISTINCT ) From Employee e";
        int position = "SELECT MIN(DISTINCT ".length();

        List<String> proposals = new ArrayList<>();
        proposals.add("e");
        CollectionTools.addAll(proposals, bnfAccessor.internalAggregateFunctionFunctions());

        testHasOnlyTheseProposals(jpqlQuery, position, proposals);
    }

    @Test
    public final void test_Min_08() {
        String jpqlQuery = "SELECT MIN(D ) From Employee e";
        int position = "SELECT MIN(D".length();
        testHasOnlyTheseProposals(jpqlQuery, position, DISTINCT);
    }

    @Test
    public final void test_Min_09() {
        String jpqlQuery = "SELECT MIN(DI ) From Employee e";
        int position = "SELECT MIN(DI".length();
        testHasOnlyTheseProposals(jpqlQuery, position, DISTINCT);
    }

    @Test
    public final void test_Min_10() {
        String jpqlQuery = "SELECT MIN(DIS ) From Employee e";
        int position = "SELECT MIN(DIS".length();
        testHasOnlyTheseProposals(jpqlQuery, position, DISTINCT);
    }

    @Test
    public final void test_Min_11() {
        String jpqlQuery = "SELECT MIN(DISTINCT e) From Employee e";
        int position = "SELECT MIN(".length();
        testHasOnlyTheseProposals(jpqlQuery, position, DISTINCT);
    }

    @Test
    public final void test_Min_12() {
        String jpqlQuery = "SELECT MIN(DISTINCT e) From Employee e";
        int position = "SELECT MIN(D".length();
        testHasOnlyTheseProposals(jpqlQuery, position, DISTINCT);
    }

    @Test
    public final void test_Min_13() {
        String jpqlQuery = "SELECT MIN(DISTINCT e) From Employee e";
        int position = "SELECT MIN(DI".length();
        testHasOnlyTheseProposals(jpqlQuery, position, DISTINCT);
    }

    @Test
    public final void test_Min_14() {

        String jpqlQuery = "SELECT MIN(DISTINCT e) From Employee e";
        int position = "SELECT MIN(DISTINCT ".length();

        List<String> proposals = new ArrayList<>();
        proposals.add("e");
        CollectionTools.addAll(proposals, bnfAccessor.internalAggregateFunctionFunctions());

        testHasOnlyTheseProposals(jpqlQuery, position, proposals);
    }

    @Test
    public final void test_Min_15() {

        String jpqlQuery = "SELECT MIN(DISTINCT e) From Employee e";
        int position = "SELECT MIN(DISTINCT e".length();

        List<String> proposals = new ArrayList<>();
        proposals.add("e");
        CollectionTools.addAll(proposals, filter(bnfAccessor.internalAggregateFunctionFunctions(), "e"));

        testHasOnlyTheseProposals(jpqlQuery, position, proposals);
    }

    @Test
    public final void test_Min_16() {

        String jpqlQuery = "SELECT MIN(DISTINCT e) From Employee emp";
        int position = "SELECT MIN(DISTINCT e".length();

        List<String> proposals = new ArrayList<>();
        proposals.add("emp");
        CollectionTools.addAll(proposals, filter(bnfAccessor.internalAggregateFunctionFunctions(), "e"));

        testHasOnlyTheseProposals(jpqlQuery, position, proposals);
    }

    @Test
    public final void test_Min_17() {

        String jpqlQuery = "SELECT MIN() From Employee emp";
        int position = "SELECT MIN(".length();

        List<String> proposals = new ArrayList<>();
        proposals.add("emp");
        proposals.add(DISTINCT);
        CollectionTools.addAll(proposals, bnfAccessor.internalAggregateFunctionFunctions());

        testHasOnlyTheseProposals(jpqlQuery, position, proposals);
    }

    @Test
    public final void test_Min_18() {

        String jpqlQuery = "SELECT MIN(e) From Employee emp";
        int position = "SELECT MIN(e".length();

        List<String> proposals = new ArrayList<>();
        proposals.add("emp");
        CollectionTools.addAll(proposals, filter(bnfAccessor.internalAggregateFunctionFunctions(), "e"));

        testHasOnlyTheseProposals(jpqlQuery, position, proposals);
    }

    @Test
    public final void test_Min_19() {
        String jpqlQuery = "SELECT MIN(em) From Employee emp";
        int position = "SELECT MIN(em".length();
        testHasOnlyTheseProposals(jpqlQuery, position, "emp");
    }

    @Test
    public final void test_Min_20() {
        String jpqlQuery = "SELECT MIN(emp) From Employee emp";
        int position = "SELECT MIN(emp".length();
        testHasOnlyTheseProposals(jpqlQuery, position, "emp");
    }

    @Test
    public final void test_Min_21() {

        String jpqlQuery = "SELECT MIN(emp) From Employee emp";
        int position = "SELECT MIN(e".length();

        List<String> proposals = new ArrayList<>();
        proposals.add("emp");
        CollectionTools.addAll(proposals, filter(bnfAccessor.internalAggregateFunctionFunctions(), "e"));

        testHasOnlyTheseProposals(jpqlQuery, position, proposals);
    }

    @Test
    public final void test_Min_22() {
        String jpqlQuery = "SELECT MIN(emp) From Employee emp";
        int position = "SELECT MIN(em".length();
        testHasOnlyTheseProposals(jpqlQuery, position, "emp");
    }

    @Test
    public final void test_Min_23() {

        String jpqlQuery = "SELECT MIN( From Employee emp";
        int position = "SELECT MIN(".length();

        List<String> proposals = new ArrayList<>();
        proposals.add("emp");
        proposals.add(DISTINCT);
        CollectionTools.addAll(proposals, bnfAccessor.internalAggregateFunctionFunctions());

        testHasOnlyTheseProposals(jpqlQuery, position, proposals);
    }

    @Test
    public final void test_Min_24() {

        String jpqlQuery = "SELECT MIN(e From Employee emp";
        int position = "SELECT MIN(e".length();

        List<String> proposals = new ArrayList<>();
        proposals.add("emp");
        CollectionTools.addAll(proposals, filter(bnfAccessor.internalAggregateFunctionFunctions(), "e"));

        testHasOnlyTheseProposals(jpqlQuery, position, proposals);
    }

    @Test
    public final void test_NullComparison_01() {
        String jpqlQuery = "SELECT e FROM Employee e WHERE ";
        int position = jpqlQuery.length();
        testDoesNotHaveTheseProposals(jpqlQuery, position, IS_NULL, IS_NOT_NULL);
    }

    @Test
    public final void test_NullComparison_02() {
        String jpqlQuery = "SELECT e FROM Employee e WHERE e.name ";
        int position = jpqlQuery.length();
        testHasTheseProposals(jpqlQuery, position, IS_NULL, IS_NOT_NULL);
    }

    @Test
    public final void test_NullComparison_03() {
        String jpqlQuery = "SELECT e FROM Employee e WHERE e.name I";
        int position = jpqlQuery.length();
        testHasTheseProposals(jpqlQuery, position, IS_NULL, IS_NOT_NULL);
    }

    @Test
    public final void test_NullComparison_04() {
        String jpqlQuery = "SELECT e FROM Employee e WHERE e.name IS";
        int position = jpqlQuery.length();
        testHasTheseProposals(jpqlQuery, position, IS_NULL, IS_NOT_NULL);
    }

    @Test
    public final void test_NullComparison_05() {
        String jpqlQuery = "SELECT e FROM Employee e WHERE e.name IS ";
        int position = jpqlQuery.length();
        testHasTheseProposals(jpqlQuery, position, IS_NULL, IS_NOT_NULL);
    }

    @Test
    public final void test_NullComparison_06() {
        String jpqlQuery = "SELECT e FROM Employee e WHERE e.name IS N";
        int position = jpqlQuery.length();
        testHasTheseProposals(jpqlQuery, position, IS_NULL, IS_NOT_NULL);
    }

    @Test
    public final void test_NullComparison_07() {
        String jpqlQuery = "SELECT e FROM Employee e WHERE e.name IS NO";
        int position = jpqlQuery.length();
        testHasOnlyTheseProposals(jpqlQuery, position, IS_NOT_NULL);
    }

    @Test
    public final void test_NullComparison_08() {
        String jpqlQuery = "SELECT e FROM Employee e WHERE e.name IS NOT";
        int position = jpqlQuery.length();
        testHasOnlyTheseProposals(jpqlQuery, position, IS_NOT_NULL);
    }

    @Test
    public final void test_NullComparison_09() {
        String jpqlQuery = "SELECT e FROM Employee e WHERE e.name IS NOT N";
        int position = jpqlQuery.length();
        testHasOnlyTheseProposals(jpqlQuery, position, IS_NOT_NULL);
    }

    @Test
    public final void test_NullComparison_10() {
        String jpqlQuery = "SELECT e FROM Employee e WHERE e.name IS NOT NU";
        int position = jpqlQuery.length();
        testHasOnlyTheseProposals(jpqlQuery, position, IS_NOT_NULL);
    }

    @Test
    public final void test_NullComparison_11() {
        String jpqlQuery = "SELECT e FROM Employee e WHERE e.name IS NOT NUL";
        int position = jpqlQuery.length();
        testHasOnlyTheseProposals(jpqlQuery, position, IS_NOT_NULL);
    }

    @Test
    public final void test_NullComparison_12() {
        String jpqlQuery = "SELECT e FROM Employee e WHERE e.name IS NOT NULL";
        int position = jpqlQuery.length();
        testHasOnlyTheseProposals(jpqlQuery, position, IS_NULL, IS_NOT_NULL);
    }

    @Test
    public final void test_Object_01() {
        String jpqlQuery = "SELECT O FROM Employee e";
        int position = "SELECT O".length() - 1;
        testHasTheseProposals(jpqlQuery, position, OBJECT);
    }

    @Test
    public final void test_Object_02() {
        String jpqlQuery = "SELECT OB FROM Employee e";
        int position = "SELECT O".length();
        testHasTheseProposals(jpqlQuery, position, OBJECT);
    }

    @Test
    public final void test_Object_03() {
        String jpqlQuery = "SELECT OBJ FROM Employee e";
        int position = "SELECT O".length();
        testHasTheseProposals(jpqlQuery, position, OBJECT);
    }

    @Test
    public final void test_Object_04() {
        String jpqlQuery = "SELECT OBJE FROM Employee e";
        int position = "SELECT O".length();
        testHasTheseProposals(jpqlQuery, position, OBJECT);
    }

    @Test
    public final void test_Object_05() {
        String jpqlQuery = "SELECT OBJEC FROM Employee e";
        int position = "SELECT O".length();
        testHasTheseProposals(jpqlQuery, position, OBJECT);
    }

    @Test
    public final void test_Object_12() {
        String jpqlQuery = "SELECT OBJECT";
        testHasTheseProposals(jpqlQuery, jpqlQuery.length(), OBJECT);
    }

    @Test
    public final void test_Object_13() {
        String jpqlQuery = "SELECT ";
        int position = jpqlQuery.length();
        testHasTheseProposals(jpqlQuery, position, OBJECT);
    }

    @Test
    public final void test_Object_14() {
        String jpqlQuery = "SELECT O";
        int position = jpqlQuery.length();
        testHasTheseProposals(jpqlQuery, position, OBJECT);
    }

    @Test
    public final void test_Object_15() {
        String jpqlQuery = "SELECT OB";
        int position = jpqlQuery.length();
        testHasTheseProposals(jpqlQuery, position, OBJECT);
    }

    @Test
    public final void test_Object_16() {
        String jpqlQuery = "SELECT OBJ";
        int position = jpqlQuery.length();
        testHasTheseProposals(jpqlQuery, position, OBJECT);
    }

    @Test
    public final void test_Object_17() {
        String jpqlQuery = "SELECT OBJE";
        int position = jpqlQuery.length();
        testHasTheseProposals(jpqlQuery, position, OBJECT);
    }

    @Test
    public final void test_Object_18() {
        String jpqlQuery = "SELECT OBJEC";
        int position = jpqlQuery.length();
        testHasTheseProposals(jpqlQuery, position, OBJECT);
    }

    @Test
    public final void test_Object_19() {
        String jpqlQuery = "SELECT OBJECT";
        int position = jpqlQuery.length();
        testHasTheseProposals(jpqlQuery, position, OBJECT);
    }

    @Test
    public final void test_Object_20() {
        String jpqlQuery = "SELECT DISTINCT OBJECT(a) FROM Address a";
        int position = "SELECT DISTINCT OBJECT(a".length();
        testHasOnlyTheseProposals(jpqlQuery, position, "a");
    }

    @Test
    public final void test_OptionalClauses_01() {

        String jpqlQuery = "SELECT e FROM Employee e ";
        int position = jpqlQuery.length();

        List<String> proposals = new ArrayList<>();
        CollectionTools.addAll(proposals, fromClauseInternalClauses(FROM));
        CollectionTools.addAll(proposals, clauses(FROM, null, false));

        testHasOnlyTheseProposals(jpqlQuery, position, proposals);
    }

    @Test
    public final void test_OptionalClauses_02() {

        String jpqlQuery = "SELECT e FROM Employee e HAVING e.name = 'Oracle'";
        int position = "SELECT e FROM Employee e ".length();

        List<String> proposals = new ArrayList<>();
        CollectionTools.addAll(proposals, fromClauseInternalClauses(FROM));
        CollectionTools.addAll(proposals, clauses(FROM, ORDER_BY, false));

        testHasOnlyTheseProposals(jpqlQuery, position, proposals);
    }

    @Test
    public final void test_OptionalClauses_03() {

        String jpqlQuery = "SELECT e FROM Employee e ORDER BY e.name";
        int position = "SELECT e FROM Employee e ".length();

        List<String> proposals = new ArrayList<>();
        proposals.add(ORDER_BY);
        CollectionTools.addAll(proposals, fromClauseInternalClauses(FROM));
        CollectionTools.addAll(proposals, clauses(FROM, ORDER_BY, false));

        testHasOnlyTheseProposals(jpqlQuery, position, proposals);
    }

    @Test
    public final void test_OptionalClauses_04() {

        String jpqlQuery = "SELECT e FROM Employee e GROUP BY e.name";
        int position = "SELECT e FROM Employee e ".length();

        List<String> proposals = new ArrayList<>();
        CollectionTools.addAll(proposals, fromClauseInternalClauses(FROM));
        CollectionTools.addAll(proposals, clauses(FROM, HAVING, false));

        testHasOnlyTheseProposals(jpqlQuery, position, proposals);
    }

    @Test
    public final void test_OptionalClauses_05() {

        String jpqlQuery = "SELECT e FROM Employee e WHERE e.name = 'Oracle' ";
        int position = jpqlQuery.length();

        List<String> proposals = new ArrayList<>();
        CollectionTools.addAll(proposals, bnfAccessor.logicalIdentifiers());
        CollectionTools.addAll(proposals, clauses(WHERE, null, false));

        testHasOnlyTheseProposals(jpqlQuery, position, proposals);
    }

    @Test
    public final void test_OptionalClauses_06() {

        String jpqlQuery = "SELECT e FROM Employee e A";
        int position = jpqlQuery.length();

        List<String> proposals = new ArrayList<>();
        CollectionTools.addAll(proposals, filter(fromClauseInternalClauses(FROM), "A"));
        CollectionTools.addAll(proposals, filter(clauses(FROM, null, false), "A"));

        testHasOnlyTheseProposals(jpqlQuery, position, proposals);
    }

    @Test
    public final void test_OptionalClauses_07() {
        String jpqlQuery = "SELECT e FROM Employee e";
        int position = jpqlQuery.length();
        testHasNoProposals(jpqlQuery, position);
    }

    @Test
    public final void test_OrderBy_01() {
        String jpqlQuery = "SELECT e FROM Employee e ";
        int position = jpqlQuery.length();
        testHasTheseProposals(jpqlQuery, position, ORDER_BY);
    }

    @Test
    public final void test_OrderBy_02() {
        String jpqlQuery = "SELECT e FROM Employee e O";
        int position = jpqlQuery.length();
        testHasTheseProposals(jpqlQuery, position, ORDER_BY);
    }

    @Test
    public final void test_OrderBy_03() {
        String jpqlQuery = "SELECT e FROM Employee e OR";
        int position = jpqlQuery.length();
        testHasTheseProposals(jpqlQuery, position, ORDER_BY);
    }

    @Test
    public final void test_OrderBy_04() {
        String jpqlQuery = "SELECT e FROM Employee e ORD";
        int position = jpqlQuery.length();
        testHasTheseProposals(jpqlQuery, position, ORDER_BY);
    }

    @Test
    public final void test_OrderBy_05() {
        String jpqlQuery = "SELECT e FROM Employee e ORDE";
        int position = jpqlQuery.length();
        testHasTheseProposals(jpqlQuery, position, ORDER_BY);
    }

    @Test
    public final void test_OrderBy_06() {
        String jpqlQuery = "SELECT e FROM Employee e ORDER";
        int position = jpqlQuery.length();
        testHasTheseProposals(jpqlQuery, position, ORDER_BY);
    }

    @Test
    public final void test_OrderBy_07() {
        String jpqlQuery = "SELECT e FROM Employee e ORDER ";
        int position = jpqlQuery.length();
        testHasTheseProposals(jpqlQuery, position, ORDER_BY);
    }

    @Test
    public final void test_OrderBy_08() {
        String jpqlQuery = "SELECT e FROM Employee e ORDER B";
        int position = jpqlQuery.length();
        testHasTheseProposals(jpqlQuery, position, ORDER_BY);
    }

    @Test
    public final void test_OrderBy_09() {
        String jpqlQuery = "SELECT e FROM Employee e ORDER BY";
        int position = jpqlQuery.length();
        testHasOnlyTheseProposals(jpqlQuery, position, ORDER_BY);
    }

    @Test
    public final void test_OrderBy_10() {
        String jpqlQuery = "SELECT e FROM Employee e WHERE (e.name = 'Pascal') ";
        int position = jpqlQuery.length();
        testHasTheseProposals(jpqlQuery, position, ORDER_BY);
    }

    @Test
    public final void test_OrderBy_11() {
        String jpqlQuery = "SELECT e FROM Employee e WHERE (e.name = 'Pascal') O";
        int position = jpqlQuery.length();
        testHasTheseProposals(jpqlQuery, position, ORDER_BY);
    }

    @Test
    public final void test_OrderBy_12() {
        String jpqlQuery = "SELECT e FROM Employee e GROUP BY e.name ";
        int position = jpqlQuery.length();
        testHasTheseProposals(jpqlQuery, position, ORDER_BY);
    }

    @Test
    public final void test_OrderBy_13() {
        String jpqlQuery = "SELECT e FROM Employee e GROUP BY e.name O";
        int position = jpqlQuery.length();
        testHasTheseProposals(jpqlQuery, position, ORDER_BY);
    }

    @Test
    public final void test_OrderBy_14() {
        String jpqlQuery = "SELECT e FROM Employee e HAVING COUNT(e) >= 5 ";
        int position = jpqlQuery.length();
        testHasTheseProposals(jpqlQuery, position, ORDER_BY);
    }

    @Test
    public final void test_OrderBy_15() {
        String jpqlQuery = "SELECT e FROM Employee e HAVING COUNT(e) >= 5 O";
        int position = jpqlQuery.length();
        testHasTheseProposals(jpqlQuery, position, ORDER_BY);
    }

    @Test
    public final void test_OrderBy_16() {
        String jpqlQuery = "SELECT e FROM Employee e WHERE (e.name = 'Pascal') GROUP BY e.name ";
        int position = jpqlQuery.length();
        testHasTheseProposals(jpqlQuery, position, ORDER_BY);
    }

    @Test
    public final void test_OrderBy_17() {
        String jpqlQuery = "SELECT e FROM Employee e WHERE (e.name = 'Pascal') GROUP BY e.name O";
        int position = jpqlQuery.length();
        testHasTheseProposals(jpqlQuery, position, ORDER_BY);
    }

    @Test
    public final void test_OrderBy_18() {
        String jpqlQuery = "SELECT e FROM Employee e WHERE (e.name = 'Pascal') GROUP BY e.name HAVING COUNT(e) >= 5 ";
        int position = jpqlQuery.length();
        testHasTheseProposals(jpqlQuery, position, ORDER_BY);
    }

    @Test
    public final void test_OrderBy_19() {
        String jpqlQuery = "SELECT e FROM Employee e WHERE (e.name = 'Pascal') GROUP BY e.name HAVING COUNT(e) >= 5 O";
        int position = jpqlQuery.length();
        testHasTheseProposals(jpqlQuery, position, ORDER_BY);
    }

    @Test
    public final void test_OrderByItem_01() {
        String jpqlQuery = "SELECT e FROM Employee e ORDER BY e.name";
        int position = jpqlQuery.length();
        testDoesNotHaveTheseProposals(jpqlQuery, position, ASC);
    }

    @Test
    public final void test_OrderByItem_02() {
        String jpqlQuery = "SELECT e FROM Employee e ORDER BY e.name ";
        int position = jpqlQuery.length();
        testHasTheseProposals(jpqlQuery, position, ASC);
    }

    @Test
    public final void test_OrderByItem_03() {
        String jpqlQuery = "SELECT e FROM Employee e ORDER BY e.name A";
        int position = jpqlQuery.length();
        testHasTheseProposals(jpqlQuery, position, ASC);
    }

    @Test
    public final void test_OrderByItem_04() {
        String jpqlQuery = "SELECT e FROM Employee e ORDER BY e.name AS";
        int position = jpqlQuery.length();
        testHasTheseProposals(jpqlQuery, position, ASC);
    }

    @Test
    public final void test_OrderByItem_05() {
        String jpqlQuery = "SELECT e FROM Employee e ORDER BY e.name ASC";
        int position = jpqlQuery.length();
        testHasOnlyTheseProposals(jpqlQuery, position, ASC, DESC);
    }

    @Test
    public final void test_OrderByItem_06() {
        String jpqlQuery = "SELECT e FROM Employee e ORDER BY e.name D";
        int position = jpqlQuery.length();
        testHasTheseProposals(jpqlQuery, position, DESC);
    }

    @Test
    public final void test_OrderByItem_07() {
        String jpqlQuery = "SELECT e FROM Employee e ORDER BY e.name DE";
        int position = jpqlQuery.length();
        testHasTheseProposals(jpqlQuery, position, DESC);
    }

    @Test
    public final void test_OrderByItem_08() {
        String jpqlQuery = "SELECT e FROM Employee e ORDER BY e.name DE";
        int position = jpqlQuery.length();
        testHasTheseProposals(jpqlQuery, position, DESC);
    }

    @Test
    public final void test_OrderByItem_09() {
        String jpqlQuery = "SELECT e FROM Employee e ORDER BY e.name DESC";
        int position = jpqlQuery.length();
        testHasOnlyTheseProposals(jpqlQuery, position, ASC, DESC);
    }

    @Test
    public final void test_Query_01() {
        String jpqlQuery = ExpressionTools.EMPTY_STRING;
        int position = 0;
        testHasOnlyTheseProposals(jpqlQuery, position, SELECT, UPDATE, DELETE_FROM);
    }

    @Test
    public final void test_Query_02() {
        String jpqlQuery = "SELECT e FROM Employee e WHERE e.name SEL";
        int position = jpqlQuery.length();
        testDoesNotHaveTheseProposals(jpqlQuery, position, SELECT, UPDATE, DELETE_FROM);
    }

    @Test
    public final void test_Query_03() {
        String jpqlQuery = "SELECT e FROM Employee e WHERE e.name DEL";
        int position = jpqlQuery.length();
        testDoesNotHaveTheseProposals(jpqlQuery, position, SELECT, UPDATE, DELETE_FROM);
    }

    @Test
    public final void test_Query_04() {
        String jpqlQuery = "SELECT e FROM Employee e WHERE e.name UP";
        int position = jpqlQuery.length();
        testDoesNotHaveTheseProposals(jpqlQuery, position, SELECT, UPDATE, DELETE_FROM);
    }

    @Test
    public final void test_Restriction_01() {

        String jpqlQuery = "SELECT AVG(e.name) FROM Employee e";
        int position = "SELECT AVG(".length();

        List<String> proposals = new ArrayList<>();
        proposals.add("e");
        proposals.add(DISTINCT);
        CollectionTools.addAll(proposals, bnfAccessor.internalAggregateFunctionFunctions());

        testHasOnlyTheseProposals(jpqlQuery, position, proposals);
    }

    @Test
    public final void test_Restriction_02() {

        String jpqlQuery = "SELECT AVG(e.name) FROM Employee e";
        int position = "SELECT AVG(e".length();

        List<String> proposals = new ArrayList<>();
        CollectionTools.addAll(proposals, filter(bnfAccessor.internalAggregateFunctionFunctions(), "e"));

        List<String> selectProposals = new ArrayList<>();
        CollectionTools.addAll(selectProposals, filter(bnfAccessor.selectItemIdentifiers(), "e"));
        selectProposals.removeAll(proposals);

        testDoesNotHaveTheseProposals(jpqlQuery, position, selectProposals);
    }

    @Test
    public final void test_Restriction_03() {
        String jpqlQuery = "SELECT AVG(e.name) FROM Employee e";
        int position = "SELECT AVG(e.".length();
        testDoesNotHaveTheseProposals(jpqlQuery, position, bnfAccessor.selectItemIdentifiers());
    }

    @Test
    public final void test_Restriction_04() {
        String jpqlQuery = "SELECT o FROM Countries AS o";
        int position = jpqlQuery.length();
        testDoesNotHaveTheseProposals(jpqlQuery, position, ORDER_BY);
    }

    @Test
    public final void test_ResultVariable_01() {
        String jpqlQuery = "SELECT ABS(a.city)  FROM Address AS a";
        int position = "SELECT ABS(a.city) ".length();
        testHasTheseProposals(jpqlQuery, position, AS);
    }

    @Test
    public final void test_ResultVariable_02() {
        String jpqlQuery = "SELECT ABS(a.city) AS FROM Address AS a";
        int position = "SELECT ABS(a.city) A ".length();
        testHasOnlyTheseProposals(jpqlQuery, position, AS);
    }

    @Test
    public final void test_ResultVariable_03() {
        String jpqlQuery = "SELECT ABS(a.city) AS FROM Address AS a";
        int position = "SELECT ABS(a.city) AS".length();
        testHasOnlyTheseProposals(jpqlQuery, position, AS);
    }

    @Test
    public final void test_ResultVariable_04() {
        String jpqlQuery = "SELECT ABS(a.city) AS FROM Address AS a";
        int position = "SELECT ABS(a.city) AS ".length();
        testHasNoProposals(jpqlQuery, position);
    }

    @Test
    public final void test_ResultVariable_05() {

        String jpqlQuery = "SELECT AS FROM Address AS a";
        int position = "SELECT ".length();

        List<String> proposals = new ArrayList<>();
        proposals.add(DISTINCT);
        proposals.add("a");
        CollectionTools.addAll(proposals, bnfAccessor.selectItemFunctions());

        testHasOnlyTheseProposals(jpqlQuery, position, proposals);
    }

    @Test
    public final void test_ResultVariable_06() {

        String jpqlQuery = "SELECT AS FROM Address AS a";
        int position = "SELECT A".length();

        List<String> proposals = new ArrayList<>();
        proposals.add("a");
        CollectionTools.addAll(proposals, filter(bnfAccessor.selectItemFunctions(), "A"));

        testHasOnlyTheseProposals(jpqlQuery, position, proposals);
    }

    @Test
    public final void test_ResultVariable_07() {
        String jpqlQuery = "SELECT AS FROM Address AS a";
        int position = "SELECT AS".length();
        testHasOnlyTheseProposals(jpqlQuery, position, filter(bnfAccessor.selectItemFunctions(), "AS"));
    }

    @Test
    public final void test_ResultVariable_08() {
        String jpqlQuery = "SELECT e a FROM Address AS a";
        int position = "SELECT e ".length();
        testHasOnlyTheseProposals(jpqlQuery, position, AS);
    }

    @Test
    public final void test_ResultVariable_09() {

        String jpqlQuery = "SELECT a.id FROM Address AS a";
        int position = "SELECT a.id ".length();

        List<String> proposals = new ArrayList<>();
        proposals.add(AS);
        proposals.add(FROM);
        CollectionTools.addAll(proposals, bnfAccessor.selectItemAggregates());

        testHasOnlyTheseProposals(jpqlQuery, position, proposals);
    }

    @Test
    public final void test_ResultVariable_10() {

        String jpqlQuery = "SELECT a.zipcode, a.id FROM Address AS a";
        int position = "SELECT a.zipcode, a.id ".length();

        List<String> proposals = new ArrayList<>();
        proposals.add(AS);
        proposals.add(FROM);
        CollectionTools.addAll(proposals, bnfAccessor.selectItemAggregates());

        testHasOnlyTheseProposals(jpqlQuery, position, proposals);
    }

    @Test
    @Ignore
    public final void test_ResultVariable_11() {

        String jpqlQuery = "SELECT a.zipcode , a.id FROM Address AS a";
        int position = "SELECT a.zipcode ".length();

        List<String> proposals = new ArrayList<>();
        proposals.add(AS);
        CollectionTools.addAll(proposals, bnfAccessor.selectItemAggregates());

        testHasOnlyTheseProposals(jpqlQuery, position, proposals);
    }

    @Test
    public final void test_ResultVariable_12() {

        String jpqlQuery = "SELECT (SELECT e From Employee e) FROM Address AS a";
        int position = "SELECT (SELECT e From Employee e) ".length();

        List<String> proposals = new ArrayList<>();
        proposals.add(AS);
        proposals.add(FROM);
        CollectionTools.addAll(proposals, bnfAccessor.selectItemAggregates());

        testHasOnlyTheseProposals(jpqlQuery, position, proposals);
    }

    @Test
    public final void test_Select_01() {

        String jpqlQuery = "SELECT ";
        int position = jpqlQuery.length();

        List<String> proposals = new ArrayList<>();
        proposals.add(DISTINCT);
        CollectionTools.addAll(proposals, bnfAccessor.selectItemFunctions());

        testHasOnlyTheseProposals(jpqlQuery, position, proposals);
    }

    @Test
    public final void test_Select_02() {

        String jpqlQuery = "SELECT e";
        int position = jpqlQuery.length();

        List<String> proposals = new ArrayList<>();
        CollectionTools.addAll(proposals, filter(bnfAccessor.selectItemFunctions(), "e"));

        testHasOnlyTheseProposals(jpqlQuery, position, proposals);
    }

    @Test
    public final void test_Select_03() {

        String jpqlQuery = "SELECT  FROM Employee e";
        int position = "SELECT ".length();

        List<String> proposals = new ArrayList<>();
        proposals.add(DISTINCT);
        proposals.add("e");
        CollectionTools.addAll(proposals, bnfAccessor.selectItemFunctions());

        testHasOnlyTheseProposals(jpqlQuery, position, proposals);
    }

    @Test
    public final void test_Select_04() {
        String jpqlQuery = "SELECT AV FROM Employee e";
        int position = "SELECT AV".length();
        testHasOnlyTheseProposals(jpqlQuery, position, AVG);
    }

    @Test
    public final void test_Select_05() {
        String jpqlQuery = "SELECT e,";
        int position = jpqlQuery.length();
        testHasOnlyTheseProposals(jpqlQuery, position, bnfAccessor.selectItemFunctions());
    }

    @Test
    public final void test_Select_06() {
        String jpqlQuery = "SELECT e, ";
        int position = jpqlQuery.length();
        testHasOnlyTheseProposals(jpqlQuery, position, bnfAccessor.selectItemFunctions());
    }

    @Test
    public final void test_Select_07() {

        String jpqlQuery = "SELECT AVG(e.age)  FROM Employee e";
        int position = "SELECT AVG(e.age) ".length();

        List<String> proposals = new ArrayList<>();
        proposals.add(AS);
        proposals.add(FROM);
        CollectionTools.addAll(proposals, bnfAccessor.selectItemAggregates());

        testHasOnlyTheseProposals(jpqlQuery, position, proposals);
    }

    @Test
    public final void test_Select_08() {

        String jpqlQuery = SELECT;

        for (int position = 1, count = jpqlQuery.length(); position < count; position++) {
            testHasOnlyTheseProposals(jpqlQuery, position, SELECT);
        }
    }

    @Test
    public final void test_SelectItem_01() {

        String jpqlQuery = "SELECT o,  FROM Address o";
        int position = "SELECT o, ".length();

        List<String> proposals = new ArrayList<>();
        proposals.add("o");
        CollectionTools.addAll(proposals, bnfAccessor.selectItemFunctions());

        testHasOnlyTheseProposals(jpqlQuery, position, proposals);
    }

    @Test
    public final void test_SelectItem_02() {
        String jpqlQuery = "SELECT O, CASE WHEN c.firstName = 'Pascal' THEN 'P' ELSE 'JPQL' END FROM Customer c";
        int position = "SELECT O".length();
        testHasOnlyTheseProposals(jpqlQuery, position, filter(bnfAccessor.selectItemIdentifiers(), "O"));
    }

    @Test
    public final void test_StateFieldPath_01() throws Exception {
        String jpqlQuery = "SELECT c. FROM CodeAssist c";
        int position = "SELECT c.".length();
        testHasOnlyTheseProposals(jpqlQuery, position, singledValuedObjectFieldNames(CodeAssist.class));
    }

    @Test
    public final void test_StateFieldPath_02() throws Exception {
        String jpqlQuery = "SELECT c.name FROM CodeAssist c";
        int position = "SELECT c.n".length();
        testHasOnlyTheseProposals(jpqlQuery, position, filter(singledValuedObjectFieldNames(CodeAssist.class), "n"));
    }

    @Test
    public final void test_StateFieldPath_03() throws Exception {
        String jpqlQuery = "SELECT c.name FROM CodeAssist c";
        int position = "SELECT c.name".length();
        testHasOnlyTheseProposals(jpqlQuery, position, filter(singledValuedObjectFieldNames(CodeAssist.class), "name"));
    }

    @Test
    public final void test_StateFieldPath_04() throws Exception {
        String jpqlQuery = "SELECT c.manager.name FROM CodeAssist c";
        int position = "SELECT c.m".length();
        testHasOnlyTheseProposals(jpqlQuery, position, filter(singledValuedObjectFieldNames(CodeAssist.class), "m"));
    }

    @Test
    public final void test_StateFieldPath_05() throws Exception {
        String jpqlQuery = "SELECT c.manager.name FROM CodeAssist c";
        int position = "SELECT c.manager".length();
        testHasOnlyTheseProposals(jpqlQuery, position, filter(singledValuedObjectFieldNames(CodeAssist.class), "manager"));
    }

    @Test
    public final void test_StateFieldPath_06() throws Exception {
        String jpqlQuery = "SELECT c.manager.name FROM CodeAssist c";
        int position = "SELECT c.manager.".length();
        testHasOnlyTheseProposals(jpqlQuery, position, singledValuedObjectFieldNames(Employee.class));
    }

    @Test
    public final void test_StateFieldPath_07() throws Exception {
        String jpqlQuery = "SELECT c.manager.name FROM CodeAssist c";
        int position = "SELECT c.manager.name".length();
        testHasOnlyTheseProposals(jpqlQuery, position, filter(singledValuedObjectFieldNames(Employee.class), "name"));
    }

    @Test
    public final void test_StateFieldPath_08() {
        String jpqlQuery = "SELECT c.employees. FROM CodeAssist c";
        int position = "SELECT c.employees.".length();
        testHasNoProposals(jpqlQuery, position);
    }

    @Test
    public final void test_StateFieldPath_09() throws Exception {
        String jpqlQuery = "SELECT e. FROM CodeAssist c JOIN c.employees e";
        int position = "SELECT e.".length();
        testHasOnlyTheseProposals(jpqlQuery, position, singledValuedObjectFieldNames(Employee.class));
    }

    @Test
    public final void test_StateFieldPath_10() throws Exception {
        String jpqlQuery = "SELECT e. FROM CodeAssist c, IN (c.employees) e";
        int position = "SELECT e.".length();
        testHasOnlyTheseProposals(jpqlQuery, position, singledValuedObjectFieldNames(Employee.class));
    }

    @Test
    public final void test_StateFieldPath_11() throws Exception {
        String jpqlQuery = "SELECT a.alias FROM CodeAssist c, IN (c.customerMap) cust, IN(KEY(cust).aliases) a";
        int position = "SELECT a.".length();
        testHasOnlyTheseProposals(jpqlQuery, position, singledValuedObjectFieldNames(Alias.class));
    }

    @Test
    public final void test_StateFieldPath_12() {
        String jpqlQuery = "SELECT a.alias FROM CodeAssist c, IN (c.customerMap) cust, IN(KEY(cust).aliases) a";
        int position = "SELECT a.alias".length();
        testHasOnlyTheseProposals(jpqlQuery, position, "alias");
    }

    @Test
    public final void test_StateFieldPath_13() throws Exception {
        String jpqlQuery = "SELECT a.alias FROM CodeAssist c, IN (c.customerMap) cust, IN(KEY(cust).aliases) a";
        int position = "SELECT a.alias FROM CodeAssist c, IN (c.".length();
        testHasOnlyTheseProposals(jpqlQuery, position, relationshipAndCollectionFieldNames(CodeAssist.class));
    }

    @Test
    public final void test_StateFieldPath_14() {
        String jpqlQuery = "SELECT a.alias FROM CodeAssist c, IN (c.customerMap) cust, IN(KEY(cust).aliases) a";
        int position = "SELECT a.alias FROM CodeAssist c, IN (c.customerMap) cust, IN(KEY(".length();
        testHasOnlyTheseProposals(jpqlQuery, position, "cust");
    }

    @Test
    public final void test_StateFieldPath_15() throws Exception {
        String jpqlQuery = "SELECT a.alias FROM CodeAssist c, IN (c.customerMap) cust, IN(KEY(cust).aliases) a";
        int position = "SELECT a.alias FROM CodeAssist c, IN (c.customerMap) cust, IN(KEY(cust).".length();
        testHasOnlyTheseProposals(jpqlQuery, position, relationshipAndCollectionFieldNames(Customer.class));
    }

    @Test
    public final void test_StateFieldPath_16() throws Exception {
        String jpqlQuery = "SELECT c FROM CodeAssist c WHERE ALL(SELECT e FROM c.";
        int position = jpqlQuery.length();
        testHasOnlyTheseProposals(jpqlQuery, position, relationshipAndCollectionFieldNames(CodeAssist.class));
    }

    @Test
    public final void test_StateFieldPath_17() throws Exception {
        String jpqlQuery = "SELECT c FROM CodeAssist c WHERE ALL(SELECT e FROM c.employees e";
        int position = "SELECT c FROM CodeAssist c WHERE ALL(SELECT e FROM c.employees".length();
        testHasOnlyTheseProposals(jpqlQuery, position, filter(relationshipAndCollectionFieldNames(CodeAssist.class), "employees"));
    }

    @Test
    public final void test_StateFieldPath_18() throws Exception {
        String jpqlQuery = "update Employee e set e.name = 'JPQL' where (select a from address a where a.";
        int position = jpqlQuery.length();
        testHasOnlyTheseProposals(jpqlQuery, position, nonTransientFieldNames(Address.class));
    }

    @Test
    public final void test_StateFieldPath_19() throws Exception {
        String jpqlQuery = "select O from Product O where O.";
        int position = jpqlQuery.length();
        testHasOnlyTheseProposals(jpqlQuery, position, singledValuedObjectFieldNames(Product.class));
    }

    @Test
    public final void test_Subquery_01() {

        String jpqlQuery = "SELECT e FROM Employee e WHERE e.salary > (SELECT AVG(f.salary) FROM Employee f)";
        int position = "SELECT e FROM Employee e WHERE e.salary > (".length();

        List<String> proposals = new ArrayList<>();
        proposals.add("e");
        CollectionTools.addAll(proposals, bnfAccessor.comparisonExpressionFunctions());
        CollectionTools.addAll(proposals, bnfAccessor.comparisonExpressionClauses());

        testHasOnlyTheseProposals(jpqlQuery, position, proposals);
    }

    @Test
    public final void test_Subquery_02() {
        String jpqlQuery = "SELECT e FROM Employee e WHERE e.salary > (SELECT AVG(f.salary) FROM Employee f)";
        int position = "SELECT e FROM Employee e WHERE e.salary > (S".length();
        testHasTheseProposals(jpqlQuery, position, SELECT);
    }

    @Test
    public final void test_Subquery_03() {
        String jpqlQuery = "SELECT e FROM Employee e WHERE e.salary > (SELECT AVG(f.salary) FROM Employee f)";
        int position = "SELECT e FROM Employee e WHERE e.salary > (SE".length();
        testHasOnlyTheseProposals(jpqlQuery, position, SELECT);
    }

    @Test
    public final void test_Subquery_04() {
        String jpqlQuery = "SELECT e FROM Employee e WHERE e.salary > (SELECT AVG(f.salary) FROM Employee f)";
        int position = "SELECT e FROM Employee e WHERE e.salary > (SEL".length();
        testHasOnlyTheseProposals(jpqlQuery, position, SELECT);
    }

    @Test
    public final void test_Subquery_05() {
        String jpqlQuery = "SELECT e FROM Employee e WHERE e.salary > (SELECT AVG(f.salary) FROM Employee f)";
        int position = "SELECT e FROM Employee e WHERE e.salary > (SELE".length();
        testHasOnlyTheseProposals(jpqlQuery, position, SELECT);
    }

    @Test
    public final void test_Subquery_06() {
        String jpqlQuery = "SELECT e FROM Employee e WHERE e.salary > (SELECT AVG(f.salary) FROM Employee f)";
        int position = "SELECT e FROM Employee e WHERE e.salary > (SELEC".length();
        testHasOnlyTheseProposals(jpqlQuery, position, SELECT);
    }

    @Test
    public final void test_Subquery_07() {
        String jpqlQuery = "SELECT e FROM Employee e WHERE e.salary > (SELECT AVG(f.salary) FROM Employee f)";
        int position = "SELECT e FROM Employee e WHERE e.salary > (SELECT".length();
        testHasTheseProposals(jpqlQuery, position, SELECT);
    }

    @Test
    public final void test_Subquery_08() {
        String jpqlQuery = "SELECT e FROM Employee e WHERE e.salary > (SELECT ";
        int position = "SELECT e FROM Employee e WHERE e.salary > (SELECT".length();
        testHasOnlyTheseProposals(jpqlQuery, position, SELECT);
    }

    @Test
    public final void test_Subquery_09() {
        String jpqlQuery = "SELECT e FROM Employee e WHERE e.salary > (SELECT A";
        int position = "SELECT e FROM Employee e WHERE e.salary > (SELECT A".length();
        testHasOnlyTheseProposals(jpqlQuery, position, ABS, AVG);
    }

    @Test
    public final void test_Subquery_10() {

        String jpqlQuery = "SELECT e FROM Employee e WHERE e.salary > (SELECT AVG(f.salary) FROM Employee f)";
        int position = "SELECT e FROM Employee e WHERE e.salary > (SELECT AVG(f.salary) ".length();

        List<String> proposals = new ArrayList<>();
        proposals.add(FROM);
        CollectionTools.addAll(proposals, bnfAccessor.selectItemAggregates());

        testHasOnlyTheseProposals(jpqlQuery, position, proposals);
    }

    @Test
    public final void test_Subquery_11() {
        String jpqlQuery = "select e from Employee e where (sel";
        int position = jpqlQuery.length();
        testHasOnlyTheseProposals(jpqlQuery, position, SELECT);
    }

    @Test
    public final void test_Subquery_12() {

        String jpqlQuery = "select s from Employee s where (s";
        int position = jpqlQuery.length();

        List<String> proposals = new ArrayList<>();
        proposals.add("s");
        proposals.add(SELECT);
        CollectionTools.addAll(proposals, filter(bnfAccessor.conditionalExpressionsFunctions(), "s"));

        testHasOnlyTheseProposals(jpqlQuery, position, proposals);
    }

    @Test
    public final void test_Subquery_13() {

        String jpqlQuery = "select e from Employee e where (";
        int position = jpqlQuery.length();

        List<String> proposals = new ArrayList<>();
        proposals.add("e");
        proposals.add(SELECT);
        CollectionTools.addAll(proposals, bnfAccessor.conditionalExpressionsFunctions());

        testHasOnlyTheseProposals(jpqlQuery, position, proposals);
    }

    @Test
    public final void test_Subquery_StateFieldPath_01() throws Exception {

        String jpqlQuery = "SELECT e FROM Employee e WHERE e.salary > (SELECT AVG(f.salary) FROM Employee f)";
        int position = "SELECT e FROM Employee e WHERE e.salary > (SELECT AVG(f.".length();

        testHasOnlyTheseProposals(
            jpqlQuery,
            position,
            singledValuedObjectFieldNames(Employee.class, acceptableType(AVG))
        );
    }

    @Test
    public final void test_Substring_01() {
        String jpqlQuery = "SELECT e FROM Employee e WHERE ";
        int position = jpqlQuery.length();
        testHasTheseProposals(jpqlQuery, position, SUBSTRING);
    }

    @Test
    public final void test_Substring_02() {
        String jpqlQuery = "SELECT e FROM Employee e WHERE S";
        int position = jpqlQuery.length();
        testHasTheseProposals(jpqlQuery, position, SUBSTRING);
    }

    @Test
    public final void test_Substring_03() {
        String jpqlQuery = "SELECT e FROM Employee e WHERE SU";
        int position = jpqlQuery.length();
        testHasTheseProposals(jpqlQuery, position, SUBSTRING);
    }

    @Test
    public final void test_Substring_04() {
        String jpqlQuery = "SELECT e FROM Employee e WHERE SUB";
        int position = jpqlQuery.length();
        testHasTheseProposals(jpqlQuery, position, SUBSTRING);
    }

    @Test
    public final void test_Substring_05() {
        String jpqlQuery = "SELECT e FROM Employee e WHERE SUBS";
        int position = jpqlQuery.length();
        testHasTheseProposals(jpqlQuery, position, SUBSTRING);
    }

    @Test
    public final void test_Substring_06() {
        String jpqlQuery = "SELECT e FROM Employee e WHERE SUBST";
        int position = jpqlQuery.length();
        testHasTheseProposals(jpqlQuery, position, SUBSTRING);
    }

    @Test
    public final void test_Substring_07() {
        String jpqlQuery = "SELECT e FROM Employee e WHERE SUBSTR";
        int position = jpqlQuery.length();
        testHasTheseProposals(jpqlQuery, position, SUBSTRING);
    }

    @Test
    public final void test_Substring_08() {
        String jpqlQuery = "SELECT e FROM Employee e WHERE SUBSTR";
        int position = jpqlQuery.length();
        testHasTheseProposals(jpqlQuery, position, SUBSTRING);
    }

    @Test
    public final void test_Substring_09() {
        String jpqlQuery = "SELECT e FROM Employee e WHERE SUBSTRI";
        int position = jpqlQuery.length();
        testHasTheseProposals(jpqlQuery, position, SUBSTRING);
    }

    @Test
    public final void test_Substring_10() {
        String jpqlQuery = "SELECT e FROM Employee e WHERE SUBSTRIN";
        int position = jpqlQuery.length();
        testHasTheseProposals(jpqlQuery, position, SUBSTRING);
    }

    @Test
    public final void test_Substring_11() {
        String jpqlQuery = "SELECT e FROM Employee e WHERE SUBSTRING";
        int position = jpqlQuery.length();
        testHasTheseProposals(jpqlQuery, position, SUBSTRING);
    }

    @Test
    public final void test_Sum_01() {
        String jpqlQuery = "SELECT ";
        int position = jpqlQuery.length();
        testHasTheseProposals(jpqlQuery, position, SUM);
    }

    @Test
    public final void test_Sum_02() {
        String jpqlQuery = "SELECT S";
        int position = jpqlQuery.length();
        testHasTheseProposals(jpqlQuery, position, SUM);
    }

    @Test
    public final void test_Sum_03() {
        String jpqlQuery = "SELECT SU";
        int position = jpqlQuery.length();
        testHasTheseProposals(jpqlQuery, position, SUM);
    }

    @Test
    public final void test_Sum_04() {
        String jpqlQuery = "SELECT SUM";
        int position = jpqlQuery.length();
        testHasTheseProposals(jpqlQuery, position, SUM);
    }

    @Test
    public final void test_Sum_05() {

        String jpqlQuery = "SELECT SUM(";
        int position = jpqlQuery.length();

        List<String> proposals = new ArrayList<>();
        proposals.add(DISTINCT);
        CollectionTools.addAll(proposals, bnfAccessor.internalAggregateFunctionFunctions());

        testHasOnlyTheseProposals(jpqlQuery, position, proposals);
    }

    @Test
    public final void test_Sum_06() {

        String jpqlQuery = "SELECT SUM() From Employee e";
        int position = "SELECT SUM(".length();

        List<String> proposals = new ArrayList<>();
        proposals.add("e");
        proposals.add(DISTINCT);
        CollectionTools.addAll(proposals, bnfAccessor.internalAggregateFunctionFunctions());

        testHasOnlyTheseProposals(jpqlQuery, position, proposals);
    }

    @Test
    public final void test_Sum_07() {

        String jpqlQuery = "SELECT SUM(DISTINCT ) From Employee e";
        int position = "SELECT SUM(DISTINCT ".length();

        List<String> proposals = new ArrayList<>();
        proposals.add("e");
        CollectionTools.addAll(proposals, bnfAccessor.internalAggregateFunctionFunctions());

        testHasOnlyTheseProposals(jpqlQuery, position, proposals);
    }

    @Test
    public final void test_Sum_08() {
        String jpqlQuery = "SELECT SUM(D ) From Employee e";
        int position = "SELECT SUM(D".length();
        testHasOnlyTheseProposals(jpqlQuery, position, DISTINCT);
    }

    @Test
    public final void test_Sum_09() {
        String jpqlQuery = "SELECT SUM(DI ) From Employee e";
        int position = "SELECT SUM(DI".length();
        testHasOnlyTheseProposals(jpqlQuery, position, DISTINCT);
    }

    @Test
    public final void test_Sum_10() {
        String jpqlQuery = "SELECT SUM(DIS ) From Employee e";
        int position = "SELECT SUM(DIS".length();
        testHasOnlyTheseProposals(jpqlQuery, position, DISTINCT);
    }

    @Test
    public final void test_Sum_11() {
        String jpqlQuery = "SELECT SUM(DISTINCT e) From Employee e";
        int position = "SELECT SUM(".length();
        testHasOnlyTheseProposals(jpqlQuery, position, DISTINCT);
    }

    @Test
    public final void test_Sum_12() {
        String jpqlQuery = "SELECT SUM(DISTINCT e) From Employee e";
        int position = "SELECT SUM(D".length();
        testHasOnlyTheseProposals(jpqlQuery, position, DISTINCT);
    }

    @Test
    public final void test_Sum_13() {
        String jpqlQuery = "SELECT SUM(DISTINCT e) From Employee e";
        int position = "SELECT SUM(DI".length();
        testHasOnlyTheseProposals(jpqlQuery, position, DISTINCT);
    }

    @Test
    public final void test_Sum_14() {

        String jpqlQuery = "SELECT SUM(DISTINCT e) From Employee e";
        int position = "SELECT SUM(DISTINCT ".length();

        List<String> proposals = new ArrayList<>();
        proposals.add("e");
        CollectionTools.addAll(proposals, bnfAccessor.internalAggregateFunctionFunctions());

        testHasOnlyTheseProposals(jpqlQuery, position, proposals);
    }

    @Test
    public final void test_Sum_15() {

        String jpqlQuery = "SELECT SUM(DISTINCT e) From Employee e";
        int position = "SELECT SUM(DISTINCT e".length();

        List<String> proposals = new ArrayList<>();
        proposals.add("e");
        CollectionTools.addAll(proposals, filter(bnfAccessor.internalAggregateFunctionFunctions(), "e"));

        testHasOnlyTheseProposals(jpqlQuery, position, proposals);
    }

    @Test
    public final void test_Sum_16() {

        String jpqlQuery = "SELECT SUM(DISTINCT e) From Employee emp";
        int position = "SELECT SUM(DISTINCT e".length();

        List<String> proposals = new ArrayList<>();
        proposals.add("emp");
        CollectionTools.addAll(proposals, filter(bnfAccessor.internalAggregateFunctionFunctions(), "e"));

        testHasOnlyTheseProposals(jpqlQuery, position, proposals);
    }

    @Test
    public final void test_Sum_17() {

        String jpqlQuery = "SELECT SUM() From Employee emp";
        int position = "SELECT SUM(".length();

        List<String> proposals = new ArrayList<>();
        proposals.add("emp");
        proposals.add(DISTINCT);
        CollectionTools.addAll(proposals, bnfAccessor.internalAggregateFunctionFunctions());

        testHasOnlyTheseProposals(jpqlQuery, position, proposals);
    }

    @Test
    public final void test_Sum_18() {

        String jpqlQuery = "SELECT SUM(e) From Employee emp";
        int position = "SELECT SUM(e".length();

        List<String> proposals = new ArrayList<>();
        proposals.add("emp");
        CollectionTools.addAll(proposals, filter(bnfAccessor.internalAggregateFunctionFunctions(), "e"));

        testHasOnlyTheseProposals(jpqlQuery, position, proposals);
    }

    @Test
    public final void test_Sum_19() {
        String jpqlQuery = "SELECT SUM(em) From Employee emp";
        int position = "SELECT SUM(em".length();
        testHasOnlyTheseProposals(jpqlQuery, position, "emp");
    }

    @Test
    public final void test_Sum_20() {
        String jpqlQuery = "SELECT SUM(emp) From Employee emp";
        int position = "SELECT SUM(emp".length();
        testHasOnlyTheseProposals(jpqlQuery, position, "emp");
    }

    @Test
    public final void test_Sum_21() {

        String jpqlQuery = "SELECT SUM(emp) From Employee emp";
        int position = "SELECT SUM(e".length();

        List<String> proposals = new ArrayList<>();
        proposals.add("emp");
        CollectionTools.addAll(proposals, filter(bnfAccessor.internalAggregateFunctionFunctions(), "e"));

        testHasOnlyTheseProposals(jpqlQuery, position, proposals);
    }

    @Test
    public final void test_Sum_22() {
        String jpqlQuery = "SELECT SUM(emp) From Employee emp";
        int position = "SELECT SUM(em".length();
        testHasOnlyTheseProposals(jpqlQuery, position, "emp");
    }

    @Test
    public final void test_Sum_23() {

        String jpqlQuery = "SELECT SUM( From Employee emp";
        int position = "SELECT SUM(".length();

        List<String> proposals = new ArrayList<>();
        proposals.add("emp");
        proposals.add(DISTINCT);
        CollectionTools.addAll(proposals, bnfAccessor.internalAggregateFunctionFunctions());

        testHasOnlyTheseProposals(jpqlQuery, position, proposals);
    }

    @Test
    public final void test_Sum_24() {

        String jpqlQuery = "SELECT SUM(e From Employee emp";
        int position = "SELECT SUM(e".length();

        List<String> proposals = new ArrayList<>();
        proposals.add("emp");
        CollectionTools.addAll(proposals, filter(bnfAccessor.internalAggregateFunctionFunctions(), "e"));

        testHasOnlyTheseProposals(jpqlQuery, position, proposals);
    }

    @Test
    public final void test_Trim_06() {
        String jpqlQuery = "SELECT e FROM Employee e WHERE TRIM(";
        int position = jpqlQuery.length();
        testHasTheseProposals(jpqlQuery, position, TRAILING);
    }

    @Test
    public final void test_Trim_07() {
        String jpqlQuery = "SELECT e FROM Employee e WHERE TRIM(B";
        int position = jpqlQuery.length();
        testHasTheseProposals(jpqlQuery, position, BOTH);
    }

    @Test
    public final void test_Trim_08() {
        String jpqlQuery = "SELECT e FROM Employee e WHERE TRIM(BO";
        int position = jpqlQuery.length();
        testHasTheseProposals(jpqlQuery, position, BOTH);
    }

    @Test
    public final void test_Trim_09() {
        String jpqlQuery = "SELECT e FROM Employee e WHERE TRIM(BOT";
        int position = jpqlQuery.length();
        testHasTheseProposals(jpqlQuery, position, BOTH);
    }

    @Test
    public final void test_Trim_10() {
        String jpqlQuery = "SELECT e FROM Employee e WHERE TRIM(BOTH";
        int position = jpqlQuery.length();
        testHasOnlyTheseProposals(jpqlQuery, position, BOTH);
    }

    @Test
    public final void test_Trim_11() {
        String jpqlQuery = "SELECT e FROM Employee e WHERE TRIM(L";
        int position = jpqlQuery.length();
        testHasTheseProposals(jpqlQuery, position, LEADING);
    }

    @Test
    public final void test_Trim_12() {
        String jpqlQuery = "SELECT e FROM Employee e WHERE TRIM(LE";
        int position = jpqlQuery.length();
        testHasTheseProposals(jpqlQuery, position, LEADING);
    }

    @Test
    public final void test_Trim_13() {
        String jpqlQuery = "SELECT e FROM Employee e WHERE TRIM(LEA";
        int position = jpqlQuery.length();
        testHasTheseProposals(jpqlQuery, position, LEADING);
    }

    @Test
    public final void test_Trim_14() {
        String jpqlQuery = "SELECT e FROM Employee e WHERE TRIM(LEAD";
        int position = jpqlQuery.length();
        testHasTheseProposals(jpqlQuery, position, LEADING);
    }

    @Test
    public final void test_Trim_15() {
        String jpqlQuery = "SELECT e FROM Employee e WHERE TRIM(LEADI";
        int position = jpqlQuery.length();
        testHasTheseProposals(jpqlQuery, position, LEADING);
    }

    @Test
    public final void test_Trim_16() {
        String jpqlQuery = "SELECT e FROM Employee e WHERE TRIM(LEADIN";
        int position = jpqlQuery.length();
        testHasTheseProposals(jpqlQuery, position, LEADING);
    }

    @Test
    public final void test_Trim_17() {
        String jpqlQuery = "SELECT e FROM Employee e WHERE TRIM(LEADING";
        int position = jpqlQuery.length();
        testHasOnlyTheseProposals(jpqlQuery, position, LEADING);
    }

    @Test
    public final void test_Trim_18() {
        String jpqlQuery = "SELECT e FROM Employee e WHERE TRIM(T";
        int position = jpqlQuery.length();
        testHasTheseProposals(jpqlQuery, position, TRAILING);
    }

    @Test
    public final void test_Trim_19() {
        String jpqlQuery = "SELECT e FROM Employee e WHERE TRIM(TR";
        int position = jpqlQuery.length();
        testHasTheseProposals(jpqlQuery, position, TRAILING);
    }

    @Test
    public final void test_Trim_20() {
        String jpqlQuery = "SELECT e FROM Employee e WHERE TRIM(TRA";
        int position = jpqlQuery.length();
        testHasTheseProposals(jpqlQuery, position, TRAILING);
    }

    @Test
    public final void test_Trim_21() {
        String jpqlQuery = "SELECT e FROM Employee e WHERE TRIM(TRAI";
        int position = jpqlQuery.length();
        testHasTheseProposals(jpqlQuery, position, TRAILING);
    }

    @Test
    public final void test_Trim_22() {
        String jpqlQuery = "SELECT e FROM Employee e WHERE TRIM(TRAIL";
        int position = jpqlQuery.length();
        testHasTheseProposals(jpqlQuery, position, TRAILING);
    }

    @Test
    public final void test_Trim_23() {
        String jpqlQuery = "SELECT e FROM Employee e WHERE TRIM(TRAILI";
        int position = jpqlQuery.length();
        testHasTheseProposals(jpqlQuery, position, TRAILING);
    }

    @Test
    public final void test_Trim_24() {
        String jpqlQuery = "SELECT e FROM Employee e WHERE TRIM(TRAILIN";
        int position = jpqlQuery.length();
        testHasTheseProposals(jpqlQuery, position, TRAILING);
    }

    @Test
    public final void test_Trim_25() {
        String jpqlQuery = "SELECT e FROM Employee e WHERE TRIM(TRAILING";
        int position = jpqlQuery.length();
        testHasOnlyTheseProposals(jpqlQuery, position, TRAILING);
    }

    @Test
    public final void test_Trim_26() {
        String jpqlQuery = "SELECT e FROM Employee e WHERE TRIM(TRAILING 'd' ";
        int position = jpqlQuery.length();
        testHasTheseProposals(jpqlQuery, position, FROM);
    }

    @Test
    public final void test_Trim_27() {
        String jpqlQuery = "SELECT e FROM Employee e WHERE TRIM(TRAILING 'd' F";
        int position = jpqlQuery.length();
        testHasTheseProposals(jpqlQuery, position, FROM);
    }

    @Test
    public final void test_Trim_28() {
        String jpqlQuery = "SELECT e FROM Employee e WHERE TRIM(TRAILING 'd' FR";
        int position = jpqlQuery.length();
        testHasTheseProposals(jpqlQuery, position, FROM);
    }

    @Test
    public final void test_Trim_29() {
        String jpqlQuery = "SELECT e FROM Employee e WHERE TRIM(TRAILING 'd' FRO";
        int position = jpqlQuery.length();
        testHasTheseProposals(jpqlQuery, position, FROM);
    }

    @Test
    public final void test_Trim_30() {
        String jpqlQuery = "SELECT e FROM Employee e WHERE TRIM(TRAILING 'd' FROM";
        int position = jpqlQuery.length();
        testHasOnlyTheseProposals(jpqlQuery, position, FROM);
    }

    @Test
    public final void test_Trim_31() {
        String jpqlQuery = "SELECT e FROM Employee e WHERE TRIM(TRAILING 'd' FROM ";
        int position = jpqlQuery.length();
        testHasTheseProposals(jpqlQuery, position, "e");
    }

    @Test
    public final void test_Trim_32() {
        String jpqlQuery = "SELECT e FROM Employee e WHERE TRIM(TRAILING 'd' FROM";
        int position = jpqlQuery.length() - 1;
        testHasOnlyTheseProposals(jpqlQuery, position, FROM);
    }

    @Test
    public final void test_Update_01() {
        String jpqlQuery = "U";
        int position = jpqlQuery.length();
        testHasTheseProposals(jpqlQuery, position, UPDATE);
    }

    @Test
    public final void test_Update_02() {
        String jpqlQuery = "UP";
        int position = jpqlQuery.length();
        testHasTheseProposals(jpqlQuery, position, UPDATE);
    }

    @Test
    public final void test_Update_03() {
        String jpqlQuery = "UPD";
        int position = jpqlQuery.length();
        testHasTheseProposals(jpqlQuery, position, UPDATE);
    }

    @Test
    public final void test_Update_04() {
        String jpqlQuery = "UPDA";
        int position = jpqlQuery.length();
        testHasTheseProposals(jpqlQuery, position, UPDATE);
    }

    @Test
    public final void test_Update_05() {
        String jpqlQuery = "UPDAT";
        int position = jpqlQuery.length();
        testHasTheseProposals(jpqlQuery, position, UPDATE);
    }

    @Test
    public final void test_Update_06() {
        String jpqlQuery = UPDATE;
        int position = jpqlQuery.length();
        testHasTheseProposals(jpqlQuery, position, UPDATE);
    }

    @Test
    public final void test_Update_07() {
        String jpqlQuery = "UPDATE Employee";
        int position = "U".length();
        testHasTheseProposals(jpqlQuery, position, UPDATE);
    }

    @Test
    public final void test_Update_08() {
        String jpqlQuery = "UPDATE Employee";
        int position = "UP".length();
        testHasTheseProposals(jpqlQuery, position, UPDATE);
    }

    @Test
    public final void test_Update_09() {
        String jpqlQuery = "UPDATE Employee";
        int position = "UPD".length();
        testHasTheseProposals(jpqlQuery, position, UPDATE);
    }

    @Test
    public final void test_Update_10() {
        String jpqlQuery = "UPDATE Employee";
        int position = "UPDA".length();
        testHasTheseProposals(jpqlQuery, position, UPDATE);
    }

    @Test
    public final void test_Update_11() {
        String jpqlQuery = "UPDATE Employee";
        int position = "UPDAT".length();
        testHasTheseProposals(jpqlQuery, position, UPDATE);
    }

    @Test
    public final void test_Update_12() {
        String jpqlQuery = "UPDATE Employee";
        int position = "UPDATE".length();
        testHasTheseProposals(jpqlQuery, position, UPDATE);
    }

    @Test
    public final void test_Update_13() {
        String jpqlQuery = "UPDATE Employee e ";
        int position = jpqlQuery.length();
        testHasTheseProposals(jpqlQuery, position, SET);
    }

    @Test
    public final void test_Update_14() {
        String jpqlQuery = "UPDATE Employee e S";
        int position = jpqlQuery.length();
        testHasOnlyTheseProposals(jpqlQuery, position, SET);
    }

    @Test
    public final void test_Update_15() {
        String jpqlQuery = "UPDATE Employee e SE";
        int position = jpqlQuery.length();
        testHasOnlyTheseProposals(jpqlQuery, position, SET);
    }

    @Test
    public final void test_Update_16() {
        String jpqlQuery = "UPDATE Employee e SET";
        int position = jpqlQuery.length();
        testHasOnlyTheseProposals(jpqlQuery, position, SET);
    }

    @Test
    public final void test_Update_17() {
        String jpqlQuery = "UPDATE SET";
        int position = jpqlQuery.length();
        testHasNoProposals(jpqlQuery, position);
    }

    @Test
    public final void test_Update_18() throws Exception {
        String jpqlQuery = "UPDATE S";
        int position = jpqlQuery.length();
        testHasOnlyTheseProposals(jpqlQuery, position, filter(entityNames(), "S"));
    }

    @Test
    public final void test_Update_19() {
        String jpqlQuery = "UPDATE Employee S";
        int position = jpqlQuery.length();
        testHasOnlyTheseProposals(jpqlQuery, position, SET);
    }

    @Test
    public final void test_Update_20() {
        String jpqlQuery = "UPDATE Employee S SET";
        int position = "UPDATE Employee S".length();
        testHasNoProposals(jpqlQuery, position);
    }

    @Test
    public final void test_Update_21() {
        String jpqlQuery = "UPDATE Z";
        int position = jpqlQuery.length();
        testHasNoProposals(jpqlQuery, position);
    }

    @Test
    public final void test_Update_22() throws Exception {
        String jpqlQuery = "UPDATE A";
        int position = "UPDATE A".length();
        testHasOnlyTheseProposals(jpqlQuery, position, filter(entityNames(), "A"));
    }

    @Test
    public final void test_Update_23() {
        String jpqlQuery = "UPDATE Employee e SET ";
        int position = jpqlQuery.length();
        testHasOnlyTheseProposals(jpqlQuery, position, "e");
    }

    @Test
    public final void test_Update_24() {
        String jpqlQuery = "UPDATE Employee SET e";
        int position = "UPDATE Employee SET ".length();
        testHasOnlyTheseProposals(jpqlQuery, position, "employee");
    }

    @Test
    public final void test_Update_25() throws Exception {
        String jpqlQuery = "UPDATE ";
        int position = jpqlQuery.length();
        testHasOnlyTheseProposals(jpqlQuery, position, entityNames());
    }

    @Test
    public final void test_Update_26() throws Exception {
        String jpqlQuery = "UPDATE Alias a";
        int position = "UPDATE ".length();
        testHasOnlyTheseProposals(jpqlQuery, position, entityNames());
    }

    @Test
    public final void test_Update_27() {
        String jpqlQuery = "UPDATE Alias a";
        int position = "UPDATE Al".length();
        testHasOnlyTheseProposals(jpqlQuery, position, "Alias");
    }

    @Test
    public final void test_Update_28() {
        String jpqlQuery = "UPDATE Employee A SET";
        int position = "UPDATE Employee A ".length();
        testHasTheseProposals(jpqlQuery, position, SET);
    }

    @Test
    public final void test_Update_30() {
        String jpqlQuery = "UPDATE Employee A ";
        int position = jpqlQuery.length() - 1;
        testHasOnlyTheseProposals(jpqlQuery, position, AS);
    }

    @Test
    public final void test_Update_31() {
        String jpqlQuery = "UPDATE Employee AS ";
        int position = jpqlQuery.length();
        testHasNoProposals(jpqlQuery, position);
    }

    @Test
    public final void test_Update_32() throws Exception {
        String jpqlQuery = "UPDATE Employee AS e SET e.";
        int position = "UPDATE Employee AS e SET e.".length();
        testHasTheseProposals(jpqlQuery, position, singledValuedObjectFieldNames(Employee.class));
    }

    @Test
    public final void test_When_01() {
        test_ConditionalClause_01(WHEN, "WHERE CASE ");
    }

    @Test
    public final void test_When_02() {
        test_ConditionalClause_02(WHEN, "WHERE CASE ");
    }

    @Test
    public final void test_When_03() {
        test_ConditionalClause_03(WHEN, "WHERE CASE ");
    }

    @Test
    public final void test_When_04() {
        test_ConditionalClause_04(WHEN, "WHERE CASE ");
    }

    @Test
    public final void test_When_05() {
        test_ConditionalClause_05(WHEN, "WHERE CASE ");
    }

    @Test
    public final void test_When_06() {
        test_ConditionalClause_06(WHEN, "WHERE CASE ");
    }

    @Test
    public final void test_When_07() {
        test_ConditionalClause_07(WHEN, "WHERE CASE ");
    }

    @Test
    public final void test_When_08() {

        String jpqlQuery = "SELECT e FROM Employee e WHERE CASE WHEN (e.name = 'Pascal') ";
        int position = jpqlQuery.length();

        List<String> proposals = new ArrayList<>();
        proposals.add(THEN);
        CollectionTools.addAll(proposals, bnfAccessor.logicalIdentifiers());

        // Filtered out
        proposals.remove(IS_EMPTY);
        proposals.remove(IS_NOT_EMPTY);

        testHasOnlyTheseProposals(jpqlQuery, position, proposals);
    }

    @Test
    public final void test_When_09() {

        String jpqlQuery = "SELECT e FROM Employee e WHERE CASE WHEN e.roomNumber ";
        int position = jpqlQuery.length();

        List<String> proposals = new ArrayList<>();
        CollectionTools.addAll(proposals, bnfAccessor.conditionalExpressionsAggregates());
        CollectionTools.addAll(proposals, bnfAccessor.conditionalExpressionsCompoundFunctions());

        // Filtered out
        proposals.remove(IS_EMPTY);
        proposals.remove(IS_NOT_EMPTY);
        proposals.remove(AND);
        proposals.remove(OR);

        testHasOnlyTheseProposals(jpqlQuery, position, proposals);
    }

    @Test
    public final void test_When_10() {

        String jpqlQuery = "SELECT e FROM Employee e WHERE CASE WHEN e.phoneNumbers ";
        int position = jpqlQuery.length();

        List<String> proposals = new ArrayList<>();
        CollectionTools.addAll(proposals, bnfAccessor.conditionalExpressionsCompoundFunctions());

        // Filtered out
        proposals.remove(LIKE);
        proposals.remove(NOT_LIKE);
        proposals.remove(BETWEEN);
        proposals.remove(NOT_BETWEEN);
        proposals.remove(LIKE);
        proposals.remove(NOT_LIKE);

        testHasOnlyTheseProposals(jpqlQuery, position, proposals);
    }

    @Test
    public final void test_When_11() {

        String jpqlQuery = "SELECT e FROM Employee e WHERE CASE WHEN AVG(e.age) ";
        int position = jpqlQuery.length();

        List<String> proposals = new ArrayList<>();
        CollectionTools.addAll(proposals, bnfAccessor.conditionalExpressionsAggregates());
        CollectionTools.addAll(proposals, bnfAccessor.conditionalExpressionsCompoundFunctions());

        // Filtered out
        proposals.remove(IS_EMPTY);
        proposals.remove(IS_NOT_EMPTY);

        testHasOnlyTheseProposals(jpqlQuery, position, proposals);
    }

    @Test
    public final void test_When_12() {

        String jpqlQuery = "SELECT e FROM Employee e WHERE CASE WHEN ?1 ";
        int position = jpqlQuery.length();

        List<String> proposals = new ArrayList<>();
        CollectionTools.addAll(proposals, bnfAccessor.conditionalExpressionsAggregates());
        CollectionTools.addAll(proposals, bnfAccessor.conditionalExpressionsCompoundFunctions());

        // Filtered out
        proposals.remove(IS_EMPTY);
        proposals.remove(IS_NOT_EMPTY);

        testHasOnlyTheseProposals(jpqlQuery, position, proposals);
    }

    @Test
    public final void test_When_13() {

        String fragment = "SELECT e FROM Employee e WHERE CASE WHEN (e.name = 'Pascal') ";

        for (int index = 0, count = THEN.length(); index <= count; index++) {

            String jpqlQuery = fragment + THEN.substring(0, index);

            for (int positionIndex = fragment.length(), count2 = jpqlQuery.length(); positionIndex <= count2; positionIndex++) {
                testHasTheseProposals(jpqlQuery, positionIndex, THEN);
            }
        }
    }

    @Test
    public final void test_When_14() {
        String jpqlQuery = "SELECT e FROM Employee e WHERE WHEN";
        int position = "SELECT e FROM Employee e WHERE W".length();
        testHasOnlyTheseProposals(jpqlQuery, position, filter(bnfAccessor.conditionalExpressionsFunctions(), "W"));
    }

    @Test
    public final void test_When_15() {
        String jpqlQuery = "SELECT e FROM Employee e WHERE THEN";
        int position = "SELECT e FROM Employee e WHERE T".length();
        testHasOnlyTheseProposals(jpqlQuery, position, filter(bnfAccessor.conditionalExpressionsFunctions(), "T"));
    }

    @Test
    public final void test_Where_01() {
        test_ConditionalClause_01(WHERE);
    }

    @Test
    public final void test_Where_02() {
        test_ConditionalClause_02(WHERE);
    }

    @Test
    public final void test_Where_03() {
        test_ConditionalClause_03(WHERE);
    }

    @Test
    public final void test_Where_04() {
        test_ConditionalClause_04(WHERE);
    }

    @Test
    public final void test_Where_05() {
        test_ConditionalClause_05(WHERE);
    }

    @Test
    public final void test_Where_06() {
        test_ConditionalClause_06(WHERE);
    }

    @Test
    public final void test_Where_07() {
        test_ConditionalClause_07(WHERE);
    }

    protected class TweakFunctionIdentifiers {

        protected void tweak(List<String> proposals,
                             String identifier,
                             String identifierFragment,
                             int positionIndex) {

            // Special case for ALL/SOME/ANY
            if (identifier.equals(ALL) && identifier.equals(identifierFragment)) {
                if (!proposals.contains(SOME)) {
                    proposals.add(SOME);
                }
                if (!proposals.contains(ANY)) {
                    proposals.add(ANY);
                }
            }
            else if (identifier.equals(ANY) && identifier.equals(identifierFragment)) {
                if (!proposals.contains(ALL)) {
                    proposals.add(ALL);
                }
                if (!proposals.contains(SOME)) {
                    proposals.add(SOME);
                }
            }
            else if (identifier.equals(SOME) && identifier.equals(identifierFragment)) {
                if (!proposals.contains(ALL)) {
                    proposals.add(ALL);
                }
                if (!proposals.contains(ANY)) {
                    proposals.add(ANY);
                }
            }

            // Special case for CURRENT_DATE/CURRENT_TIME/CURRENT_TIMESTAMP
            else if (identifier.equals(CURRENT_DATE) && identifier.equals(identifierFragment)) {
                if (!proposals.contains(CURRENT_TIME)) {
                    proposals.add(CURRENT_TIME);
                }
                if (!proposals.contains(CURRENT_TIMESTAMP)) {
                    proposals.add(CURRENT_TIMESTAMP);
                }
            }
            else if (identifier.equals(CURRENT_TIME) && identifier.equals(identifierFragment)) {
                if (!proposals.contains(CURRENT_DATE)) {
                    proposals.add(CURRENT_DATE);
                }
                if (!proposals.contains(CURRENT_TIMESTAMP)) {
                    proposals.add(CURRENT_TIMESTAMP);
                }
            }
            else if (identifier.equals(CURRENT_TIMESTAMP) && identifier.equals(identifierFragment)) {
                if (!proposals.contains(CURRENT_DATE)) {
                    proposals.add(CURRENT_DATE);
                }
                if (!proposals.contains(CURRENT_TIME)) {
                    proposals.add(CURRENT_TIME);
                }
            }
            else if (identifier.equals(CURRENT_TIME) && identifierFragment.equals(CURRENT_TIMESTAMP) ||
                     identifier.equals(CURRENT_TIMESTAMP) && identifierFragment.equals(CURRENT_TIME)) {

                if (!proposals.contains(CURRENT_DATE)) {
                    proposals.add(CURRENT_DATE);
                }
            }

            // Special case for EXISTS/NOT EXISTS
            else if (identifier.equals(EXISTS) && identifier.equals(identifierFragment) && positionIndex > 0) {
                if (!proposals.contains(NOT_EXISTS)) {
                    proposals.add(NOT_EXISTS);
                }
            }

            // Special case for TRUE/FALSE/NULL
            else if (identifier.equals(TRUE) && identifier.equals(identifierFragment)) {
                if (!proposals.contains(FALSE)) {
                    proposals.add(FALSE);
                }
                if (!proposals.contains(NULL)) {
                    proposals.add(NULL);
                }
            }
            else if (identifier.equals(FALSE) && identifier.equals(identifierFragment)) {
                if (!proposals.contains(TRUE)) {
                    proposals.add(TRUE);
                }
                if (!proposals.contains(NULL)) {
                    proposals.add(NULL);
                }
            }
            else if (identifier.equals(NULL) && identifier.equals(identifierFragment)) {
                if (!proposals.contains(FALSE)) {
                    proposals.add(FALSE);
                }
                if (!proposals.contains(TRUE)) {
                    proposals.add(TRUE);
                }
            }
            else if (identifier.equals(NULLIF) && identifierFragment.equals(NULL)) {
                if (!proposals.contains(FALSE)) {
                    proposals.add(FALSE);
                }
                if (!proposals.contains(TRUE)) {
                    proposals.add(TRUE);
                }
            }
        }
    }
}