foundation/eclipselink.core.test/src/org/eclipse/persistence/testing/tests/queries/CursoredStreamConformingTest.java

/*******************************************************************************
 * Copyright (c) 1998, 2013 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.queries;

import java.util.*;

import org.eclipse.persistence.testing.framework.*;
import org.eclipse.persistence.testing.models.employee.domain.*;
import org.eclipse.persistence.queries.*;
import org.eclipse.persistence.expressions.*;
import org.eclipse.persistence.sessions.*;

/**
 * Runs cursored stream tests with conforming.
 * @bug 3009570 Conforming Cursors
 * @author Stephen McRitchie
 */
	
public class CursoredStreamConformingTest extends CursoredStreamTest 
{
	protected ConformingTestConfiguration configuration;
	protected boolean useNestedUnitOfWork;

public CursoredStreamConformingTest() {
	super(Employee.class, (new ExpressionBuilder()).get("salary").greaterThan(50000));
	configuration = new ConformingTestConfiguration();
}

public CursoredStreamConformingTest(boolean useNestedUnitOfWork) {
	this();
	if (useNestedUnitOfWork) {
		setName(getName() + ":NestedUnitOfWork");
		this.useNestedUnitOfWork = true;
	}
	
}
protected void setup() 
{	
	getSession().getIdentityMapAccessor().initializeAllIdentityMaps();

	configuration.setup(getSession());
	UnitOfWork unitOfWork = configuration.getUnitOfWork();
	
	ReadAllQuery query = new ReadAllQuery(getReferenceClass(), joinExpression);
	query.conformResultsInUnitOfWork();
	Vector result = (Vector)unitOfWork.executeQuery(query);

	// Since conforming can not preserve order, must simply compare the
	// two results by PK.
	Vector expectedPKs = new Vector(result.size());
	for (Enumeration enumtr = result.elements(); enumtr.hasMoreElements();) {
		Employee emp = (Employee)enumtr.nextElement();
		expectedPKs.add(emp.getId());
	}
	setNormalQueryObjects(expectedPKs);
	
	configuration.reset();
	getSession().getIdentityMapAccessor().initializeAllIdentityMaps();

	configuration.setup(getSession());
	if (useNestedUnitOfWork) {
		getExecutor().setSession(configuration.getUnitOfWork().acquireUnitOfWork());		
	} else {
		getExecutor().setSession(configuration.getUnitOfWork());
	}
}
public void test ( ) {
	
	ReadAllQuery query = new ReadAllQuery();
	CursoredStream stream = null;
	
	try {
		Object databaseObject;
	
		cursoredQueryObjects = new Vector();
	
		query.setReferenceClass(getReferenceClass());
		query.setSelectionCriteria(joinExpression);
		query.conformResultsInUnitOfWork();
		query.useCursoredStream();
		stream = (CursoredStream) getSession().executeQuery(query);
		
		// Test dual cursors and read(int)
		CursoredStream stream2 = (CursoredStream) getSession().executeQuery(query);
		try {
		stream2.read(5);
		} catch (org.eclipse.persistence.exceptions.QueryException ex) {} // ignore at end	
		stream2.close();
		while (!stream.atEnd()) {
			databaseObject = stream.read();		
			getCursoredQueryObjects().addElement(((Employee)databaseObject).getId());
			stream.releasePrevious();	
		}
	} finally {	
		if (stream != null) {
			stream.close();
		}
	}	
}
/**
 * Verify if number of query objects matches number of cursor objects
 */
protected void verify() 
{	
	//System.out.println("Normal objects: " + getNormalQueryObjects());
	//System.out.println("Conforming objects: " + getCursoredQueryObjects());
	if (getNormalQueryObjects().size() != getCursoredQueryObjects().size()) {
		throw new TestErrorException("The number of streamed objects does not match the number of objects stored on the database ");
	}

	if (getNormalQueryObjects().size() == 0) {
		throw new TestWarningException("no object with the specified selection criteria was found ");
	}

	for (Enumeration enumtr = getNormalQueryObjects().elements(); enumtr.hasMoreElements();) {
		Object nextObject = enumtr.nextElement();
		if (!getCursoredQueryObjects().remove(nextObject)) {
			throw new TestErrorException("The following element was not found in the conformed result: " + nextObject);
		}
	}	
}

public void reset() {
	if (useNestedUnitOfWork) {
		getExecutor().getSession().release();
	}
	getExecutor().setSession(configuration.getUnitOfWork().getParent());
	configuration.reset();
}
}