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 void setup() {
Vector employees = getSomeEmployees();
// Bug 223005: Verify that we have at least 1 employee with the required field length otherwise
// an EclipseLinkException will be thrown
Employee emp = getEmployeeWithRequiredNameLength(employees, MIN_FIRSTNAME_LENGTH, getName());
String partialFirstName = "%" + emp.getFirstName().substring(0, 3) + "%";
ReadAllQuery raq = new ReadAllQuery();
raq.setReferenceClass(Employee.class);
Vector parameters = new Vector();
parameters.add(partialFirstName);
ExpressionBuilder eb = new ExpressionBuilder();
Expression whereClause = eb.get("firstName").like(partialFirstName);
raq.setSelectionCriteria(whereClause);
employees = (Vector) getSession().executeQuery(raq);
String ejbqlString = "SELECT OBJECT(emp) FROM Employee emp WHERE emp.firstName LIKE ?1";
setEjbqlString(ejbqlString);
setOriginalOject(employees);
setArguments(parameters);
Vector myArgumentNames = new Vector();
myArgumentNames.add("1");
setArgumentNames(myArgumentNames);
super.setup();
}
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 void setup() {
Employee emp = (Employee) getSomeEmployees().firstElement();
String partOne;
String partTwo;
String ejbqlString;
partOne = emp.getFirstName();
ExpressionBuilder builder = new ExpressionBuilder();
Expression whereClause = builder.get("firstName").concat("Smith").like(partOne + "Smith");
ReadAllQuery raq = new ReadAllQuery();
raq.setReferenceClass(Employee.class);
raq.setSelectionCriteria(whereClause);
Vector employees = (Vector) getSession().executeQuery(raq);
ejbqlString = "SELECT OBJECT(emp) FROM Employee emp WHERE ";
ejbqlString = ejbqlString + "CONCAT(emp.firstName,\"Smith\") LIKE ";
ejbqlString = ejbqlString + "\"" + partOne + "Smith\"";
setEjbqlString(ejbqlString);
setOriginalOject(employees);
super.setup();
}
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 void setup() {
Employee emp1;
Employee emp2;
Employee emp3;
emp1 = (Employee) getSomeEmployees().firstElement();
emp2 = (Employee) getSomeEmployees().elementAt(1);
emp3 = (Employee) getSomeEmployees().elementAt(2);
ExpressionBuilder builder = new ExpressionBuilder();
Vector idVector = new Vector();
idVector.add(emp1.getId());
idVector.add(emp2.getId());
idVector.add(emp3.getId());
Expression whereClause = builder.get("id").notIn(idVector);
ReadAllQuery raq = new ReadAllQuery();
raq.setReferenceClass(Employee.class);
raq.setSelectionCriteria(whereClause);
setOriginalOject(getSession().executeQuery(raq));
getSession().getIdentityMapAccessor().initializeAllIdentityMaps();
String ejbqlString = "SELECT OBJECT(emp) FROM Employee emp WHERE emp.id NOT IN (";
ejbqlString = ejbqlString + emp1.getId().toString() + ", ";
ejbqlString = ejbqlString + emp2.getId().toString() + ", ";
ejbqlString = ejbqlString + emp3.getId().toString();
ejbqlString = ejbqlString + ")";
setEjbqlString(ejbqlString);
super.setup();
}
public ReadQuery getQueryForTest() {
ReportQuery testQuery = new ReportQuery();
testQuery.setReferenceClass(Employee.class);
ExpressionBuilder employees = new ExpressionBuilder();
Expression exp = employees.get("firstName").like("B%");
testQuery.setSelectionCriteria(exp);
testQuery.cacheQueryResults();
testQuery.addAttribute("firstName");
return testQuery;
}
public void test() {
ExpressionBuilder eb = new ExpressionBuilder();
ReportQuery rq = new ReportQuery(Employee.class, eb);
rq.addAttribute("firstName");
rq.addAttribute("lastName");
Expression exp = eb.getFunction("dbms_random.value");
exp.setSelectIfOrderedBy(false);
rq.addOrdering(exp.ascending());
rq.setSelectionCriteria(eb.anyOf("projects").get("teamLeader").isNull());
results = (Vector) getSession().executeQuery(rq);
}
private void addOuterJoinJoiningComplexTest() {
ExpressionBuilder emp = new ExpressionBuilder();
ReadAllExpressionTest test = new ReadAllOuterJoinExpressionTest(Project.class, 15);
test.setName("OuterJoinJoiningComplexTest");
test.setDescription("Test joining with outer joins");
ReadAllQuery query = new ReadAllQuery(Project.class);
query.addJoinedAttribute(emp.getAllowingNull("teamLeader"));
test.setQuery(query);
addTest(test);
}
private void addOuterJoinJoiningTest() {
ExpressionBuilder emp = new ExpressionBuilder();
ReadAllExpressionTest test = new ReadAllOuterJoinExpressionTest(Employee.class, 12);
test.setName("OuterJoinJoiningTest");
test.setDescription("Test joining with outer joins");
ReadAllQuery query = new ReadAllQuery(Employee.class);
query.addJoinedAttribute(emp.getAllowingNull("address"));
test.setQuery(query);
addTest(test);
}
private void addOuterJoinOrderByTest() {
ExpressionBuilder emp = new ExpressionBuilder();
ReadAllExpressionTest test = new ReadAllOuterJoinExpressionTest(Employee.class, 12);
test.setName("OuterJoinOrderByTest");
test.setDescription("Test order by with outer joins");
ReadAllQuery query = new ReadAllQuery(Employee.class);
query.addOrdering(emp.getAllowingNull("address").get("city"));
test.setQuery(query);
addTest(test);
}
private void addOuterJoinSimpleTest() {
// This one does not really make sense, however its simple and tests that the syntax works.
ExpressionBuilder emp = new ExpressionBuilder();
Expression expression = emp.getAllowingNull("address").get("city").equal("Ottawa");
ReadAllExpressionTest test = new ReadAllOuterJoinExpressionTest(Employee.class, 1);
test.setName("OuterJoinSimpleTest");
test.setDescription("Test expression with outer joins");
test.setExpression(expression);
addTest(test);
}
/** Read employee and clear the cache, test database read. */
public void test() throws Exception {
ReadObjectQuery query = new ReadObjectQuery(Employee.class);
ExpressionBuilder employee = new ExpressionBuilder();
query.setSelectionCriteria(
employee
.get("firstName")
.equal("Brendan")
.and(employee.get("salary").equal(100000))
.and(employee.get("address").get("city").like("%pean%"))
.and(employee.anyOf("phoneNumbers").get("type").equal("Home")));
query.checkCacheOnly();
Employee result = (Employee) getSession().executeQuery(query);
}
private void addOuterJoinManyToManyTest() {
ExpressionBuilder emp = new ExpressionBuilder();
Expression expression =
emp.get("firstName")
.like("%")
.or(emp.anyOfAllowingNone("projects").get("description").like("%"));
ReadAllExpressionTest test = new ReadAllOuterJoinExpressionTest(Employee.class, 12);
test.setName("OuterJoinManytoManyTest");
test.setDescription("Tests manytomany relationships with outer joins");
test.setExpression(expression);
addTest(test);
}
private void addOuterJoinDirectCollectionTest() {
ExpressionBuilder emp = new ExpressionBuilder();
Expression expression =
emp.get("firstName")
.equal("Nancy")
.or(emp.anyOfAllowingNone("responsibilitiesList").equal("Write lots of Java code."));
ReadAllExpressionTest test = new ReadAllOuterJoinExpressionTest(Employee.class, 2);
test.setName("OuterJoinDirectCollectionTest");
test.setDescription("Tests direct collection relationships with outer joins");
test.setExpression(expression);
addTest(test);
}
private void addOuterJoinOrWhereClauseTest2() {
ExpressionBuilder emp = new ExpressionBuilder();
Expression expression =
emp.get("firstName")
.like("Sarah%")
.or(emp.getAllowingNull("manager").get("firstName").like("Sarah%"));
ReadAllExpressionTest test = new ReadAllOuterJoinExpressionTest(Employee.class, 3);
test.setName("OuterJoinOrWhereClauseTest2");
test.setDescription("Test expression with outer joins");
test.setExpression(expression);
addTest(test);
}
private void addOuterJoinOrAnyWhereClauseTest() {
ExpressionBuilder emp = new ExpressionBuilder();
Expression expression =
emp.get("firstName")
.like("Sarah%")
.or(emp.anyOfAllowingNone("phoneNumbers").get("areaCode").equal("613"));
ReadAllExpressionTest test = new ReadAllOuterJoinExpressionTest(Employee.class, 10);
test.setName("OuterJoinOrAnyWhereClauseTest");
test.setDescription("Test expression anyof with outer joins");
test.setExpression(expression);
addTest(test);
}
private void addOuterJoinJoiningTest2() {
ExpressionBuilder emp = new ExpressionBuilder();
ReadAllExpressionTest test =
new ReadAllOuterJoinExpressionTest2(
org.eclipse.persistence.testing.models.insurance.PolicyHolder.class, 4);
test.setName("OuterJoinJoiningTest2");
test.setDescription("Test joining with outer joins");
ReadAllQuery query =
new ReadAllQuery(org.eclipse.persistence.testing.models.insurance.PolicyHolder.class);
query.addJoinedAttribute(emp.getAllowingNull("address"));
test.setQuery(query);
addTest(test);
}
private void addOuterJoinIsNullTest() {
ExpressionBuilder emp = new ExpressionBuilder();
Expression expression =
emp.get("firstName")
.equal("Bob")
.or(emp.getAllowingNull("address").isNull())
.or(emp.getAllowingNull("address").get("city").equal("Ottawa"));
ReadAllExpressionTest test = new ReadAllOuterJoinExpressionTest(Employee.class, 2);
test.setName("OuterJoinIsNullTest");
test.setDescription("Test using isNull with outer joins");
test.setExpression(expression);
addTest(test);
}
public static ReadObjectTest getReadInterfaceObjectTest() {
TestSuite suite = new TestSuite();
PopulationManager manager = PopulationManager.getDefaultManager();
Contact contact = ((Employee) manager.getObject(Employee.class, "example1")).getContact();
ExpressionBuilder builder = new ExpressionBuilder();
Expression expression = builder.get("id").equal(contact.getEmp().getId());
ReadObjectQuery query = new ReadObjectQuery();
query.setReferenceClass(ContactHolder.class);
query.setSelectionCriteria(expression);
ReadObjectTest test = new ReadObjectTest(contact.getEmp());
test.setQuery(query);
return test;
}
private void addOuterJoinOrWhereClauseTest4() {
ExpressionBuilder emp = new ExpressionBuilder();
Expression expression =
emp.get("firstName")
.like("Bob%")
.or(
emp.getAllowingNull("address")
.get("city")
.like("Ot%")
.and(emp.getAllowingNull("address").get("city").like("%wa")));
ReadAllExpressionTest test = new ReadAllOuterJoinExpressionTest(Employee.class, 2);
test.setName("OuterJoinOrWhereClauseTest4");
test.setDescription("Test expression with outer joins");
test.setExpression(expression);
addTest(test);
}
private void addOuterJoinAcrossInheritanceTest() {
ExpressionBuilder emp = new ExpressionBuilder();
ReadAllExpressionTest test =
new ReadAllOuterJoinExpressionTest(
org.eclipse.persistence.testing.models.inheritance.Person.class, 1);
test.setName("OuterJoinAcrossInheritanceTest");
test.setDescription("Test joining with outer joins across inheritance");
ReadAllQuery query =
new ReadAllQuery(org.eclipse.persistence.testing.models.inheritance.Person.class);
// This test used to make no sense...
// query.setSelectionCriteria(emp.getAllowingNull("representitive").get("name").equalOuterJoin("Richard"));
query.addOrdering(emp.getAllowingNull("representitive").get("name"));
test.setQuery(query);
addTest(test);
}
protected void test() {
for (int i = 0; i <= 1; i++) {
getSession().getPlatform().setShouldBindAllParameters(i != 0);
for (int j = 0; j <= 2; j++) {
query = new ReadAllQuery(Employee.class);
ExpressionBuilder builder = new ExpressionBuilder();
Vector vExp = new Vector(2);
vExp.add(builder.getParameter("p1"));
query.addArgument("p1");
vExp.add(builder.getParameter("p2"));
query.addArgument("p2");
Expression exp = builder.get("id").in(vExp);
query.setSelectionCriteria(exp);
switch (j) {
case 0:
// nothing to do - just test the default:
// query.bindAllParameters == Undefined
break;
case 1:
// query.bindAllParameters == False
query.setShouldBindAllParameters(false);
break;
case 2:
// query.bindAllParameters == True
query.setShouldBindAllParameters(true);
break;
}
// clear the writer's buffer
((StringWriter) getSession().getLog()).getBuffer().setLength(0);
try {
getSession().executeQuery(query, v);
} catch (DatabaseException e) {
throw new TestProblemException("executeQuery threw DatabaseException");
}
if (shouldBind() != wasBound()) {
return;
}
}
}
}
public void setup() {
Employee emp = (Employee) getSomeEmployees().firstElement();
PhoneNumber phone = (PhoneNumber) emp.getPhoneNumbers().firstElement();
String areaCode = phone.getAreaCode();
String firstName = emp.getFirstName();
setReferenceClass(Employee.class);
ExpressionBuilder employeeBuilder = new ExpressionBuilder();
Expression phones = employeeBuilder.anyOf("phoneNumbers");
Expression whereClause =
phones
.get("owner")
.get("firstName")
.equal(firstName)
.and(phones.get("areaCode").equal(areaCode));
ReportQuery rq = new ReportQuery();
rq.setSelectionCriteria(whereClause);
rq.addAttribute("number", phones.get("number"));
rq.setReferenceClass(Employee.class);
setOriginalOject(getAttributeFromAll("number", (Vector) getSession().executeQuery(rq)));
getSession().getIdentityMapAccessor().initializeAllIdentityMaps();
String ejbqlString;
ejbqlString =
"SELECT phone.number FROM Employee employee, IN(employee.phoneNumbers) phone "
+ "WHERE phone.owner.firstName = \""
+ firstName
+ "\" AND phone.areaCode = \""
+ areaCode
+ "\"";
useReportQuery();
setEjbqlString(ejbqlString);
super.setup();
}
/**
* INTERNAL: Selection criteria is created with source foreign keys and target keys. This criteria
* is then used to read target records from the table.
*/
public void initializeSelectionCriteria(AbstractSession session) {
Expression selectionCriteria = null;
Expression expression;
ExpressionBuilder expBuilder = new ExpressionBuilder();
Iterator sourceKeysEnum = getSourceToTargetQueryKeyNames().keySet().iterator();
while (sourceKeysEnum.hasNext()) {
DatabaseField sourceKey = (DatabaseField) sourceKeysEnum.next();
String target = (String) this.getSourceToTargetQueryKeyNames().get(sourceKey);
expression = expBuilder.getParameter(sourceKey).equal(expBuilder.get(target));
if (selectionCriteria == null) {
selectionCriteria = expression;
} else {
selectionCriteria = expression.and(selectionCriteria);
}
}
setSelectionCriteria(selectionCriteria);
}
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 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 void setup() {
// Get the baseline employees for the verify
Employee emp = (Employee) getSomeEmployees().firstElement();
String parameterName = "firstName";
ExpressionBuilder builder = new ExpressionBuilder();
Expression whereClause = builder.get("firstName").equal(builder.getParameter(parameterName));
ReadAllQuery raq = new ReadAllQuery();
raq.setReferenceClass(Employee.class);
raq.setSelectionCriteria(whereClause);
raq.addArgument(parameterName);
Vector parameters = new Vector();
parameters.add(emp.getFirstName());
Vector employees = (Vector) getSession().executeQuery(raq, parameters);
emp = (Employee) employees.firstElement();
// Set up the EJBQL using the retrieved employees
String ejbqlString = "SELECT OBJECT(emp) FROM Employee emp WHERE ";
ejbqlString = ejbqlString + "?1 = emp.firstName ";
setEjbqlString(ejbqlString);
setOriginalOject(employees);
setArguments(parameters);
Vector myArgumentNames = new Vector();
myArgumentNames.add("1");
setArgumentNames(myArgumentNames);
// Finish the setup
super.setup();
}
/**
* Load the last test result from the test result database. Find only the results run on the same
* machine and database. Compare the current test run result with the previous results do
* determine if the test passes or fails.
*/
public static void verify(PerformanceRegressionTest test) {
// Ensures all tests pass to reset baseline,
// Required when tests or environment change to be slower to avoid failures.
if (reset) {
throw new TestWarningException("Reseting baseline.");
}
Session session = LoadBuildSystem.getSystem().getSession();
// Query all previous successful test results for this test on the same machine and database.
// Find only the baseline version, or last version run different than current version.
// If you need to compare results against the current version you must change the TopLink
// version string.
ReadAllQuery query = new ReadAllQuery(TestResult.class);
ExpressionBuilder result = new ExpressionBuilder();
query.setSelectionCriteria(
result
.get("name")
.equal(test.getName())
.and(
result
.get("loadBuildSummary")
.get("machine")
.equal(LoadBuildSystem.getSummary().getMachine()))
.and(
result
.get("loadBuildSummary")
.get("loginChoice")
.equal(LoadBuildSystem.getSummary().getLoginChoice())));
// Allow comparing to a set version through a system property.
String currentVersion = LoadBuildSystem.getSummary().getToplinkVersion();
String baselineVersion = null;
if (System.getProperties().containsKey("toplink.loadbuild.baseline-version")) {
baselineVersion = System.getProperties().getProperty("toplink.loadbuild.baseline-version");
// System properties cannot store spaces so need to replace them from \b.
baselineVersion = baselineVersion.replace('_', ' ');
((PerformanceComparisonTestResult) ((TestCase) test).getTestResult()).baselineVersion =
baselineVersion;
} else {
// Compare against the last successful version.
ReportQuery reportQuery = new ReportQuery(TestResult.class, query.getExpressionBuilder());
reportQuery.useDistinct();
reportQuery.returnSingleValue();
reportQuery.addAttribute("version", result.get("loadBuildSummary").get("toplinkVersion"));
reportQuery.setSelectionCriteria(
query
.getSelectionCriteria()
.and(
(result.get("outcome").equal(TestResult.PASSED))
.or(result.get("outcome").equal(TestResult.WARNING)))
.and(result.get("loadBuildSummary").get("toplinkVersion").notEqual(currentVersion)));
reportQuery.addOrdering(result.get("loadBuildSummary").get("timestamp").descending());
baselineVersion = (String) session.executeQuery(reportQuery);
}
query.setSelectionCriteria(
query
.getSelectionCriteria()
.and(result.get("loadBuildSummary").get("toplinkVersion").equal(baselineVersion)));
query.addOrdering(result.get("loadBuildSummary").get("timestamp").descending());
query.setMaxRows(10);
query.useCursoredStream(1, 1);
CursoredStream stream = (CursoredStream) session.executeQuery(query);
if (!stream.hasMoreElements()) {
throw new TestWarningException("No previous test result to compare performance with.");
}
TestResult lastResult = (TestResult) stream.nextElement();
double lastCount = lastResult.getTestTime();
PerformanceComparisonTestResult testResult =
(PerformanceComparisonTestResult) ((TestCase) test).getTestResult();
testResult.getBaselineVersionResults().add(new Double(lastCount));
// Average last 5 runs.
int numberOfRuns = 0;
while (stream.hasMoreElements() && (numberOfRuns < 4)) {
TestResult nextResult = (TestResult) stream.nextElement();
testResult.getBaselineVersionResults().add(new Double(nextResult.getTestTime()));
numberOfRuns++;
}
stream.close();
double baselineAverage =
PerformanceComparisonTestResult.averageResults(testResult.getBaselineVersionResults());
double currentCount = ((TestCase) test).getTestResult().getTestTime();
testResult.baselineVersion = lastResult.getLoadBuildSummary().getToplinkVersion();
testResult.percentageDifferenceLastRun =
PerformanceComparisonTestResult.percentageDifference(currentCount, lastCount);
// Query the current version last 5 runs for averaging.
query = new ReadAllQuery(TestResult.class);
result = new ExpressionBuilder();
query.setSelectionCriteria(
result
.get("name")
.equal(((TestCase) test).getName())
.and(
result
.get("loadBuildSummary")
.get("machine")
.equal(LoadBuildSystem.getSummary().getMachine()))
.and(
result
.get("loadBuildSummary")
.get("loginChoice")
.equal(LoadBuildSystem.getSummary().getLoginChoice()))
.and(result.get("loadBuildSummary").get("toplinkVersion").equal(currentVersion)));
query.addOrdering(result.get("loadBuildSummary").get("timestamp").descending());
query.useCursoredStream(1, 1);
stream = (CursoredStream) session.executeQuery(query);
// Average last 5 runs.
testResult.getCurrentVersionResults().add(new Double(currentCount));
numberOfRuns = 0;
while (stream.hasMoreElements() && (numberOfRuns < 4)) {
TestResult nextResult = (TestResult) stream.nextElement();
testResult.getCurrentVersionResults().add(new Double(nextResult.getTestTime()));
numberOfRuns++;
}
stream.close();
double currentAverage =
PerformanceComparisonTestResult.averageResults(testResult.getCurrentVersionResults());
testResult.percentageDifferenceAverage =
PerformanceComparisonTestResult.percentageDifference(currentAverage, baselineAverage);
testResult.baselineStandardDeviation =
PerformanceComparisonTestResult.standardDeviationResults(
testResult.getBaselineVersionResults());
testResult.currentStandardDeviation =
PerformanceComparisonTestResult.standardDeviationResults(
testResult.getCurrentVersionResults());
if (testResult.percentageDifferenceAverage < test.getAllowableDecrease()) {
throw new TestErrorException(
"Test is "
+ ((long) testResult.percentageDifferenceAverage)
+ "% slower than last successful execution.");
}
}
public void test() {
ReadAllQuery query = new ReadAllQuery();
if (configuration != null) {
ExpressionBuilder emp = new ExpressionBuilder();
Expression exp = emp.get("salary").greaterThan(50000);
query.setSelectionCriteria(exp);
query.conformResultsInUnitOfWork();
}
ScrollableCursor cursor = null;
try {
query.setReferenceClass(Employee.class);
if (TYPE_SCROLL_INSENSITIVE_isSupported && CONCUR_UPDATABLE_isSupported) {
query.useScrollableCursor(2);
} else {
ScrollableCursorPolicy policy = new ScrollableCursorPolicy();
if (!TYPE_SCROLL_INSENSITIVE_isSupported) {
policy.setResultSetType(ScrollableCursorPolicy.TYPE_SCROLL_SENSITIVE);
}
if (!CONCUR_UPDATABLE_isSupported) {
policy.setResultSetConcurrency(ScrollableCursorPolicy.CONCUR_READ_ONLY);
}
policy.setPageSize(2);
query.useScrollableCursor(policy);
}
cursor = (ScrollableCursor) getSession().executeQuery(query);
try {
boolean isFirst = cursor.first();
if (!cursor.isFirst() || !isFirst) {
navigationError = "cursor.first() does not result in cursor.isFirst() returning true.";
}
Object second = cursor.next();
Object first = cursor.previous();
if (first.equals(second)) {
navigationError = "cursor.next() and cursor.previous() are not complementary.";
}
if (!second.equals(cursor.next())) {
navigationError = "cursor.next() does not move the cursor forward.";
}
boolean isRelative = cursor.relative(1);
if (!isRelative || !second.equals(cursor.previous())) {
navigationError =
"cursor.relative() does not move the cursor the proper number of spaces.";
}
boolean isAbsolute = cursor.absolute(1);
if (!second.equals(cursor.next())) {
navigationError = "cursor.absolute(0) move a cursor to the beginning of the cursor.";
}
cursor.beforeFirst();
if (!cursor.isBeforeFirst()) {
navigationError =
"cursor.beforeFirst() does not result in cursor.isBeforeFirst() returning true.";
}
if (!first.equals(cursor.next())) {
navigationError = "cursor.beforeFirst() does not set the cursor position properly.";
}
boolean isLast = cursor.last();
if (!isLast || !cursor.isLast()) {
navigationError = "cursor.last() does not result in cursor.isLast() returning true.";
}
cursor.afterLast();
if (!cursor.isAfterLast()) {
navigationError =
"cursor.afterLast() does not result in cursor.isAfterLast() returning true.";
}
Object last = cursor.previous();
int size = cursor.size();
cursor.relative(size);
Object lastBySize = cursor.previous();
if (!last.equals(lastBySize)) {
navigationError = "The last item in the list is not correct.";
}
} catch (org.eclipse.persistence.exceptions.QueryException ex) {
caughtException = ex;
}
} finally {
if (cursor != null) {
cursor.close();
}
}
}