/* | |
* Licensed to the Apache Software Foundation (ASF) under one or more | |
* contributor license agreements. See the NOTICE file distributed with | |
* this work for additional information regarding copyright ownership. | |
* The ASF licenses this file to You under the Apache License, Version 2.0 | |
* (the "License"); you may not use this file except in compliance with | |
* the License. You may obtain a copy of the License at | |
* | |
* http://www.apache.org/licenses/LICENSE-2.0 | |
* | |
* Unless required by applicable law or agreed to in writing, software | |
* distributed under the License is distributed on an "AS IS" BASIS, | |
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. | |
* See the License for the specific language governing permissions and | |
* limitations under the License. | |
*/ | |
package org.apache.jdo.tck.api.persistencemanager.fetchplan; | |
import java.util.ArrayList; | |
import java.util.Arrays; | |
import java.util.Collection; | |
import java.util.HashSet; | |
import java.util.Set; | |
import javax.jdo.FetchPlan; | |
import org.apache.jdo.tck.JDO_Test; | |
import org.apache.jdo.tck.pc.mylib.PCPoint; | |
import org.apache.jdo.tck.pc.mylib.PCRect; | |
import org.apache.jdo.tck.util.BatchTestRunner; | |
/** | |
*<B>Title:</B> Test TITLE | |
*<BR> | |
*<B>Keywords:</B> fetch plan | |
*<BR> | |
*<B>Assertion IDs:</B> 12.7.1-1 | |
*<BR> | |
*<B>Assertion Description: </B> | |
public interface FetchPlan { | |
String DEFAULT = "default"; | |
String ALL = "all"; | |
int FETCH_SIZE_GREEDY = -1; | |
int FETCH_SIZE_OPTIMAL = 0; | |
int DETACH_LOAD_FIELDS = 1; | |
int DETACH_UNLOAD_FIELDS = 2; | |
A12.7.1-1 [/** Add the fetchgroup to the set of active fetch groups. Duplicate names will be removed. | |
FetchPlan addGroup(String fetchGroupName); | |
/** Remove the fetch group from the set active fetch groups. | |
FetchPlan removeGroup(String fetchGroupName); | |
/** Remove all active groups, including the default fetch group. | |
FetchPlan clearGroups(); | |
/** Return an immutable Set of the names of all active fetch groups. | |
Set getGroups(); | |
/** Set a Collection of group names to replace the current groups. Duplicate names will be removed. | |
FetchPlan setGroups(Collection fetchGroupNames); | |
/** Set an array of group names to replace the current groups. Duplicate names will be removed. | |
FetchPlan setGroups(String[] fetchGroupNames); | |
/** Set a single group to replace the current groups. | |
FetchPlan setGroup(String fetchGroupName);] | |
/** Set the roots for DetachAllOnCommit | |
FetchPlan setDetachmentRoots(Collection roots); | |
/** Get the roots for DetachAllOnCommit | |
Collection getDetachmentRoots(); | |
/** Set the roots for DetachAllOnCommit | |
FetchPlan setDetachmentRootClasses(Class[] rootClasses); | |
/** Get the roots for DetachAllOnCommit | |
Class[] getDetachmentRootClasses(); | |
/** Set the maximum fetch depth. | |
FetchPlan setMaxFetchDepth(int fetchDepth); | |
/** Get the maximum fetch depth. | |
int getMaxFetchDepth(); | |
A12.7.1-2 [/** Set the fetch size for large result set support. | |
FetchPlan setFetchSize(int fetchSize); | |
/** Return the fetch size; 0 if not set; -1 for greedy fetching. | |
int getFetchSize();] | |
A12.7.1-3 [/** Set detachment options | |
FetchPlan setDetachmentOptions(int options); | |
/** Return the detachment options | |
int getDetachmentOptions();] | |
*/ | |
public class FetchPlanInterface extends JDO_Test { | |
/** */ | |
private static final String ASSERTION_FAILED = | |
"Assertion 12.7.1-1 (FetchPlanTest) failed: "; | |
/** | |
* The <code>main</code> is called when the class | |
* is directly executed from the command line. | |
* @param args The arguments passed to the program. | |
*/ | |
public static void main(String[] args) { | |
BatchTestRunner.run(FetchPlanInterface.class); | |
} | |
/** | |
* @see JDO_Test#localSetUp() | |
*/ | |
protected void localSetUp() { | |
addTearDownClass(PCRect.class); | |
addTearDownClass(PCPoint.class); | |
} | |
/** */ | |
protected boolean setEquals | |
(Collection expected, Collection actual) { | |
if (expected == actual) | |
return true; | |
if (expected == null || actual == null) | |
return false; | |
Set expectedSet = new HashSet(expected); | |
Set actualSet = new HashSet(actual); | |
return expectedSet.equals(actualSet); | |
} | |
/** */ | |
protected void failCompare(String message, | |
Object expected, Object actual) { | |
appendMessage(ASSERTION_FAILED + message); | |
appendMessage("expected: " + expected); | |
appendMessage("actual: " + actual); | |
} | |
/** */ | |
protected void failCompare(String message, | |
int expected, int actual) { | |
appendMessage(ASSERTION_FAILED + message); | |
appendMessage("expected: " + expected); | |
appendMessage("actual: " + actual); | |
} | |
/** */ | |
public void testGroups() { | |
checkDefaultGroups(); | |
checkClearGroups(); | |
checkSetGroup(); | |
checkAddGroup(); | |
checkRemoveGroup(); | |
checkClearGroups(); | |
checkSetGroupsCollection(); | |
checkSetGroupsArray(); | |
failOnError(); | |
} | |
/** */ | |
public void testDetachmentRoots() { | |
checkGetDetachmentRoots(); | |
checkSetDetachmentRoots(); | |
checkSetDetachmentRootClasses(); | |
failOnError(); | |
} | |
/** */ | |
public void testDetachmentOptions() { | |
int expectedOptions = | |
FetchPlan.DETACH_LOAD_FIELDS + | |
FetchPlan.DETACH_UNLOAD_FIELDS; | |
FetchPlan fp = getPM().getFetchPlan(); | |
int initialOptions = fp.getDetachmentOptions(); | |
if (FetchPlan.DETACH_LOAD_FIELDS != initialOptions) { | |
failCompare( | |
"testDetachmentOptions(): wrong getDetachmentOptions() " + | |
"after getPersistenceManager().", | |
FetchPlan.DETACH_LOAD_FIELDS, initialOptions); | |
} | |
fp.setDetachmentOptions(expectedOptions); | |
int actualOptions = fp.getDetachmentOptions(); | |
if (expectedOptions != actualOptions) { | |
failCompare( | |
"testDetachmentOptions(): wrong getDetachmentOptions() " + | |
"after setDetachmentOptions().", | |
expectedOptions, actualOptions); | |
} | |
cleanupPM(); | |
failOnError(); | |
} | |
/** */ | |
public void testMaxFetchDepth() { | |
int expectedMaxFetchDepth = 12; | |
FetchPlan fp = getPM().getFetchPlan(); | |
fp.setMaxFetchDepth(expectedMaxFetchDepth); | |
int actualMaxFetchDepth = fp.getMaxFetchDepth(); | |
if (expectedMaxFetchDepth != actualMaxFetchDepth) { | |
failCompare( | |
"testMaxFetchDepth(): wrong getMaxFetchDepth() " + | |
"after setMaxFetchDepth().", | |
expectedMaxFetchDepth, actualMaxFetchDepth); | |
} | |
cleanupPM(); | |
failOnError(); | |
} | |
/** */ | |
public void testFetchSize() { | |
int expectedFetchSize = 12; | |
FetchPlan fp = getPM().getFetchPlan(); | |
fp.setFetchSize(expectedFetchSize); | |
int actualFetchSize = fp.getFetchSize(); | |
if (expectedFetchSize != actualFetchSize) { | |
failCompare( | |
"testFetchSize(): wrong getFetchSize() " + | |
"after setFetchSize().", | |
expectedFetchSize, actualFetchSize); | |
} | |
cleanupPM(); | |
failOnError(); | |
} | |
/** */ | |
public void checkDefaultGroups() { | |
Set expectedGroups = new HashSet(); | |
expectedGroups.add("default"); | |
FetchPlan fp = getPM().getFetchPlan(); | |
Collection groups = fp.getGroups(); | |
if (!setEquals(expectedGroups, groups)) { | |
failCompare( | |
"checkDefaultGroups(): wrong getGroups() " + | |
"after getPersistenceManager().", | |
expectedGroups, groups); | |
} | |
cleanupPM(); | |
} | |
/** */ | |
public void checkClearGroups() { | |
Set expectedGroups = new HashSet(); | |
FetchPlan fp = getPM().getFetchPlan(); | |
fp.clearGroups(); | |
Collection groups = fp.getGroups(); | |
if (!setEquals(expectedGroups, groups)) { | |
failCompare( | |
"checkClearGroups(): wrong getGroups() " + | |
"after clearGroups.", | |
expectedGroups, groups); | |
} | |
cleanupPM(); | |
} | |
/** */ | |
public void checkSetGroup() { | |
Set expectedGroups = new HashSet(); | |
expectedGroups.add("group1"); | |
FetchPlan fp = getPM().getFetchPlan(); | |
fp.setGroup("group1"); | |
Collection groups = fp.getGroups(); | |
if (!setEquals(expectedGroups, groups)) { | |
failCompare( | |
"checkSetGroup(): wrong getGroups() " + | |
"after setGroup.", | |
expectedGroups, groups); | |
} | |
cleanupPM(); | |
} | |
/** */ | |
public void checkAddGroup() { | |
Set expectedGroups = new HashSet(); | |
expectedGroups.add("default"); | |
expectedGroups.add("group1"); | |
FetchPlan fp = getPM().getFetchPlan(); | |
fp.addGroup("group1"); | |
Collection groups = fp.getGroups(); | |
if (!setEquals(expectedGroups, groups)) { | |
failCompare( | |
"checkAddGroup(): wrong getGroups() " + | |
"after addGroup.", | |
expectedGroups, groups); | |
} | |
cleanupPM(); | |
} | |
/** */ | |
public void checkRemoveGroup() { | |
Set expectedGroups = new HashSet(); | |
FetchPlan fp = getPM().getFetchPlan(); | |
fp.removeGroup("default"); | |
Collection groups = fp.getGroups(); | |
if (!setEquals(expectedGroups, groups)) { | |
failCompare( | |
"checkRemoveGroup(): wrong getGroups() " + | |
"after removeGroup.", | |
expectedGroups, groups); | |
} | |
cleanupPM(); | |
} | |
/** */ | |
public void checkSetGroupsCollection() { | |
Set expectedGroups = new HashSet(); | |
expectedGroups.add("default"); | |
expectedGroups.add("group1"); | |
expectedGroups.add("group2"); | |
FetchPlan fp = getPM().getFetchPlan(); | |
fp.setGroups(expectedGroups); | |
Collection groups = fp.getGroups(); | |
if (!setEquals(expectedGroups, groups)) { | |
failCompare( | |
"checkSetGroupsCollection(): wrong getGroups() " + | |
"after SetGroups(Collection).", | |
expectedGroups, groups); | |
} | |
cleanupPM(); | |
} | |
/** */ | |
public void checkSetGroupsArray() { | |
Set expectedGroups = new HashSet(); | |
expectedGroups.add("default"); | |
expectedGroups.add("group1"); | |
expectedGroups.add("group2"); | |
FetchPlan fp = getPM().getFetchPlan(); | |
fp.setGroups(new String[] {"default", "group1", "group2"}); | |
Collection groups = fp.getGroups(); | |
if (!setEquals(expectedGroups, groups)) { | |
failCompare( | |
"checkSetGroupsArray(): wrong getGroups() " + | |
"after setGroups(String[]).", | |
expectedGroups, groups); | |
} | |
cleanupPM(); | |
} | |
/** */ | |
protected void checkGetDetachmentRoots() { | |
Set expectedRoots = new HashSet(); | |
FetchPlan fp = getPM().getFetchPlan(); | |
Collection roots = fp.getDetachmentRoots(); | |
if (!setEquals(expectedRoots, roots)) { | |
failCompare( | |
"checkGetDetachmentRoots(): wrong getDetachmentRoots() " + | |
"after getPersistenceManager().", | |
expectedRoots, roots); | |
} | |
cleanupPM(); | |
} | |
/** */ | |
protected void checkSetDetachmentRoots() { | |
PCPoint p = new PCPoint(10, 20); | |
Set expectedRoots = new HashSet(); | |
expectedRoots.add(p); | |
FetchPlan fp = getPM().getFetchPlan(); | |
fp.setDetachmentRoots(expectedRoots); | |
Collection roots = fp.getDetachmentRoots(); | |
if (!setEquals(expectedRoots, roots)) { | |
failCompare( | |
"checkGetDetachmentRoots(): wrong getDetachmentRoots() " + | |
"after setDetachmentRoots().", | |
expectedRoots, roots); | |
} | |
cleanupPM(); | |
} | |
/** */ | |
private void checkSetDetachmentRootClasses() { | |
Class[] expectedRootClasses = new Class[] {PCPoint.class}; | |
FetchPlan fp = getPM().getFetchPlan(); | |
fp.setDetachmentRootClasses( | |
expectedRootClasses); | |
Class[] rootClasses = fp.getDetachmentRootClasses(); | |
if (!Arrays.equals(expectedRootClasses, rootClasses)) { | |
failCompare( | |
"checkGetDetachmentRootClasses(): " + | |
"wrong getDetachmentRootClasses() " + | |
"after setDetachmentRootClasses().", | |
expectedRootClasses, rootClasses); | |
} | |
cleanupPM(); | |
} | |
} |