Attachment #150866 for bug #293708

View | Details | Raw Unified | Return to bug 293708
Collapse All | Expand All




    public void simpleJoinFetchTest(org.eclipse.persistence.jpa.JpaEntityManager em) throws Exception {
        //"SELECT e FROM Employee e LEFT JOIN FETCH e.phoneNumbers"

        em.createQuery("select e from Employee e left join fetch e.phoneNumbers").getResultList();
        //use the cache
        CriteriaBuilder qb = em.getCriteriaBuilder();
        CriteriaQuery<Employee> cq = qb.createQuery(Employee.class);
        Root<Employee> root = cq.from(getEntityManagerFactory().getMetamodel().entity(Employee.class));
        Root<Employee> root2 = cq.from(Employee.class);
        //getEntityManagerFactory().getMetamodel();
        root.fetch(Employee_.phoneNumbers, JoinType.LEFT);
        List result = em.createQuery(cq).getResultList();
        

        clearCache();

        //"SELECT OBJECT(emp) FROM Employee emp"
        beginTransaction(em);
        try {
            List result = em.createQuery(em.getCriteriaBuilder().createQuery(Employee.class)).getResultList();
            Assert.assertTrue("Base Test Case Failed", comparer.compareObjects(result, expectedResult));
        } finally {
            rollbackTransaction(em);
            closeEntityManager(em);
        }
    }

    //Test case for ABS function in EJBQL

        getEntityManagerFactory().getMetamodel().managedType(Employee.class).getDeclaredSingularAttribute("manager", Employee.class).getType();
        Root<Employee> root = cq.from(getEntityManagerFactory().getMetamodel().entity(Employee.class));
        cq.where(qb.equal( qb.abs(root.get(Employee_.salary)), expectedResult.getSalary()) );

        beginTransaction(em);
        try {
            List result = em.createQuery(cq).getResultList();
            Assert.assertTrue("ABS test failed", comparer.compareObjects(result, expectedResult));
        } finally {
            rollbackTransaction(em);
            closeEntityManager(em);
        }
    }

    //Test case for Between function in EJBQL

        Root<Employee> root = cq.from(getEntityManagerFactory().getMetamodel().entity(Employee.class));
        //Cast to Expression<Comparable> since empId is BigDec and getId is Integer.  between requires Comparable types; Number is not comparable
        cq.where( qb.between(root.get(Employee_.id).as(Comparable.class), qb.literal(empId), qb.literal(employee.getId()) ) );
        beginTransaction(em);
        try {
            List result = em.createQuery(cq).getResultList();
            Assert.assertTrue("Between test failed", comparer.compareObjects(result, expectedResult));
        } finally {
            rollbackTransaction(em);
            closeEntityManager(em);
        }
    }

    //Test case for concat function in EJBQL

        CriteriaQuery<Employee> cq = qb.createQuery(Employee.class);
        Root<Employee> root = cq.from(getEntityManagerFactory().getMetamodel().entity(Employee.class));
        cq.where( qb.equal(root.get(Employee_.firstName), qb.concat(qb.literal(partOne), qb.literal(partTwo))) );
        beginTransaction(em);
        try {
            List result = em.createQuery(cq).getResultList();
            Assert.assertTrue("Concat test failed", comparer.compareObjects(result, expectedResult));
        } finally {
            rollbackTransaction(em);
            closeEntityManager(em);
        }
    }

    //Test case for concat function in EJBQL taking parameters

        String partTwo = expectedResult.getFirstName().substring(2);

        //"SELECT OBJECT(emp) FROM Employee emp WHERE emp.firstName = CONCAT( :partOne, :partTwo )"
        beginTransaction(em);
        try {  
            CriteriaBuilder qb = em.getCriteriaBuilder();
            CriteriaQuery<Employee> cq = qb.createQuery(Employee.class);
            Root<Employee> root = cq.from(getEntityManagerFactory().getMetamodel().entity(Employee.class));
            cq.where( qb.equal(root.get(Employee_.firstName), qb.concat(qb.parameter(String.class, "partOne"), qb.parameter(String.class, "partTwo"))) );
            Query query = em.createQuery(cq);
            query.setParameter("partOne", partOne).setParameter("partTwo", partTwo);
      
            List result = query.getResultList();
            Assert.assertTrue("Concat test failed", comparer.compareObjects(result, expectedResult));
        } finally {
            rollbackTransaction(em);
            closeEntityManager(em);
        }
    }



        CriteriaQuery<Employee> cq = qb.createQuery(Employee.class);
        Root<Employee> root = cq.from(getEntityManagerFactory().getMetamodel().entity(Employee.class));
        cq.where( qb.like(qb.concat(root.get(Employee_.firstName), qb.literal("Smith") ), partOne+"Smith") );
        beginTransaction(em);
        try {  
            List result = em.createQuery(cq).getResultList();
            Assert.assertTrue("Concat test with constraints failed", comparer.compareObjects(result, expectedResult));
        } finally {
            rollbackTransaction(em);
            closeEntityManager(em);
        }
    }
    
  //Test case for concat function with constants in EJBQL

                .get(getEntityManagerFactory().getMetamodel().entity(Employee.class).getSingularAttribute("id", Integer.class))));
        //cq.select(qb.count(root.get(PhoneNumber_.owner).get(Employee_.id)));

        beginTransaction(em);
        try { 
            List result = em.createQuery(cq).getResultList();
            System.out.println(" results are :"+result);
        
            qb = em.getCriteriaBuilder();
            cq = qb.createQuery(Long.class);
            root = cq.from(PhoneNumber.class);
            cq.select(qb.count(root.get(PhoneNumber_.owner).get(Employee_.id)));
            result = em.createQuery(cq).getResultList();

            Assert.assertTrue("Simple Count test failed", expectedResult.elementAt(0).equals(result.get(0)));
        } finally {
            rollbackTransaction(em);
            closeEntityManager(em);
        }
    }

    public void simpleThreeArgConcatTest() {

        CriteriaQuery<Employee> cq = qb.createQuery(Employee.class);
        Root<Employee> root = cq.from(getEntityManagerFactory().getMetamodel().entity(Employee.class));
        cq.where( qb.equal( root.get(Employee_.firstName), qb.concat(qb.literal(partOne), qb.concat( qb.literal(partTwo), qb.literal(partThree)) ) ) );
        beginTransaction(em);
        try { 
            List result = em.createQuery(cq).getResultList();
            Assert.assertTrue("Concat test failed", comparer.compareObjects(result, expectedResult));
        } finally {
            rollbackTransaction(em);
            closeEntityManager(em);
        }
    }

    public void simpleDistinctTest() {

        CriteriaQuery<Employee> cq = qb.createQuery(Employee.class);
        cq.distinct(true);
        cq.from(getEntityManagerFactory().getMetamodel().entity(Employee.class)).join(Employee_.phoneNumbers);
        beginTransaction(em);
        try { 
            List result = em.createQuery(cq).getResultList();
        
            Set testSet = new HashSet();
            for (Iterator iterator = result.iterator(); iterator.hasNext(); ) {
                Employee emp = (Employee)iterator.next();
                assertFalse("Result was not distinct", testSet.contains(emp));
                testSet.add(emp);
            }
        } finally {
            rollbackTransaction(em);
            closeEntityManager(em);
        }
    }


            Root<Employee> root = cq.from(getEntityManagerFactory().getMetamodel().entity(Employee.class));
            cq.select(root.get(Employee_.firstName));
            cq.where( qb.equal(root.get(Employee_.lastName), qb.literal(emp.getLastName())));
            beginTransaction(em);
            try {
                List result = em.createQuery(cq).getResultList();
            
                assertTrue("Failed to return null value", result.contains(null));
            } finally {
                rollbackTransaction(em);
               // closeEntityManager(em);
            }
        } finally {
            try {
                beginTransaction(em);

                }
                closeEntityManager(em);
                throw ex;
            } finally {
                closeEntityManager(em);
            }

        }
    }


        root.join(Employee_.phoneNumbers);
        cq.distinct(true);
        cq.multiselect(root, root.get(Employee_.firstName));
        beginTransaction(em);
        try {
            List result = em.createQuery(cq).getResultList();

            Set testSet = new HashSet();
            for (Iterator iterator = result.iterator(); iterator.hasNext(); ) {
                String ids = "";
                javax.persistence.Tuple row = (javax.persistence.Tuple)iterator.next();
                Employee emp = row.get(0, Employee.class);
                String string = row.get(1, String.class);
                ids = "_" + emp.getId() + "_" + string;
                assertFalse("Result was not distinct", testSet.contains(ids));
                testSet.add(ids);
            }
        } finally {
            rollbackTransaction(em);
            closeEntityManager(em);
        }
    }


        Root<Employee> root = cq.from(getEntityManagerFactory().getMetamodel().entity(Employee.class));
        Predicate firstOr = qb.or(qb.equal(root.get(Employee_.id), emp1.getId()), qb.equal(root.get(Employee_.id), emp2.getId()));
        cq.where( qb.or(firstOr, qb.equal(root.get(Employee_.id), emp3.getId())) );
        beginTransaction(em);
        try {
            List result = em.createQuery(cq).getResultList();

            Assert.assertTrue("Double OR test failed", comparer.compareObjects(result, expectedResult));
        } finally {
            rollbackTransaction(em);
            closeEntityManager(em);
        }
    }

    //Test case for equals in EJBQL

        CriteriaQuery<Employee> cq = qb.createQuery(Employee.class);
        Root<Employee> root = cq.from(getEntityManagerFactory().getMetamodel().entity(Employee.class));
        cq.where( qb.equal(root.get(Employee_.firstName), expectedResult.getFirstName() ) );
        beginTransaction(em);
        try {
            List result = em.createQuery(cq).getResultList();

            Assert.assertTrue("Equals test failed", comparer.compareObjects(expectedResult, result));
        } finally {
            rollbackTransaction(em);
            closeEntityManager(em);
        }
    }

    //Test case for equals with join in EJBQL

        CriteriaQuery<Employee> cq = qb.createQuery(Employee.class);
        Join managedEmp = cq.from(getEntityManagerFactory().getMetamodel().entity(Employee.class)).join(Employee_.managedEmployees);
        cq.where( qb.equal(managedEmp.get(Employee_.address).get(Address_.city), "Ottawa" ) );
        beginTransaction(em);
        try {
            List result = em.createQuery(cq).getResultList();

            Assert.assertTrue("Equals test with Join failed", comparer.compareObjects(result, expectedResult));
        } finally {
            rollbackTransaction(em);
            closeEntityManager(em);
        }
    }

    public void collectionMemberIdentifierEqualsTest() {

        CriteriaQuery<Employee> cq = qb.createQuery(Employee.class);
        Join phones = cq.from(getEntityManagerFactory().getMetamodel().entity(Employee.class)).join(Employee_.phoneNumbers);
        cq.where( qb.equal(phones, qb.parameter(PhoneNumber.class, "1") ) );
        beginTransaction(em);
        try {
            List result = em.createQuery(cq).setParameter("1", phoneNumber).getResultList();

            Assert.assertTrue("CollectionMemberIdentifierEqualsTest failed", comparer.compareObjects(expectedResult, result));
        } finally {
            rollbackTransaction(em);
            closeEntityManager(em);
        }
    }

    public void abstractSchemaIdentifierEqualsTest() {

        CriteriaQuery<Employee> cq = qb.createQuery(Employee.class);
        Root<Employee> root = cq.from(getEntityManagerFactory().getMetamodel().entity(Employee.class));
        cq.where( qb.equal(root, qb.parameter(Employee.class, "1") ) );
        beginTransaction(em);
        try {
            List result = em.createQuery(cq).setParameter("1", expectedResult).getResultList();

            Assert.assertTrue("abstractSchemaIdentifierEqualsTest failed", comparer.compareObjects(expectedResult, result));
        } finally {
            rollbackTransaction(em);
            closeEntityManager(em);
        }
    }

    public void abstractSchemaIdentifierNotEqualsTest() {

        CriteriaQuery<Employee> cq = qb.createQuery(Employee.class);
        Root<Employee> root = cq.from(getEntityManagerFactory().getMetamodel().entity(Employee.class));
        cq.where( qb.notEqual(root, qb.parameter(Employee.class, "1") ) );
        beginTransaction(em);
        try {
            List result = em.createQuery(cq).setParameter("1", emp).getResultList();

            Assert.assertTrue("abstractSchemaIdentifierNotEqualsTest failed", comparer.compareObjects(result, expectedResult));
        } finally {
            rollbackTransaction(em);
            closeEntityManager(em);
        }
    }

    public void simpleInOneDotTest() {

        Predicate firstAnd = qb.and( qb.equal(phone.get(PhoneNumber_.areaCode), empPhoneNumbers.getAreaCode()), 
                qb.equal(root.get(Employee_.firstName), expectedResult.getFirstName()));
        cq.where( qb.and(firstAnd, qb.equal(root.get(Employee_.lastName), expectedResult.getLastName())) );
        beginTransaction(em);
        try {
            Employee result = em.createQuery(cq).getSingleResult();

            Assert.assertTrue("Simple In Dot Test failed", comparer.compareObjects(result, expectedResult));
        } finally {
            rollbackTransaction(em);
            closeEntityManager(em);
        }
    }

    public void selectAverageQueryForByteColumnTest() {

        Root<Employee> root = cq.from(getEntityManagerFactory().getMetamodel().entity(Employee.class));
        //casting types again.  Avg takes a number, so Path<Object> won't compile
        cq.select( qb.avg( root.get(Employee_.salary) ) );
        beginTransaction(em);
        try {
            Object result = em.createQuery(cq).getSingleResult();

            Assert.assertTrue("AVG result type [" + result.getClass() + "] not of type Double", result.getClass() == Double.class);
        } finally {
            rollbackTransaction(em);
            closeEntityManager(em);
        }
    }

    public void simpleInTest() {

        CriteriaBuilder qb = em.getCriteriaBuilder();
        CriteriaQuery<Employee> cq = qb.createQuery(Employee.class);
        cq.where( qb.in(cq.from(getEntityManagerFactory().getMetamodel().entity(Employee.class)).get(Employee_.id)).value(expectedResult.getId()) );
        beginTransaction(em);
        try {
            List result = em.createQuery(cq).getResultList();

            Assert.assertTrue("Simple In Test failed", comparer.compareObjects(result, expectedResult));
        } finally {
            rollbackTransaction(em);
            closeEntityManager(em);
        }
    }
    
    public void simpleInListTest() {

        //passing a collection to IN might not be supported in criteria api, trying to get around it by hidding the type
        ParameterExpression exp = qb.parameter(List.class, "result");
        cq.where( qb.in(root.get(Employee_.id)).value(exp) );
        beginTransaction(em);
        try {
            List result = em.createQuery(cq).setParameter("result", expectedResultList).getResultList();

            Assert.assertTrue("Simple In Test failed", comparer.compareObjects(result, expectedResult));
        } finally {
            rollbackTransaction(em);
            closeEntityManager(em);
        }
    }

    public void simpleLengthTest() {

        CriteriaQuery<Employee> cq = qb.createQuery(Employee.class);
        Root<Employee> root = cq.from(getEntityManagerFactory().getMetamodel().entity(Employee.class));
        cq.where( qb.equal( qb.length(root.get(Employee_.firstName)) , expectedResult.getFirstName().length()) );
        beginTransaction(em);
        try {        
            List result = em.createQuery(cq).getResultList();

            Assert.assertTrue("Simple Length Test failed", comparer.compareObjects(result, expectedResult));
        } finally {
            rollbackTransaction(em);
            closeEntityManager(em);
        }
    }



        CriteriaQuery<Employee> cq = qb.createQuery(Employee.class);
        Root<Employee> root = cq.from(getEntityManagerFactory().getMetamodel().entity(Employee.class));
        cq.where( qb.like( root.get(Employee_.firstName), partialFirstName) );
        beginTransaction(em);
        try { 
            List result = em.createQuery(cq).getResultList();

            Assert.assertTrue("Simple Like Test failed", comparer.compareObjects(result, expectedResult));
        } finally {
            rollbackTransaction(em);
            closeEntityManager(em);
        }
    }

    public void simpleLikeTestWithParameter() {

        CriteriaQuery<Employee> cq = qb.createQuery(Employee.class);
        Root<Employee> root = cq.from(getEntityManagerFactory().getMetamodel().entity(Employee.class));
        cq.where( qb.like( root.get(Employee_.firstName), qb.parameter(String.class, "1")) );
        beginTransaction(em);
        try { 
            List result = em.createQuery(cq).setParameter("1", partialFirstName).getResultList();

            Assert.assertTrue("Simple Like Test with Parameter failed", comparer.compareObjects(result, expectedResult));
        } finally {
            rollbackTransaction(em);
            closeEntityManager(em);
        }
    }

    public void simpleLikeEscapeTestWithParameter() {

            patternString = "234 RUBY \\_Way";
            escChar = new Character('\\');
        }
        beginTransaction(em);
        try {
            List result = em.createQuery(cq).setParameter("pattern", patternString).setParameter("esc", escChar).getResultList();

            Assert.assertTrue("Simple Escape Underscore test failed", comparer.compareObjects(result, expectedResult));
        } finally {
            rollbackTransaction(em);
            closeEntityManager(em);
        }
    }

    public void simpleNotBetweenTest() {

        CriteriaQuery<Employee> cq = qb.createQuery(Employee.class);
        Root<Employee> root = cq.from(getEntityManagerFactory().getMetamodel().entity(Employee.class));
        cq.where( qb.not(qb.between(root.get(Employee_.id), emp1.getId(), emp2.getId())) );
        beginTransaction(em);
        try {
            List result = em.createQuery(cq).getResultList();

            Assert.assertTrue("Simple Not Between Test failed", comparer.compareObjects(result, expectedResult));
        } finally {
            rollbackTransaction(em);
            closeEntityManager(em);
        }
    }

    public void simpleNotEqualsVariablesInteger() {

        CriteriaBuilder qb = em.getCriteriaBuilder();
        CriteriaQuery<Employee> cq = qb.createQuery(Employee.class);
        cq.where( qb.notEqual(cq.from(getEntityManagerFactory().getMetamodel().entity(Employee.class)).get(Employee_.id), emp.getId()) );
        beginTransaction(em);
        try {
            List result = em.createQuery(cq).getResultList();

            Assert.assertTrue("Simple Like Test with Parameter failed", comparer.compareObjects(result, expectedResult));
        } finally {
            rollbackTransaction(em);
            closeEntityManager(em);
        }
    }

    public void simpleNotInTest() {

        CriteriaQuery<Employee> cq = qb.createQuery(Employee.class);
        Root<Employee> root = cq.from(getEntityManagerFactory().getMetamodel().entity(Employee.class));
        cq.where( qb.not(qb.in(root.get(Employee_.id)).value(emp.getId())) );
        beginTransaction(em);
        try {
            List result = em.createQuery(cq).getResultList();

            Assert.assertTrue("Simple Not In Test failed", comparer.compareObjects(result, expectedResult));
        } finally {
            rollbackTransaction(em);
            closeEntityManager(em);
        }
    }

    public void simpleNotLikeTest() {

        CriteriaQuery<Employee> cq = qb.createQuery(Employee.class);
        Root<Employee> root = cq.from(getEntityManagerFactory().getMetamodel().entity(Employee.class));
        cq.where( qb.notLike(root.get(Employee_.firstName), partialFirstName ) );
        beginTransaction(em);
        try {
            List result = em.createQuery(cq).getResultList();

            Assert.assertTrue("Simple Not Like Test failed", comparer.compareObjects(result, expectedResult));
        } finally {
            rollbackTransaction(em);
            closeEntityManager(em);
        }
    }

    public void simpleOrFollowedByAndTest() {

        Root<Employee> root = cq.from(getEntityManagerFactory().getMetamodel().entity(Employee.class));
        Predicate andOpp = qb.and(qb.equal(root.get(Employee_.id), emp2.getId()), qb.equal(root.get(Employee_.id), emp3.getId()));
        cq.where( qb.or( qb.equal(root.get(Employee_.id), emp1.getId()), andOpp ) );
        beginTransaction(em);
        try {
            List result = em.createQuery(cq).getResultList();

            Assert.assertTrue("Simple Or followed by And Test failed", comparer.compareObjects(result, expectedResult));
        } finally {
            rollbackTransaction(em);
            closeEntityManager(em);
        }
    }

    public void simpleOrFollowedByAndTestWithStaticNames() {

        javax.persistence.criteria.Expression empFName = root.get(Employee_.firstName);
        Predicate andOpp = qb.and(qb.equal(empFName, "Bob"), qb.equal(root.get(Employee_.lastName), "Smith"));
        cq.where( qb.or( qb.equal(empFName, "John"), andOpp ) );
        beginTransaction(em);
        try {
            List result = em.createQuery(cq).getResultList();

            Assert.assertTrue("Simple Or followed by And With Static Names Test failed", comparer.compareObjects(result, expectedResult));
        } finally {
            rollbackTransaction(em);
            closeEntityManager(em);
        }
    }

    public void simpleOrTest() {

        javax.persistence.criteria.Expression empId = root.get(Employee_.id);
        cq.where( qb.or( qb.equal(empId, emp1.getId()), qb.equal(empId, emp2.getId()) ) );

        beginTransaction(em);
        try {
            List result = em.createQuery(cq).getResultList();
            clearCache();

            Assert.assertTrue("Simple Or Test failed", comparer.compareObjects(result, expectedResult));
        } finally {
            rollbackTransaction(em);
            closeEntityManager(em);
        }
    }

    public void simpleParameterTest() {

        CriteriaQuery<Employee> cq = qb.createQuery(Employee.class);
        Root<Employee> root = cq.from(getEntityManagerFactory().getMetamodel().entity(Employee.class));
        cq.where( qb.equal(root.get(Employee_.firstName), qb.parameter(String.class,parameterName)) );
        beginTransaction(em);
        try {
            List result = em.createQuery(cq).setParameter(parameterName, expectedResult.getFirstName()).getResultList();

            Assert.assertTrue("Simple Parameter Test failed", comparer.compareObjects(result, expectedResult));
        } finally {
            rollbackTransaction(em);
            closeEntityManager(em);
        }
    }

    public void simpleParameterTestChangingParameters() {

        Root<Employee> root = cq.from(getEntityManagerFactory().getMetamodel().entity(Employee.class));
        cq.where( qb.equal(root.get(Employee_.firstName), qb.parameter(String.class, "1")) );

        beginTransaction(em);
        try {
            List firstResultSet = em.createQuery(cq).setParameter("1", firstParameters.get(0)).getResultList();
            clearCache();
            List secondResultSet = em.createQuery(cq).setParameter("1", secondParameters.get(0)).getResultList();
            clearCache();
            Vector result = new Vector();
            result.addAll(firstResultSet);
            result.addAll(secondResultSet);

            Assert.assertTrue("Simple Parameter Test Changing Parameters failed", comparer.compareObjects(result, expectedResult));
        } finally {
            rollbackTransaction(em);
            closeEntityManager(em);
        }
    }

    public void simpleReverseAbsTest() {

        Root<Employee> root = cq.from(getEntityManagerFactory().getMetamodel().entity(Employee.class));
        //equal can't take an int as the first argument, it must be an expression
        cq.where( qb.equal(qb.literal(expectedResult.getSalary()), qb.abs(root.get(Employee_.salary))) );
        beginTransaction(em);
        try {
            List result = em.createQuery(cq).getResultList();

            Assert.assertTrue("Simple Reverse Abs test failed", comparer.compareObjects(result, expectedResult));
        } finally {
            rollbackTransaction(em);
            closeEntityManager(em);
        }
    }

    public void simpleReverseConcatTest() {

        Root<Employee> root = cq.from(getEntityManagerFactory().getMetamodel().entity(Employee.class));
        //One argument to concat must be an expression
        cq.where( qb.equal(qb.concat(partOne, qb.literal(partTwo)), root.get(Employee_.firstName)) );
        beginTransaction(em);
        try {
            List result = em.createQuery(cq).getResultList();

            Assert.assertTrue("Simple Reverse Concat test failed", comparer.compareObjects(result, expectedResult));
        } finally {
            rollbackTransaction(em);
            closeEntityManager(em);
        }
    }

    public void simpleReverseEqualsTest() {

        CriteriaQuery<Employee> cq = qb.createQuery(Employee.class);
        Root<Employee> root = cq.from(getEntityManagerFactory().getMetamodel().entity(Employee.class));
        cq.where( qb.equal(qb.literal(expectedResult.getFirstName()), root.get(Employee_.firstName)) );
        beginTransaction(em);
        try {
            List result = em.createQuery(cq).getResultList();

            Assert.assertTrue("Simple Reverse Equals test failed", comparer.compareObjects(result, expectedResult));
        } finally {
            rollbackTransaction(em);
            closeEntityManager(em);
        }
    }

    public void simpleReverseLengthTest() {

        Root<Employee> root = cq.from(getEntityManagerFactory().getMetamodel().entity(Employee.class));
        javax.persistence.criteria.Expression<Integer> length = qb.length(root.get(Employee_.firstName));
        cq.where( qb.equal(qb.literal(expectedResult.getFirstName().length()), length) );
        beginTransaction(em);
        try {
            List result = em.createQuery(cq).getResultList();

            Assert.assertTrue("Simple Reverse Length test failed", comparer.compareObjects(result, expectedResult));
        } finally {
            rollbackTransaction(em);
            closeEntityManager(em);
        }
    }

    public void simpleReverseParameterTest() {

        CriteriaQuery<Employee> cq = qb.createQuery(Employee.class);
        Root<Employee> root = cq.from(getEntityManagerFactory().getMetamodel().entity(Employee.class));
        cq.where( qb.equal(qb.parameter(String.class, "1"), root.get(Employee_.firstName)) );
        beginTransaction(em);
        try {
            List result = em.createQuery(cq).setParameter("1", parameters.get(0)).getResultList();

            Assert.assertTrue("Simple Reverse Parameter test failed", comparer.compareObjects(result, expectedResult));
        } finally {
            rollbackTransaction(em);
            closeEntityManager(em);
        }
    }

    public void simpleReverseSqrtTest() {

        Root<Employee> root = cq.from(getEntityManagerFactory().getMetamodel().entity(Employee.class));
        javax.persistence.criteria.Expression<Double> sqrt = qb.sqrt(root.get(Employee_.salary));
        cq.where( qb.equal(qb.literal(salarySquareRoot), sqrt) );
        beginTransaction(em);
        try {
            List result = em.createQuery(cq).getResultList();

            Assert.assertTrue("Simple Reverse Square Root test failed", comparer.compareObjects(result, expectedResult));
        } finally {
            rollbackTransaction(em);
            closeEntityManager(em);
        }
    }

    public void simpleReverseSubstringTest() {

        Root<Employee> root = cq.from(getEntityManagerFactory().getMetamodel().entity(Employee.class));
        javax.persistence.criteria.Expression<String> substring = qb.substring(root.get(Employee_.firstName), 1, 2);
        cq.where( qb.equal(qb.literal(firstNamePart), substring) );
        beginTransaction(em);
        try {
            List result = em.createQuery(cq).getResultList();

            Assert.assertTrue("Simple Reverse SubString test failed", comparer.compareObjects(result, expectedResult));
        } finally {
            rollbackTransaction(em);
            closeEntityManager(em);
        }
    }



        CriteriaQuery<Employee> cq = qb.createQuery(Employee.class);
        Root<Employee> root = cq.from(getEntityManagerFactory().getMetamodel().entity(Employee.class));
        cq.where( qb.equal(qb.sqrt(root.get(Employee_.salary)), salarySquareRoot) );
        beginTransaction(em);
        try {
            List result = em.createQuery(cq).getResultList();

            Assert.assertTrue("Simple Square Root test failed", comparer.compareObjects(result, expectedResult));
        } finally {
            rollbackTransaction(em);
            closeEntityManager(em);
        }
    }

    public void simpleSubstringTest() {

        Root<Employee> root = cq.from(getEntityManagerFactory().getMetamodel().entity(Employee.class));
        javax.persistence.criteria.Expression<String> substring = qb.substring(root.get(Employee_.firstName), 1, 2);
        cq.where( qb.equal(substring, firstNamePart) );
        beginTransaction(em);
        try {
            List result = em.createQuery(cq).getResultList();
            Assert.assertTrue("Simple SubString test failed", comparer.compareObjects(result, expectedResult));
        } finally {
            rollbackTransaction(em);
            closeEntityManager(em);
        }
    }

    public void simpleNullTest() {

        CriteriaBuilder qb = em.getCriteriaBuilder();
        CriteriaQuery<Employee> cq = qb.createQuery(Employee.class);
        cq.where( qb.isNull(cq.from(getEntityManagerFactory().getMetamodel().entity(Employee.class)).get(Employee_.firstName)) );
        beginTransaction(em);
        try {
            List result = em.createQuery(cq).getResultList();

            uow = clientSession.acquireUnitOfWork();
            uow.deleteObject(nullEmployee);
            uow.commit();

            Assert.assertTrue("Simple Null test failed", comparer.compareObjects(result, expectedResult));
        } finally {
            rollbackTransaction(em);
            closeEntityManager(em);
        }

    }

    public void simpleNotNullTest() {

        CriteriaBuilder qb = em.getCriteriaBuilder();
        CriteriaQuery<Employee> cq = qb.createQuery(Employee.class);
        cq.where( qb.isNotNull(cq.from(getEntityManagerFactory().getMetamodel().entity(Employee.class)).get(Employee_.firstName)) );
        beginTransaction(em);
        try {
            List result = em.createQuery(cq).getResultList();

            uow = clientSession.acquireUnitOfWork();
            uow.deleteObject(nullEmployee);
            uow.commit();

            Assert.assertTrue("Simple Not Null test failed", comparer.compareObjects(result, expectedResult));
        } finally {
            rollbackTransaction(em);
            closeEntityManager(em);
        }
    }

    public void distinctTest() {

        CriteriaQuery<Employee> cq = qb.createQuery(Employee.class);
        cq.distinct(true);
        cq.where( qb.equal(cq.from(getEntityManagerFactory().getMetamodel().entity(Employee.class)).get(Employee_.lastName), "Smith") );
        beginTransaction(em);
        try {
            List result = em.createQuery(cq).getResultList();

            Assert.assertTrue("Distinct test failed", comparer.compareObjects(result, expectedResult));
        } finally {
            rollbackTransaction(em);
            closeEntityManager(em);
        }
    }

    public void multipleExecutionOfCriteriaQueryTest() {
        //bug 5279859
        EntityManager em = createEntityManager();
        //"SELECT e FROM Employee e where e.address.postalCode = :postalCode"
        beginTransaction(em);
        CriteriaQuery<Employee> cq = qb.createQuery(Employee.class);
        Root<Employee> root = cq.from(getEntityManagerFactory().getMetamodel().entity(Employee.class));
        cq.where( qb.equal(root.get(Employee_.address).get(Address_.postalCode), qb.parameter(String.class, "postalCode")) );
        Query query = em.createQuery(cq);
        query.setParameter("postalCode", "K1T3B9");
        try {
            CriteriaBuilder qb = em.getCriteriaBuilder();
            CriteriaQuery<Employee> cq = qb.createQuery(Employee.class);
            Root<Employee> root = cq.from(getEntityManagerFactory().getMetamodel().entity(Employee.class));
            cq.where( qb.equal(root.get(Employee_.address).get(Address_.postalCode), qb.parameter(String.class, "postalCode")) );
            Query query = em.createQuery(cq);
            query.setParameter("postalCode", "K1T3B9");
            try {
                query.getResultList();
            } catch (RuntimeException ex) {
                fail("Failed to execute query, exception resulted on first execution, not expected");
            }
            try {
                query.getResultList();
            } catch (RuntimeException ex) {
                fail("Failed to execute query, exception resulted on second execution");
            }
            query = em.createNamedQuery("findEmployeeByPostalCode");
            query.setParameter("postalCode", "K1T3B9");
            try {
                query.getResultList();
            } catch (RuntimeException ex) {
                fail("Failed to execute query, exception resulted on first execution, of second use of named query");
            }
            query.setMaxResults(100000);
            try {
                query.getResultList();
            } catch (RuntimeException ex) {
                fail("Failed to execute query, exception resulted after setting max results (forcing reprepare)");
            }
        } finally {
            rollbackTransaction(em);
            closeEntityManager(em);
        }
        try {
            query.getResultList();
        } catch (RuntimeException ex) {
            fail("Failed to execute query, exception resulted on second execution");
        }
        query = em.createNamedQuery("findEmployeeByPostalCode");
        query.setParameter("postalCode", "K1T3B9");
        try {
            query.getResultList();
        } catch (RuntimeException ex) {
            fail("Failed to execute query, exception resulted on first execution, of second use of named query");
        }
        query.setMaxResults(100000);
        try {
            query.getResultList();
        } catch (RuntimeException ex) {
            fail("Failed to execute query, exception resulted after setting max results (forcing reprepare)");
        }

    }

    public void simpleModTest() {

        CriteriaQuery<Employee> cq = qb.createQuery(Employee.class);
        Root<Employee> root = cq.from(getEntityManagerFactory().getMetamodel().entity(Employee.class));
        cq.where( qb.gt(qb.mod(root.get(Employee_.salary), 2), 0) );
        List result = null;

        beginTransaction(em);
        try {
            result = em.createQuery(cq).getResultList();

            Assert.assertTrue("Simple Mod test failed", comparer.compareObjects(result, expectedResult));
        } finally {
            rollbackTransaction(em);
        }
        // Test MOD(fieldAccess, fieldAccess) glassfish issue 2771

        expectedResult = getServerSession().readAllObjects(Employee.class);
        clearCache();
        

        root = cq.from(getEntityManagerFactory().getMetamodel().entity(Employee.class));
        javax.persistence.criteria.Expression<Integer> salaryExp = root.get(Employee_.salary);
        cq.where( qb.equal(qb.mod(salaryExp, salaryExp), 0) );
        beginTransaction(em);
        try {
            result = em.createQuery(cq).getResultList();

            Assert.assertTrue("Simple Mod test(2) failed", comparer.compareObjects(result, expectedResult));  
        } finally {
            rollbackTransaction(em);
            closeEntityManager(em);
        }
    }

    public void simpleIsEmptyTest() {

        CriteriaQuery<Employee> cq = qb.createQuery(Employee.class);
        Root<Employee> root = cq.from(getEntityManagerFactory().getMetamodel().entity(Employee.class));
        cq.where( qb.isEmpty(root.get(Employee_.phoneNumbers)) );
        beginTransaction(em);
        try {
            List result = em.createQuery(cq).getResultList();

            Assert.assertTrue("Simple Is empty test failed", comparer.compareObjects(result, expectedResult));
        } finally {
            rollbackTransaction(em);
            closeEntityManager(em);
        }
    }

    public void simpleIsNotEmptyTest() {

        CriteriaBuilder qb = em.getCriteriaBuilder();
        CriteriaQuery<Employee> cq = qb.createQuery(Employee.class);
        cq.where( qb.isNotEmpty(cq.from(getEntityManagerFactory().getMetamodel().entity(Employee.class)).get(Employee_.phoneNumbers)) );
        beginTransaction(em);
        try {
            List result = em.createQuery(cq).getResultList();

            Assert.assertTrue("Simple is not empty test failed", comparer.compareObjects(result, expectedResult));
        } finally {
            rollbackTransaction(em);
            closeEntityManager(em);
        }
    }

    //JPQL parsing test, not applicable to criteria api

        CriteriaQuery<Address> cq = qb.createQuery(Address.class);
        Root<Address> root = cq.from(getEntityManagerFactory().getMetamodel().entity(Address.class));
        cq.where( qb.like(root.get(Address_.street), "234 Wandering "+escapeChar+"_Way", escapeChar) );
        beginTransaction(em);
        try {
            List result = em.createQuery(cq).getResultList();

            Assert.assertTrue("Simple Escape Underscore test failed", comparer.compareObjects(result, expectedResult));
        } finally {
            rollbackTransaction(em);
            closeEntityManager(em);
        }
    }

    public void smallProjectMemberOfProjectsTest() {

        //"SELECT OBJECT(employee) FROM Employee employee, SmallProject sp WHERE sp MEMBER OF employee.projects";
        CriteriaBuilder qb = em.getCriteriaBuilder();
        CriteriaQuery<Employee> cq = qb.createQuery(Employee.class);
        Root<SmallProject> projRoot = cq.from(getEntityManagerFactory().getMetamodel().entity(SmallProject.class));

        Root<Employee> empRoot = cq.from(getEntityManagerFactory().getMetamodel().entity(Employee.class));
        cq.where(qb.isMember(projRoot.as(Project.class), empRoot.get(Employee_.projects)) );
        beginTransaction(em);
        try {
            List result = em.createQuery(cq).getResultList();

            Assert.assertTrue("Simple small Project Member Of Projects test failed", comparer.compareObjects(result, expectedResult));
        } finally {
            rollbackTransaction(em);
            closeEntityManager(em);
        }
    }

    public void smallProjectNOTMemberOfProjectsTest() {

        CriteriaBuilder qb = em.getCriteriaBuilder();
        CriteriaQuery<Employee> cq = qb.createQuery(Employee.class);
        cq.where( qb.isNotMember(qb.parameter(Project.class, "1"), cq.from(getEntityManagerFactory().getMetamodel().entity(Employee.class)).get(Employee_.projects)) );
        beginTransaction(em);
        try {
            List result = em.createQuery(cq).setParameter("1", smallProject).getResultList();

            Assert.assertTrue("Simple small Project NOT Member Of Projects test failed", comparer.compareObjects(result, expectedResult));
        } finally {
            rollbackTransaction(em);
            closeEntityManager(em);
        }
    }

    //This test demonstrates the bug 4616218, waiting for bug fix

        CriteriaBuilder qb = em.getCriteriaBuilder();
        CriteriaQuery<Long> cq = qb.createQuery(Long.class);
        cq.select(qb.countDistinct(cq.from(getEntityManagerFactory().getMetamodel().entity(PhoneNumber.class)).get(PhoneNumber_.owner)));
        beginTransaction(em);
        try {
            List result = em.createQuery(cq).getResultList();

            Assert.assertTrue("Simple Select Count One To One test failed", expectedResult.elementAt(0).equals(result.get(0)));
        } finally {
            rollbackTransaction(em);
            closeEntityManager(em);
        }
    }

    public void selectOneToOneTest() {

        cq.distinct(true);
        cq.select(root.get(Employee_.address));
        cq.where(qb.like(root.get(Employee_.lastName), "%Way%"));
        beginTransaction(em);
        try {
            List result = em.createQuery(cq).getResultList();

            Assert.assertTrue("Simple Select One To One test failed", comparer.compareObjects(result, expectedResult));
        } finally {
            rollbackTransaction(em);
            closeEntityManager(em);
        }
    }

    public void selectPhonenumberDeclaredInINClauseTest() {

        CriteriaQuery<PhoneNumber> cq = qb.createQuery(PhoneNumber.class);
        Root<Employee> root = cq.from(getEntityManagerFactory().getMetamodel().entity(Employee.class));
        Join phone = root.join(Employee_.phoneNumbers);
        cq.select(phone);
        cq.where(qb.isNotNull(phone.get(PhoneNumber_.number)));
        cq.orderBy(qb.asc(phone.get(PhoneNumber_.number)), qb.asc(phone.get(PhoneNumber_.areaCode)));
        beginTransaction(em);
        try {
            List result = em.createQuery(cq).getResultList();

            Assert.assertTrue("Simple select Phonenumber Declared In IN Clause test failed", comparer.compareObjects(result, expectedResult));
        } finally {
            rollbackTransaction(em);
            closeEntityManager(em);
        }
    }

    /**

        Root<Employee> root = cq.from(getEntityManagerFactory().getMetamodel().entity(Employee.class));
        Join phone = root.join("phoneNumbers");
        cq.where(qb.equal(root.get("number"), qb.all(sq)));
        beginTransaction(em);
        try {
            List result = em.createQuery(cq).getResultList();

            Assert.assertTrue("Simple select Phonenumber Declared In IN Clause test failed", comparer.compareObjects(result, expectedResult));
        } finally {
            rollbackTransaction(em);
            closeEntityManager(em);
        }
    }*/

    /**

        clearCache();

        //"Select Distinct Object(emp) from Employee emp, IN(emp.phoneNumbers) p WHERE p.number = ALL (Select MIN(pp.number) FROM PhoneNumber pp)";
        beginTransaction(em);
        try {
            CriteriaBuilder qb = em.getCriteriaBuilder();
            CriteriaQuery<Employee> cq = qb.createQuery(Employee.class);
            cq.distinct(true);
            Subquery<Number> sq = cq.subquery(Number.class);
            Root<PhoneNumber> subroot = sq.from(PhoneNumber.class);
            sq.select(qb.min(subroot.<Number>get("number")));//number is a string? not sure this will work.
        
            Root<Employee> root = cq.from(getEntityManagerFactory().getMetamodel().entity(Employee.class));
            Join phone = root.join(Employee_.phoneNumbers);
            cq.where(qb.equal(phone.get(PhoneNumber_.number), qb.all(sq)));

            Query jpqlQuery = em.createQuery(cq);
        jpqlQuery.setMaxResults(10);
        List result = jpqlQuery.getResultList();

            jpqlQuery.setMaxResults(10);
            List result = jpqlQuery.getResultList();
            Assert.assertTrue("Simple select Phonenumber Declared In IN Clause test failed", comparer.compareObjects(result, expectedResult));
        } finally {
            rollbackTransaction(em);
            closeEntityManager(em);
        }
    }

    public void selectSimpleMemberOfWithParameterTest() {

        Vector parameters = new Vector();
        parameters.add(phone);

        beginTransaction(em);
        try {
            List result = em.createQuery(cq).setParameter("1", phone).getResultList();
            Assert.assertTrue("Select simple member of with parameter test failed", comparer.compareObjects(result, expectedResult));
        } finally {
            rollbackTransaction(em);
            closeEntityManager(em);
        }

        uow = clientSession.acquireUnitOfWork();
        uow.deleteObject(phone);
        uow.commit();

        Assert.assertTrue("Select simple member of with parameter test failed", comparer.compareObjects(result, expectedResult));
    }

    public void selectSimpleNotMemberOfWithParameterTest() {

        CriteriaBuilder qb = em.getCriteriaBuilder();
        CriteriaQuery<Employee> cq = qb.createQuery(Employee.class);
        Root<Employee> root = cq.from(getEntityManagerFactory().getMetamodel().entity(Employee.class));
        cq.where(qb.isNotMember(qb.parameter(PhoneNumber.class, "1"), root.get(Employee_.phoneNumbers)));

        Vector parameters = new Vector();
        parameters.add(phone);

        beginTransaction(em);
        try {
            List result = em.createQuery(cq).setParameter("1", phone).getResultList();

            Assert.assertTrue("Select simple Not member of with parameter test failed", comparer.compareObjects(result, expectedResult));
        } finally {
            rollbackTransaction(em);
            closeEntityManager(em);
        }

        uow = clientSession.acquireUnitOfWork();
        uow.deleteObject(phone);
        uow.commit();

        Assert.assertTrue("Select simple Not member of with parameter test failed", comparer.compareObjects(result, expectedResult));
    }

    public void selectSimpleBetweenWithParameterTest() {

        CriteriaQuery<Employee> cq = qb.createQuery(Employee.class);
        Root<Employee> root = cq.from(getEntityManagerFactory().getMetamodel().entity(Employee.class));
        cq.where(qb.between(root.get(Employee_.id).as(Comparable.class), qb.parameter(BigDecimal.class, "1"), qb.parameter(Integer.class, "2")));
        beginTransaction(em);
        try {
            List result = em.createQuery(cq).setParameter("1", empId1).setParameter("2", emp2.getId()).getResultList();

            Assert.assertTrue("Simple select between with parameter test failed", comparer.compareObjects(result, expectedResult));
        } finally {
            rollbackTransaction(em);
            closeEntityManager(em);
        }
    }

    public void selectSimpleInWithParameterTest() {

        inExp.value(qb.parameter(BigDecimal.class, "1"));
        inExp.value(qb.parameter(Integer.class, "2"));
        cq.where(inExp);
        beginTransaction(em);
        try {
            List result = em.createQuery(cq).setParameter("1", empId1).setParameter("2", emp2.getId()).getResultList();

            Assert.assertTrue("Simple select between with parameter test failed", comparer.compareObjects(result, expectedResult));
        } finally {
            rollbackTransaction(em);
            closeEntityManager(em);
        }
    }

    //Test case for ABS function in EJBQL

        CriteriaBuilder qb = em.getCriteriaBuilder();
        CriteriaQuery<Employee> cq = qb.createQuery(Employee.class);
        cq.where(qb.equal(cq.from(getEntityManagerFactory().getMetamodel().entity(Employee.class)).get(Employee_.status), org.eclipse.persistence.testing.models.jpa.advanced.Employee.EmployeeStatus.FULL_TIME));
        beginTransaction(em);
        try {
            List result = em.createQuery(cq).getResultList();
        } finally {
            rollbackTransaction(em);
            closeEntityManager(em);
        }
    }

    public void simpleTypeTest(){

        CriteriaBuilder qb = em.getCriteriaBuilder();
        CriteriaQuery<Project> cq = qb.createQuery(Project.class);
        cq.where(qb.equal(cq.from(getEntityManagerFactory().getMetamodel().entity(Project.class)).type(), org.eclipse.persistence.testing.models.jpa.advanced.LargeProject.class));
        beginTransaction(em);
        try {
            List result = em.createQuery(cq).getResultList();

            Assert.assertTrue("SimpleTypeTest", comparer.compareObjects(result, expectedResult));
        } finally {
            rollbackTransaction(em);
            closeEntityManager(em);
        }
    }
    
    public void simpleAsOrderByTest(){

        Root<Employee> root = cq.from(getEntityManagerFactory().getMetamodel().entity(Employee.class));
        cq.select(root.get(Employee_.firstName));
        cq.orderBy(qb.asc(root.get(Employee_.firstName)));
        beginTransaction(em);
        try {
            List result = em.createQuery(cq).getResultList();

            Assert.assertTrue("SimpleTypeTest", comparer.compareObjects(result, expectedResult));
        } finally {
            rollbackTransaction(em);
            closeEntityManager(em);
        }
    }
}





            <exclude name="org/eclipse/persistence/testing/models/jpa/advanced/**"/>
            <exclude name="org/eclipse/persistence/testing/tests/jpa/FullRegressionTestSuite.java"/>
            <exclude name="org/eclipse/persistence/testing/tests/jpa/AllCMP3TestRunModel.java"/>
            <exclude name="org/eclipse/persistence/testing/tests/jpa/criteria/CriteriaServerTestSuite.java"/>
            <classpath>
                <path refid="compile.path"/>
            </classpath>

               failonerror="true">
            <include name="org/eclipse/persistence/testing/tests/jpa/FullRegressionTestSuite.java"/>
            <include name="org/eclipse/persistence/testing/tests/jpa/AllCMP3TestRunModel.java"/>
            <include name="org/eclipse/persistence/testing/tests/jpa/criteria/CriteriaServerTestSuite.java"/>
            <classpath>
                <path refid="compile.path"/>
            </classpath>

            target="${javac.version}"
            deprecation="${javac.deprecation}"
            failonerror="true"
            includes="${TEST_DIR}/**/*.java"
			excludes="org/eclipse/persistence/testing/tests/jpa/criteria/CriteriaServerTestSuite.java">
            <classpath refid="compile.server.path"/>
        </javac>
        <javac

            target="${javac.version}"
            deprecation="${javac.deprecation}"
            failonerror="true"
            includes="${TEST_DIR}/**/*.java"
			excludes="org/eclipse/persistence/testing/tests/jpa/criteria/CriteriaServerTestSuite.java">
            <classpath refid="compile.server.path"/>
        </javac>
        <javac

            <include name="*.xml"/>
        </replace>

        <!-- Copy the canonical metamodel and criteria api test -->
        <antcall target="copy_criteria_api_canonical_model" inheritRefs="true"/>
        <!-- Create ejb jar. -->
        <jar destfile="${eclipselink.jpa.test}/${build.dir}/${MODEL_NAME}_ejb.jar" basedir="stage"/>
        <antcall target="create-ejb-stubs" inheritRefs="true"/>
        <delete dir="stage"/>
    </target>

    <target name="copy_criteria_api_canonical_model" if="is.criteria.server.test">
        <!-- Coping the CriteriaServerTestSuite class -->
        <antcall target="compile"/>
        <copy todir="${eclipselink.jpa.test}/stage">
            <fileset dir="${eclipselink.jpa.test}/classes">
                <include name="org/eclipse/persistence/testing/tests/jpa/criteria/CriteriaServerTestSuite.class"/>
                <include name="org/eclipse/persistence/testing/tests/jpa/criteria/metamodel/JUnitCriteriaSimpleTestSuite.class"/>
                <include name="org/eclipse/persistence/testing/models/jpa/advanced/*.class"/>
            </fileset>
        </copy>
    </target>

    <target name="create-ejb-stubs" depends="detect-os" if="is.websphere">
        <exec executable="${was.home}/bin/createEJBStubs.${suffix}">
            <arg line="${eclipselink.jpa.test}/${build.dir}/${MODEL_NAME}_ejb.jar"/>

    </target>

    <target name="server-test-criteria">
        <property name="is.criteria.server.test" value="true"/>
        <antcall target="server-run-all" inheritRefs="true">
            <param name="PERSISTENCE_UNIT_NAME" value="default"/>
            <param name="MODEL_DIR" value="org/eclipse/persistence/testing/models/jpa/advanced"/>




    public static Test suite() {
        TestSuite suite = new TestSuite();
        suite.setName("Criteria ServerTestSuite");
        suite.addTest(AdvancedCompositePKJunitTest.suite());
        suite.addTest(AdvancedCriteriaQueryTestSuite.suite());
        suite.addTest(AdvancedQueryTestSuite.suite());
        suite.addTest(JUnitCriteriaSimpleTestSuite.suite());
        suite.addTest(JUnitCriteriaUnitTestSuite.suite());
        suite.addTest(org.eclipse.persistence.testing.tests.jpa.criteria.metamodel.JUnitCriteriaSimpleTestSuite.suite());  
        
        return suite;
    }





    public void simpleLikeEscapeTestWithParameter() {
        EntityManager em = createEntityManager();

        try {
            Address expectedResult = new Address();
            expectedResult.setCity("TAIYUAN");
            expectedResult.setCountry("CHINA");

                patternString = "234 RUBY \\_Way";
                escChar = new Character('\\');
            }
        beginTransaction(em);
        try {
            List result = em.createQuery(cq).setParameter("pattern", patternString).setParameter("esc", escChar).getResultList();

            Assert.assertTrue("Simple Escape Underscore test failed", comparer.compareObjects(result, expectedResult));

Lines 210-216 Link Here

(-)jpa/eclipselink.jpa.test/src/org/eclipse/persistence/testing/tests/jpa/FullRegressionTestSuite.java (-1 / +1 lines)
210	suite.addTest(org.eclipse.persistence.testing.tests.jpa.criteria.AdvancedCriteriaQueryTestSuite.suite());	210	suite.addTest(org.eclipse.persistence.testing.tests.jpa.criteria.AdvancedCriteriaQueryTestSuite.suite());
211	suite.addTest(org.eclipse.persistence.testing.tests.jpa.criteria.AdvancedQueryTestSuite.suite());	211	suite.addTest(org.eclipse.persistence.testing.tests.jpa.criteria.AdvancedQueryTestSuite.suite());
212	suite.addTest(org.eclipse.persistence.testing.tests.jpa.criteria.JUnitCriteriaSimpleTestSuite.suite());	212	suite.addTest(org.eclipse.persistence.testing.tests.jpa.criteria.JUnitCriteriaSimpleTestSuite.suite());
213	//suite.addTest(org.eclipse.persistence.testing.tests.jpa.criteria.metamodel.JUnitCriteriaSimpleTestSuite.suite());	213	suite.addTest(org.eclipse.persistence.testing.tests.jpa.criteria.metamodel.JUnitCriteriaSimpleTestSuite.suite());
214	fullSuite.addTest(suite);	214	fullSuite.addTest(suite);
215		215
216	// JPA 2.0 Cacheable model	216	// JPA 2.0 Cacheable model

Return to bug 293708

Lines 330-335 Link Here

(-)jpa/eclipselink.jpa.test/build.xml (-2 / +21 lines)
330	<exclude name="org/eclipse/persistence/testing/models/jpa/advanced/**"/>	330	<exclude name="org/eclipse/persistence/testing/models/jpa/advanced/**"/>
331	<exclude name="org/eclipse/persistence/testing/tests/jpa/FullRegressionTestSuite.java"/>	331	<exclude name="org/eclipse/persistence/testing/tests/jpa/FullRegressionTestSuite.java"/>
332	<exclude name="org/eclipse/persistence/testing/tests/jpa/AllCMP3TestRunModel.java"/>	332	<exclude name="org/eclipse/persistence/testing/tests/jpa/AllCMP3TestRunModel.java"/>
		333	<exclude name="org/eclipse/persistence/testing/tests/jpa/criteria/CriteriaServerTestSuite.java"/>
333	<classpath>	334	<classpath>
334	<path refid="compile.path"/>	335	<path refid="compile.path"/>
335	</classpath>	336	</classpath>
Lines 348-353 Link Here
348	failonerror="true">	349	failonerror="true">
349	<include name="org/eclipse/persistence/testing/tests/jpa/FullRegressionTestSuite.java"/>	350	<include name="org/eclipse/persistence/testing/tests/jpa/FullRegressionTestSuite.java"/>
350	<include name="org/eclipse/persistence/testing/tests/jpa/AllCMP3TestRunModel.java"/>	351	<include name="org/eclipse/persistence/testing/tests/jpa/AllCMP3TestRunModel.java"/>
		352	<include name="org/eclipse/persistence/testing/tests/jpa/criteria/CriteriaServerTestSuite.java"/>
351	<classpath>	353	<classpath>
352	<path refid="compile.path"/>	354	<path refid="compile.path"/>
353	</classpath>	355	</classpath>
Lines 1375-1381 Link Here
1375	target="${javac.version}"	1377	target="${javac.version}"
1376	deprecation="${javac.deprecation}"	1378	deprecation="${javac.deprecation}"
1377	failonerror="true"	1379	failonerror="true"
1378	includes="${TEST_DIR}/*/.java">	1380	includes="${TEST_DIR}/*/.java"
		1381	excludes="org/eclipse/persistence/testing/tests/jpa/criteria/CriteriaServerTestSuite.java">
1379	<classpath refid="compile.server.path"/>	1382	<classpath refid="compile.server.path"/>
1380	</javac>	1383	</javac>
1381	<javac	1384	<javac
Lines 1432-1438 Link Here
1432	target="${javac.version}"	1435	target="${javac.version}"
1433	deprecation="${javac.deprecation}"	1436	deprecation="${javac.deprecation}"
1434	failonerror="true"	1437	failonerror="true"
1435	includes="${TEST_DIR}/*/.java">	1438	includes="${TEST_DIR}/*/.java"
		1439	excludes="org/eclipse/persistence/testing/tests/jpa/criteria/CriteriaServerTestSuite.java">
1436	<classpath refid="compile.server.path"/>	1440	<classpath refid="compile.server.path"/>
1437	</javac>	1441	</javac>
1438	<javac	1442	<javac
Lines 1540-1551 Link Here
1540	<include name="*.xml"/>	1544	<include name="*.xml"/>
1541	</replace>	1545	</replace>
1542		1546
		1547	<!-- Copy the canonical metamodel and criteria api test -->
		1548	<antcall target="copy_criteria_api_canonical_model" inheritRefs="true"/>
1543	<!-- Create ejb jar. -->	1549	<!-- Create ejb jar. -->
1544	<jar destfile="${eclipselink.jpa.test}/${build.dir}/${MODEL_NAME}_ejb.jar" basedir="stage"/>	1550	<jar destfile="${eclipselink.jpa.test}/${build.dir}/${MODEL_NAME}_ejb.jar" basedir="stage"/>
1545	<antcall target="create-ejb-stubs" inheritRefs="true"/>	1551	<antcall target="create-ejb-stubs" inheritRefs="true"/>
1546	<delete dir="stage"/>	1552	<delete dir="stage"/>
1547	</target>	1553	</target>
1548		1554
		1555	<target name="copy_criteria_api_canonical_model" if="is.criteria.server.test">
		1556	<!-- Coping the CriteriaServerTestSuite class -->
		1557	<antcall target="compile"/>
		1558	<copy todir="${eclipselink.jpa.test}/stage">
		1559	<fileset dir="${eclipselink.jpa.test}/classes">
		1560	<include name="org/eclipse/persistence/testing/tests/jpa/criteria/CriteriaServerTestSuite.class"/>
		1561	<include name="org/eclipse/persistence/testing/tests/jpa/criteria/metamodel/JUnitCriteriaSimpleTestSuite.class"/>
		1562	<include name="org/eclipse/persistence/testing/models/jpa/advanced/*.class"/>
		1563	</fileset>
		1564	</copy>
		1565	</target>
		1566
1549	<target name="create-ejb-stubs" depends="detect-os" if="is.websphere">	1567	<target name="create-ejb-stubs" depends="detect-os" if="is.websphere">
1550	<exec executable="${was.home}/bin/createEJBStubs.${suffix}">	1568	<exec executable="${was.home}/bin/createEJBStubs.${suffix}">
1551	<arg line="${eclipselink.jpa.test}/${build.dir}/${MODEL_NAME}_ejb.jar"/>	1569	<arg line="${eclipselink.jpa.test}/${build.dir}/${MODEL_NAME}_ejb.jar"/>
Lines 1741-1746 Link Here
1741	</target>	1759	</target>
1742		1760
1743	<target name="server-test-criteria">	1761	<target name="server-test-criteria">
		1762	<property name="is.criteria.server.test" value="true"/>
1744	<antcall target="server-run-all" inheritRefs="true">	1763	<antcall target="server-run-all" inheritRefs="true">
1745	<param name="PERSISTENCE_UNIT_NAME" value="default"/>	1764	<param name="PERSISTENCE_UNIT_NAME" value="default"/>
1746	<param name="MODEL_DIR" value="org/eclipse/persistence/testing/models/jpa/advanced"/>	1765	<param name="MODEL_DIR" value="org/eclipse/persistence/testing/models/jpa/advanced"/>

Lines 23-33 Link Here

(-)jpa/eclipselink.jpa.test/src/org/eclipse/persistence/testing/tests/jpa/criteria/CriteriaServerTestSuite.java (-3 / +4 lines)
23	public static Test suite() {	23	public static Test suite() {
24	TestSuite suite = new TestSuite();	24	TestSuite suite = new TestSuite();
25	suite.setName("Criteria ServerTestSuite");	25	suite.setName("Criteria ServerTestSuite");
26	// suite.addTest(AdvancedCompositePKJunitTest.suite());	26	suite.addTest(AdvancedCompositePKJunitTest.suite());
27	suite.addTest(AdvancedCriteriaQueryTestSuite.suite());	27	suite.addTest(AdvancedCriteriaQueryTestSuite.suite());
28	// suite.addTest(AdvancedQueryTestSuite.suite());	28	suite.addTest(AdvancedQueryTestSuite.suite());
29	// suite.addTest(JUnitCriteriaSimpleTestSuite.suite());	29	suite.addTest(JUnitCriteriaSimpleTestSuite.suite());
30	suite.addTest(JUnitCriteriaUnitTestSuite.suite());	30	suite.addTest(JUnitCriteriaUnitTestSuite.suite());
		31	suite.addTest(org.eclipse.persistence.testing.tests.jpa.criteria.metamodel.JUnitCriteriaSimpleTestSuite.suite());
31		32
32	return suite;	33	return suite;
33	}	34	}

Lines 1014-1021 Link Here

(-)jpa/eclipselink.jpa.test/src/org/eclipse/persistence/testing/tests/jpa/criteria/JUnitCriteriaSimpleTestSuite.java (-3 / +3 lines)
1014		1014
1015	public void simpleLikeEscapeTestWithParameter() {	1015	public void simpleLikeEscapeTestWithParameter() {
1016	EntityManager em = createEntityManager();	1016	EntityManager em = createEntityManager();
1017	beginTransaction(em);	1017
1018	try {
1019	Address expectedResult = new Address();	1018	Address expectedResult = new Address();
1020	expectedResult.setCity("TAIYUAN");	1019	expectedResult.setCity("TAIYUAN");
1021	expectedResult.setCountry("CHINA");	1020	expectedResult.setCountry("CHINA");
Lines 1046-1052 Link Here
1046	patternString = "234 RUBY \\_Way";	1045	patternString = "234 RUBY \\_Way";
1047	escChar = new Character('\\');	1046	escChar = new Character('\\');
1048	}	1047	}
1049		1048	beginTransaction(em);
		1049	try {
1050	List result = em.createQuery(cq).setParameter("pattern", patternString).setParameter("esc", escChar).getResultList();	1050	List result = em.createQuery(cq).setParameter("pattern", patternString).setParameter("esc", escChar).getResultList();
1051		1051
1052	Assert.assertTrue("Simple Escape Underscore test failed", comparer.compareObjects(result, expectedResult));	1052	Assert.assertTrue("Simple Escape Underscore test failed", comparer.compareObjects(result, expectedResult));