/*******************************************************************************
* Copyright (c) 1998, 2015 Oracle and/or its affiliates. All rights reserved.
* This program and the accompanying materials are made available under the
* terms of the Eclipse Public License v1.0 and Eclipse Distribution License v. 1.0
* which accompanies this distribution.
* The Eclipse Public License is available at http://www.eclipse.org/legal/epl-v10.html
* and the Eclipse Distribution License is available at
* http://www.eclipse.org/org/documents/edl-v10.php.
*
* Contributors:
* Oracle - initial API and implementation from Oracle TopLink
******************************************************************************/
package org.eclipse.persistence.testing.tests.jpql;
// Java imports
import java.util.*;
// TopLink imports
import org.eclipse.persistence.queries.*;
import org.eclipse.persistence.expressions.*;
// Testing imports
import org.eclipse.persistence.testing.framework.*;
// Domain imports
import org.eclipse.persistence.testing.models.employee.domain.*;
public class BinaryOperatorWithParameterTest extends JPQLParameterTestCase {
private Vector expressionParameters;
public static BinaryOperatorWithParameterTest getNumericParameterGreaterThanTest() {
BinaryOperatorWithParameterTest theTest = new BinaryOperatorWithParameterTest();
theTest.setName("Greater than with parameter test");
String parameterName = "id";
theTest.setExpressionParameters(new Vector());
theTest.getExpressionParameters().add(parameterName);
ExpressionBuilder builder = new ExpressionBuilder();
Expression whereClause = builder.get("id").greaterThan(builder.getParameter(parameterName));
theTest.setOriginalObjectExpression(whereClause);
String ejbqlString = "SELECT OBJECT(emp) FROM Employee emp WHERE ";
ejbqlString = ejbqlString + "emp.id > ?1 ";
theTest.setEjbqlString(ejbqlString);
Vector myArgumentNames = new Vector();
myArgumentNames.add("1");
theTest.setArgumentNames(myArgumentNames);
return theTest;
}
public static BinaryOperatorWithParameterTest getNumericParameterGreaterThanEqualTest() {
BinaryOperatorWithParameterTest theTest = new BinaryOperatorWithParameterTest();
theTest.setName("Greater than equal to with parameter test");
String parameterName = "id";
theTest.setExpressionParameters(new Vector());
theTest.getExpressionParameters().add(parameterName);
ExpressionBuilder builder = new ExpressionBuilder();
Expression whereClause = builder.get("id").greaterThanEqual(builder.getParameter(parameterName));
theTest.setOriginalObjectExpression(whereClause);
String ejbqlString = "SELECT OBJECT(emp) FROM Employee emp WHERE ";
ejbqlString = ejbqlString + "emp.id >= ?1 ";
theTest.setEjbqlString(ejbqlString);
Vector myArgumentNames = new Vector();
myArgumentNames.add("1");
theTest.setArgumentNames(myArgumentNames);
return theTest;
}
public static BinaryOperatorWithParameterTest getNumericParameterLessThanTest() {
BinaryOperatorWithParameterTest theTest = new BinaryOperatorWithParameterTest();
theTest.setName("Less than with parameter test");
String parameterName = "id";
theTest.setExpressionParameters(new Vector());
theTest.getExpressionParameters().add(parameterName);
ExpressionBuilder builder = new ExpressionBuilder();
Expression whereClause = builder.get("id").lessThan(builder.getParameter(parameterName));
theTest.setOriginalObjectExpression(whereClause);
String ejbqlString = "SELECT OBJECT(emp) FROM Employee emp WHERE ";
ejbqlString = ejbqlString + "emp.id < ?1 ";
theTest.setEjbqlString(ejbqlString);
Vector myArgumentNames = new Vector();
myArgumentNames.add("1");
theTest.setArgumentNames(myArgumentNames);
return theTest;
}
public static BinaryOperatorWithParameterTest getNumericParameterLessThanEqualTest() {
BinaryOperatorWithParameterTest theTest = new BinaryOperatorWithParameterTest();
theTest.setName("Less than equal to with parameter test");
String parameterName = "id";
theTest.setExpressionParameters(new Vector());
theTest.getExpressionParameters().add(parameterName);
ExpressionBuilder builder = new ExpressionBuilder();
Expression whereClause = builder.get("id").lessThanEqual(builder.getParameter(parameterName));
theTest.setOriginalObjectExpression(whereClause);
String ejbqlString = "SELECT OBJECT(emp) FROM Employee emp WHERE ";
ejbqlString = ejbqlString + "emp.id <= ?1 ";
theTest.setEjbqlString(ejbqlString);
Vector myArgumentNames = new Vector();
myArgumentNames.add("1");
theTest.setArgumentNames(myArgumentNames);
return theTest;
}
public static BinaryOperatorWithParameterTest getNumericParameterPlusTest() {
BinaryOperatorWithParameterTest theTest = new BinaryOperatorWithParameterTest();
theTest.setName("Plus with parameter test");
String parameterName = "amountToAdd";
theTest.setExpressionParameters(new Vector());
theTest.getExpressionParameters().add(parameterName);
ExpressionBuilder builder = new ExpressionBuilder();
Expression whereClause = ExpressionMath.add(builder.get("salary"), (builder.getParameter(parameterName))).lessThanEqual(50000);
theTest.setOriginalObjectExpression(whereClause);
String ejbqlString = "SELECT OBJECT(emp) FROM Employee emp WHERE emp.salary + ?1 <= 50000";
theTest.setEjbqlString(ejbqlString);
Vector myArgumentNames = new Vector();
myArgumentNames.add("1");
theTest.setArgumentNames(myArgumentNames);
theTest.setArguments(new Vector());
theTest.getArguments().addElement(new Integer(1000));
return theTest;
}
public static BinaryOperatorWithParameterTest getNumericParameterPlusTestWithBracketsBeforeComparison() {
BinaryOperatorWithParameterTest theTest = new BinaryOperatorWithParameterTest();
theTest.setName("Plus with parameter test with brackets before comparison");
String parameterName = "amountToAdd";
theTest.setExpressionParameters(new Vector());
theTest.getExpressionParameters().add(parameterName);
ExpressionBuilder builder = new ExpressionBuilder();
Expression whereClause = ExpressionMath.add(builder.get("salary"), (builder.getParameter(parameterName))).lessThanEqual(50000);
theTest.setOriginalObjectExpression(whereClause);
String ejbqlString = "SELECT OBJECT(emp) FROM Employee emp WHERE (emp.salary + ?1) <= 50000";
theTest.setEjbqlString(ejbqlString);
Vector myArgumentNames = new Vector();
myArgumentNames.add("1");
theTest.setArgumentNames(myArgumentNames);
theTest.setArguments(new Vector());
theTest.getArguments().addElement(new Integer(1000));
return theTest;
}
public static BinaryOperatorWithParameterTest getNumericParameterPlusTestWithBracketsAfterComparison() {
BinaryOperatorWithParameterTest theTest = new BinaryOperatorWithParameterTest();
theTest.setName("Plus with parameter test with brackets after comparison");
String parameterName = "amountToAdd";
theTest.setExpressionParameters(new Vector());
theTest.getExpressionParameters().add(parameterName);
ExpressionBuilder builder = new ExpressionBuilder();
Expression whereClause = ExpressionBuilder.fromConstant(new Integer(50000), builder).greaterThan(ExpressionMath.add(builder.get("salary"), (builder.getParameter(parameterName))));
theTest.setOriginalObjectExpression(whereClause);
String ejbqlString = "SELECT OBJECT(emp) FROM Employee emp WHERE 50000 > (emp.salary + ?1)";
theTest.setEjbqlString(ejbqlString);
Vector myArgumentNames = new Vector();
myArgumentNames.add("1");
theTest.setArgumentNames(myArgumentNames);
theTest.setArguments(new Vector());
theTest.getArguments().addElement(new Integer(1000));
return theTest;
}
public static BinaryOperatorWithParameterTest getNumericParameterMinusTest() {
BinaryOperatorWithParameterTest theTest = new BinaryOperatorWithParameterTest();
theTest.setName("Minus with parameter test");
String parameterName = "amountToSubtract";
theTest.setExpressionParameters(new Vector());
theTest.getExpressionParameters().add(parameterName);
ExpressionBuilder builder = new ExpressionBuilder();
Expression whereClause = ExpressionMath.subtract(builder.get("salary"), (builder.getParameter(parameterName))).lessThanEqual(50000);
theTest.setOriginalObjectExpression(whereClause);
String ejbqlString = "SELECT OBJECT(emp) FROM Employee emp WHERE emp.salary - ?1 <= 50000";
theTest.setEjbqlString(ejbqlString);
Vector myArgumentNames = new Vector();
myArgumentNames.add("1");
theTest.setArgumentNames(myArgumentNames);
theTest.setArguments(new Vector());
theTest.getArguments().addElement(new Integer(1000));
return theTest;
}
public static BinaryOperatorWithParameterTest getNumericParameterMinusTestWithBracketsBeforeComparison() {
BinaryOperatorWithParameterTest theTest = new BinaryOperatorWithParameterTest();
theTest.setName("Minus with parameter test with brackets before comparison");
String parameterName = "amountToSubtract";
theTest.setExpressionParameters(new Vector());
theTest.getExpressionParameters().add(parameterName);
ExpressionBuilder builder = new ExpressionBuilder();
Expression whereClause = ExpressionMath.subtract(builder.get("salary"), (builder.getParameter(parameterName))).lessThanEqual(50000);
theTest.setOriginalObjectExpression(whereClause);
String ejbqlString = "SELECT OBJECT(emp) FROM Employee emp WHERE (emp.salary - ?1) <= 50000";
theTest.setEjbqlString(ejbqlString);
Vector myArgumentNames = new Vector();
myArgumentNames.add("1");
theTest.setArgumentNames(myArgumentNames);
theTest.setArguments(new Vector());
theTest.getArguments().addElement(new Integer(1000));
return theTest;
}
public static BinaryOperatorWithParameterTest getNumericParameterMinusTestWithBracketsAfterComparison() {
BinaryOperatorWithParameterTest theTest = new BinaryOperatorWithParameterTest();
theTest.setName("Minus with parameter test with brackets after comparison");
String parameterName = "amountToSubtract";
theTest.setExpressionParameters(new Vector());
theTest.getExpressionParameters().add(parameterName);
ExpressionBuilder builder = new ExpressionBuilder();
Expression whereClause = ExpressionBuilder.fromConstant(new Integer(50000), builder).greaterThan(ExpressionMath.subtract(builder.get("salary"), (builder.getParameter(parameterName))));
theTest.setOriginalObjectExpression(whereClause);
String ejbqlString = "SELECT OBJECT(emp) FROM Employee emp WHERE 50000 > (emp.salary - ?1)";
theTest.setEjbqlString(ejbqlString);
Vector myArgumentNames = new Vector();
myArgumentNames.add("1");
theTest.setArgumentNames(myArgumentNames);
theTest.setArguments(new Vector());
theTest.getArguments().addElement(new Integer(1000));
return theTest;
}
public static BinaryOperatorWithParameterTest getNumericParameterMultiplyTest() {
BinaryOperatorWithParameterTest theTest = new BinaryOperatorWithParameterTest();
theTest.setName("Multiply with parameter test");
String parameterName = "amountToMultiply";
theTest.setExpressionParameters(new Vector());
theTest.getExpressionParameters().add(parameterName);
ExpressionBuilder builder = new ExpressionBuilder();
Expression whereClause = ExpressionMath.multiply(builder.get("salary"), (builder.getParameter(parameterName))).lessThanEqual(100000);
theTest.setOriginalObjectExpression(whereClause);
String ejbqlString = "SELECT OBJECT(emp) FROM Employee emp WHERE emp.salary * ?1 <= 100000";
theTest.setEjbqlString(ejbqlString);
Vector myArgumentNames = new Vector();
myArgumentNames.add("1");
theTest.setArgumentNames(myArgumentNames);
theTest.setArguments(new Vector());
theTest.getArguments().addElement(new Integer(2));
return theTest;
}
public static BinaryOperatorWithParameterTest getNumericParameterMultiplyTestWithBracketsBeforeComparison() {
BinaryOperatorWithParameterTest theTest = new BinaryOperatorWithParameterTest();
theTest.setName("Multiply with parameter test with brackets before comparison");
String parameterName = "amountToMultiply";
theTest.setExpressionParameters(new Vector());
theTest.getExpressionParameters().add(parameterName);
ExpressionBuilder builder = new ExpressionBuilder();
Expression whereClause = ExpressionMath.multiply(builder.get("salary"), (builder.getParameter(parameterName))).lessThanEqual(100000);
theTest.setOriginalObjectExpression(whereClause);
String ejbqlString = "SELECT OBJECT(emp) FROM Employee emp WHERE (emp.salary * ?1) <= 100000";
theTest.setEjbqlString(ejbqlString);
Vector myArgumentNames = new Vector();
myArgumentNames.add("1");
theTest.setArgumentNames(myArgumentNames);
theTest.setArguments(new Vector());
theTest.getArguments().addElement(new Integer(2));
return theTest;
}
public static BinaryOperatorWithParameterTest getNumericParameterMultiplyTestWithBracketsAfterComparison() {
BinaryOperatorWithParameterTest theTest = new BinaryOperatorWithParameterTest();
theTest.setName("Multiply with parameter test with brackets after comparison");
String parameterName = "amountToMultiply";
theTest.setExpressionParameters(new Vector());
theTest.getExpressionParameters().add(parameterName);
ExpressionBuilder builder = new ExpressionBuilder();
Expression whereClause = ExpressionBuilder.fromConstant(new Integer(100000), builder).greaterThan(ExpressionMath.multiply(builder.get("salary"), (builder.getParameter(parameterName))));
theTest.setOriginalObjectExpression(whereClause);
String ejbqlString = "SELECT OBJECT(emp) FROM Employee emp WHERE 100000 > (emp.salary * ?1)";
theTest.setEjbqlString(ejbqlString);
Vector myArgumentNames = new Vector();
myArgumentNames.add("1");
theTest.setArgumentNames(myArgumentNames);
theTest.setArguments(new Vector());
theTest.getArguments().addElement(new Integer(2));
return theTest;
}
public static BinaryOperatorWithParameterTest getNumericParameterDivideTest() {
BinaryOperatorWithParameterTest theTest = new BinaryOperatorWithParameterTest();
theTest.setName("Divide with parameter test");
String parameterName = "amountToDivide";
theTest.setExpressionParameters(new Vector());
theTest.getExpressionParameters().add(parameterName);
ExpressionBuilder builder = new ExpressionBuilder();
Expression whereClause = ExpressionMath.divide(builder.get("salary"), (builder.getParameter(parameterName))).lessThanEqual(20000);
theTest.setOriginalObjectExpression(whereClause);
String ejbqlString = "SELECT OBJECT(emp) FROM Employee emp WHERE emp.salary / ?1 <= 20000";
theTest.setEjbqlString(ejbqlString);
Vector myArgumentNames = new Vector();
myArgumentNames.add("1");
theTest.setArgumentNames(myArgumentNames);
theTest.setArguments(new Vector());
theTest.getArguments().addElement(new Integer(2));
return theTest;
}
public static BinaryOperatorWithParameterTest getNumericParameterDivideTestWithBracketsBeforeComparison() {
BinaryOperatorWithParameterTest theTest = new BinaryOperatorWithParameterTest();
theTest.setName("Divide with parameter test with brackets before comparison");
String parameterName = "amountToDivide";
theTest.setExpressionParameters(new Vector());
theTest.getExpressionParameters().add(parameterName);
ExpressionBuilder builder = new ExpressionBuilder();
Expression whereClause = ExpressionMath.divide(builder.get("salary"), (builder.getParameter(parameterName))).lessThanEqual(20000);
theTest.setOriginalObjectExpression(whereClause);
String ejbqlString = "SELECT OBJECT(emp) FROM Employee emp WHERE (emp.salary / ?1) <= 20000";
theTest.setEjbqlString(ejbqlString);
Vector myArgumentNames = new Vector();
myArgumentNames.add("1");
theTest.setArgumentNames(myArgumentNames);
theTest.setArguments(new Vector());
theTest.getArguments().addElement(new Integer(2));
return theTest;
}
public static BinaryOperatorWithParameterTest getNumericParameterDivideTestWithBracketsAfterComparison() {
BinaryOperatorWithParameterTest theTest = new BinaryOperatorWithParameterTest();
theTest.setName("Divide with parameter test with brackets after comparison");
String parameterName = "amountToDivide";
theTest.setExpressionParameters(new Vector());
theTest.getExpressionParameters().add(parameterName);
ExpressionBuilder builder = new ExpressionBuilder();
Expression whereClause = ExpressionBuilder.fromConstant(new Integer(20000), builder).greaterThan(ExpressionMath.divide(builder.get("salary"), (builder.getParameter(parameterName))));
theTest.setOriginalObjectExpression(whereClause);
String ejbqlString = "SELECT OBJECT(emp) FROM Employee emp WHERE 20000 > (emp.salary / ?1)";
theTest.setEjbqlString(ejbqlString);
Vector myArgumentNames = new Vector();
myArgumentNames.add("1");
theTest.setArgumentNames(myArgumentNames);
theTest.setArguments(new Vector());
theTest.getArguments().addElement(new Integer(2));
return theTest;
}
public static BinaryOperatorWithParameterTest getNumericTwoParameterMultipleOperators() {
BinaryOperatorWithParameterTest theTest = new BinaryOperatorWithParameterTest();
theTest.setName("Multiple operators with two parameters");
String parameterNameForDivide = "amountToDivide";
String parameterNameForMultiply = "amountToMultiply";
theTest.setExpressionParameters(new Vector());
theTest.getExpressionParameters().add(parameterNameForDivide);
theTest.getExpressionParameters().add(parameterNameForMultiply);
ExpressionBuilder builder = new ExpressionBuilder();
Expression whereClause = ExpressionMath.subtract(ExpressionMath.add(builder.get("salary"), 10000), ExpressionMath.multiply(ExpressionMath.divide(ExpressionBuilder.fromConstant(new Integer(10000), builder), builder.getParameter(parameterNameForDivide)), builder.getParameter(parameterNameForMultiply))).greaterThanEqual(50000);
theTest.setOriginalObjectExpression(whereClause);
String ejbqlString = "SELECT OBJECT(emp) FROM Employee emp WHERE emp.salary + 10000 - 10000 / ?1 * ?2 >= 50000";
theTest.setEjbqlString(ejbqlString);
Vector myArgumentNames = new Vector();
myArgumentNames.add("1");
myArgumentNames.add("2");
theTest.setArgumentNames(myArgumentNames);
theTest.setArguments(new Vector());
theTest.getArguments().addElement(new Integer(2));
theTest.getArguments().addElement(new Integer(3));
return theTest;
}
public static BinaryOperatorWithParameterTest getNumericTwoParameterMultipleOperatorsWithBracketsAroundPlusMinus() {
BinaryOperatorWithParameterTest theTest = new BinaryOperatorWithParameterTest();
theTest.setName("Multiple operators with two parameters with brackets around plus/minus");
String parameterNameForDivide = "amountToDivide";
String parameterNameForMultiply = "amountToMultiply";
theTest.setExpressionParameters(new Vector());
theTest.getExpressionParameters().add(parameterNameForDivide);
theTest.getExpressionParameters().add(parameterNameForMultiply);
ExpressionBuilder builder = new ExpressionBuilder();
Expression whereClause = ExpressionMath.multiply(ExpressionMath.divide(ExpressionMath.subtract(ExpressionMath.add(builder.get("salary"), 10), 20), builder.getParameter(parameterNameForDivide)), builder.getParameter(parameterNameForMultiply)).greaterThanEqual(70000);
theTest.setOriginalObjectExpression(whereClause);
String ejbqlString = "SELECT OBJECT(emp) FROM Employee emp WHERE (emp.salary + 10 - 20) / ?1 * ?2 >= 70000";
theTest.setEjbqlString(ejbqlString);
Vector myArgumentNames = new Vector();
myArgumentNames.add("1");
myArgumentNames.add("2");
theTest.setArgumentNames(myArgumentNames);
theTest.setArguments(new Vector());
theTest.getArguments().addElement(new Integer(2));
theTest.getArguments().addElement(new Integer(3));
return theTest;
}
public static BinaryOperatorWithParameterTest getNumericTwoParameterMultipleOperatorsWithBracketsAroundMultiply() {
BinaryOperatorWithParameterTest theTest = new BinaryOperatorWithParameterTest();
theTest.setName("Multiple operators with two parameters with brackets around multiply");
String parameterNameForDivide = "amountToDivide";
String parameterNameForMultiply = "amountToMultiply";
theTest.setExpressionParameters(new Vector());
theTest.getExpressionParameters().add(parameterNameForDivide);
theTest.getExpressionParameters().add(parameterNameForMultiply);
ExpressionBuilder builder = new ExpressionBuilder();
Expression whereClause = builder.get("salary").greaterThan(ExpressionMath.subtract(ExpressionMath.add(ExpressionBuilder.fromConstant(new Integer(50000), builder), 10000), ExpressionMath.divide(ExpressionBuilder.fromConstant(new Integer(10000), builder), ExpressionMath.multiply(builder.getParameter(parameterNameForMultiply), builder.getParameter(parameterNameForDivide)))));
theTest.setOriginalObjectExpression(whereClause);
String ejbqlString = "SELECT OBJECT(emp) FROM Employee emp WHERE emp.salary > (50000 + 10000 - 10000 / (?1 * ?2))";
theTest.setEjbqlString(ejbqlString);
Vector myArgumentNames = new Vector();
myArgumentNames.add("1");
myArgumentNames.add("2");
theTest.setArgumentNames(myArgumentNames);
theTest.setArguments(new Vector());
theTest.getArguments().addElement(new Integer(2));
theTest.getArguments().addElement(new Integer(5));
return theTest;
}
public static TestSuite getParameterBinaryOperatorTests() {
TestSuite theSuite = new TestSuite();
theSuite.setName("Parameter Binary Operator Test Suite");
theSuite.addTest(BinaryOperatorWithParameterTest.getNumericParameterGreaterThanTest());
theSuite.addTest(BinaryOperatorWithParameterTest.getNumericParameterGreaterThanEqualTest());
theSuite.addTest(BinaryOperatorWithParameterTest.getNumericParameterLessThanTest());
theSuite.addTest(BinaryOperatorWithParameterTest.getNumericParameterLessThanEqualTest());
theSuite.addTest(BinaryOperatorWithParameterTest.getNumericParameterPlusTest());
theSuite.addTest(BinaryOperatorWithParameterTest.getNumericParameterPlusTestWithBracketsBeforeComparison());
theSuite.addTest(BinaryOperatorWithParameterTest.getNumericParameterPlusTestWithBracketsAfterComparison());
theSuite.addTest(BinaryOperatorWithParameterTest.getNumericParameterMinusTest());
theSuite.addTest(BinaryOperatorWithParameterTest.getNumericParameterMinusTestWithBracketsBeforeComparison());
theSuite.addTest(BinaryOperatorWithParameterTest.getNumericParameterMinusTestWithBracketsAfterComparison());
theSuite.addTest(BinaryOperatorWithParameterTest.getNumericParameterMultiplyTest());
theSuite.addTest(BinaryOperatorWithParameterTest.getNumericParameterMultiplyTestWithBracketsBeforeComparison());
theSuite.addTest(BinaryOperatorWithParameterTest.getNumericParameterMultiplyTestWithBracketsAfterComparison());
theSuite.addTest(BinaryOperatorWithParameterTest.getNumericParameterDivideTest());
theSuite.addTest(BinaryOperatorWithParameterTest.getNumericParameterDivideTestWithBracketsBeforeComparison());
theSuite.addTest(BinaryOperatorWithParameterTest.getNumericParameterDivideTestWithBracketsAfterComparison());
theSuite.addTest(BinaryOperatorWithParameterTest.getNumericTwoParameterMultipleOperators());
theSuite.addTest(BinaryOperatorWithParameterTest.getNumericTwoParameterMultipleOperatorsWithBracketsAroundPlusMinus());
theSuite.addTest(BinaryOperatorWithParameterTest.getNumericTwoParameterMultipleOperatorsWithBracketsAroundMultiply());
return theSuite;
}
private void setArgumentsForTestUsing(Vector employees) {
setArguments(new Vector());
Enumeration names = getExpressionParameters().elements();
Enumeration employeeEnum = employees.elements();
while (names.hasMoreElements()) {
Employee emp = (Employee)employeeEnum.nextElement();
getArguments().add(emp.getId());
names.nextElement();
}
}
public void setup() {
//JGL: If the arguments are already set by the test, don't
//set them again
if (!hasArguments()) {
setArgumentsForTestUsing(getSomeEmployees());
}
ReadAllQuery raq = new ReadAllQuery();
raq.setReferenceClass(Employee.class);
raq.setSelectionCriteria(getOriginalObjectExpression());
// Add all the arguments to the query
Enumeration enumtr = getExpressionParameters().elements();
while (enumtr.hasMoreElements()) {
raq.addArgument((String)enumtr.nextElement());
}
// Save the retrieved employees for the verify
setOriginalOject(getSession().executeQuery(raq, getArguments()));
// Finish the setup
super.setup();
}
private void setExpressionParameters(Vector theArgumentNames) {
expressionParameters = theArgumentNames;
}
private Vector getExpressionParameters() {
return expressionParameters;
}
}