public void conc2(ExtObjectContainer oc) {
oc.store(new CreateIndexFor("d"));
tQueryB(oc);
tUpdateB(oc);
oc.store(new CreateIndexFor("z"));
oc.store(new CreateIndexFor("y"));
}
void checkHelper(Db4oHashMapHelper helper) {
ExtObjectContainer con = db();
if (con.isActive(helper)) {
Assert.areEqual("hi", helper.i_childList.get(0));
checkHelper(helper.i_child);
}
}
/*
* delete - set - commit set - commit delete
*/
public void testSD() {
ExtObjectContainer oc1 = openNewSession();
ExtObjectContainer oc2 = openNewSession();
ExtObjectContainer oc3 = openNewSession();
try {
SimpleObject o1 = (SimpleObject) retrieveOnlyInstance(oc1, SimpleObject.class);
oc1.delete(o1);
SimpleObject o2 = (SimpleObject) retrieveOnlyInstance(oc2, SimpleObject.class);
Assert.areEqual("hello", o2.getS());
o2.setS("o2");
oc2.store(o2);
oc2.commit();
oc1.commit();
assertOccurrences(oc1, SimpleObject.class, 0);
assertOccurrences(oc2, SimpleObject.class, 0);
assertOccurrences(oc3, SimpleObject.class, 0);
} finally {
oc1.close();
oc2.close();
oc3.close();
}
}
public void conc(ExtObjectContainer oc) {
oc.queryByExample((new QueryNonExistantTestCase(true)));
assertOccurrences(oc, QueryNonExistantTestCase.class, 0);
Query q = oc.query();
q.constrain(new QueryNonExistantTestCase(true));
Assert.areEqual(0, q.execute().size());
}
private MockActivatable retrieveMockFromNewClientAndClose() {
final ExtObjectContainer client = openNewSession();
try {
return retrieveMock(client);
} finally {
client.close();
}
}
public void concUpdateSameObject(ExtObjectContainer oc, int seq) throws Exception {
Query query = oc.query();
query.descend("_s").constrain(testString + COUNT / 2);
ObjectSet result = query.execute();
Assert.areEqual(1, result.size());
SimpleObject o = (SimpleObject) result.next();
o.setI(COUNT + seq);
oc.store(o);
}
public void conc(ExtObjectContainer oc) {
Query q = oc.query();
q.constrain(QueryForUnknownFieldTestCase.class);
q.descend("_name").constrain("name");
Assert.areEqual(1, q.execute().size());
q = oc.query();
q.constrain(QueryForUnknownFieldTestCase.class);
q.descend("name").constrain("name");
Assert.areEqual(0, q.execute().size());
}
public void concUpdateDifferentObject(ExtObjectContainer oc, int seq) throws Exception {
Query query = oc.query();
query
.descend("_s")
.constrain(testString + seq)
.and(query.descend("_i").constrain(new Integer(seq)));
ObjectSet result = query.execute();
Assert.areEqual(1, result.size());
SimpleObject o = (SimpleObject) result.next();
o.setI(seq + COUNT);
oc.store(o);
}
public void testQuery() {
ExtObjectContainer oc = fixture().db();
initGenericObjects();
ReflectClass rc = getReflectClass(oc, PERSON_CLASSNAME);
Assert.isNotNull(rc);
// now query to make sure there are none left
Query q = oc.query();
q.constrain(rc);
q.descend("surname").constrain("John");
ObjectSet results = q.execute();
Assert.isTrue(results.size() == 1);
}
public void concUpdate(ExtObjectContainer oc, int seq) throws Exception {
Query q = oc.query();
q.constrain(IndexedByIdentityTestCase.class);
ObjectSet os = q.execute();
Assert.areEqual(COUNT, os.size());
while (os.hasNext()) {
IndexedByIdentityTestCase idi = (IndexedByIdentityTestCase) os.next();
idi.atom.name = "updated" + seq;
oc.store(idi);
Thread.sleep(100);
}
}
public void testUpdate() {
ExtObjectContainer oc = fixture().db();
initGenericObjects();
// Db4oUtil.dump(oc);
ReflectClass rc = getReflectClass(oc, PERSON_CLASSNAME);
Assert.isNotNull(rc);
Query q = oc.query();
q.constrain(rc);
ObjectSet results = q.execute();
// Db4oUtil.dumpResults(oc, results);
Assert.isTrue(results.size() == 1);
}
private void tUpdateB(ExtObjectContainer oc) {
ObjectSet res = query(oc, "b");
CreateIndexFor ci = (CreateIndexFor) res.next();
ci.i_name = "j";
oc.store(ci);
res = query(oc, "b");
Assert.areEqual(0, res.size());
res = query(oc, "j");
Assert.areEqual(1, res.size());
ci.i_name = "b";
oc.store(ci);
tQueryB(oc);
}
public void testCreate() throws Exception {
initGenericObjects();
// fixture().reopen();
ExtObjectContainer oc = fixture().db();
// now check to see if person was saved
ReflectClass rc = getReflectClass(oc, PERSON_CLASSNAME);
Assert.isNotNull(rc);
Query q = oc.query();
q.constrain(rc);
ObjectSet results = q.execute();
Assert.isTrue(results.size() == 1);
// Db4oUtil.dumpResults(fixture().db(), results);
}
public void concRead(ExtObjectContainer oc) {
for (int i = 0; i < COUNT; i++) {
Query q = oc.query();
q.constrain(Atom.class);
q.descend("name").constrain("ibi" + i);
ObjectSet objectSet = q.execute();
Assert.areEqual(1, objectSet.size());
Atom child = (Atom) objectSet.next();
q = oc.query();
q.constrain(IndexedByIdentityTestCase.class);
q.descend("atom").constrain(child).identity();
objectSet = q.execute();
Assert.areEqual(1, objectSet.size());
IndexedByIdentityTestCase ibi = (IndexedByIdentityTestCase) objectSet.next();
Assert.areSame(child, ibi.atom);
}
}
public void checkUpdateSameObject(ExtObjectContainer oc) throws Exception {
Query query = oc.query();
query.descend("_s").constrain(testString + COUNT / 2);
ObjectSet result = query.execute();
Assert.areEqual(1, result.size());
SimpleObject o = (SimpleObject) result.next();
int i = o.getI();
Assert.isTrue(COUNT <= i && i < COUNT + threadCount());
}
public void checkUpdateDifferentObject(ExtObjectContainer oc) throws Exception {
ObjectSet result = oc.query(SimpleObject.class);
Assert.areEqual(COUNT, result.size());
while (result.hasNext()) {
SimpleObject o = (SimpleObject) result.next();
int i = o.getI();
if (i >= COUNT) {
i -= COUNT;
}
Assert.areEqual(testString + i, o.getS());
}
}
public void concDelete(ExtObjectContainer oc) throws Exception {
int size = countOccurences(oc, SimpleObject.class);
if (size == 0) { // already deleted
return;
}
Assert.areEqual(ELEMENT_COUNT, size);
ObjectSet os = oc.query(ArrayItem.class);
if (os.size() == 0) { // already deteled
return;
}
Assert.areEqual(1, os.size());
ArrayItem item = (ArrayItem) os.next();
// waits for other threads
Thread.sleep(500);
oc.delete(item);
oc.commit();
assertOccurrences(oc, SimpleObject.class, 0);
}
private void operateOnClient1And2(
ArrayList4Operation<Integer> op1, ArrayList4Operation<Integer> op2) throws Exception {
ExtObjectContainer client1 = openNewSession();
ExtObjectContainer client2 = openNewSession();
ArrayList4<Integer> list1 = retrieveAndAssertNullArrayList4(client1);
ArrayList4<Integer> list2 = retrieveAndAssertNullArrayList4(client2);
op1.operate(list1);
op2.operate(list2);
client1.store(list1);
client2.store(list2);
client1.commit();
client2.commit();
client1.close();
client2.close();
}
/**
* This is to ensure that reflector.forObject(GenericArray) returns an instance of
* GenericArrayClass instead of GenericClass http://tracker.db4o.com/jira/browse/COR-376
*/
public void testGenericArrayClass() {
ExtObjectContainer oc = fixture().db();
initGenericObjects();
ReflectClass elementType = oc.reflector().forName(PERSON_CLASSNAME);
Object array = reflector().array().newInstance(elementType, 5);
ReflectClass arrayClass = oc.reflector().forObject(array);
Assert.isTrue(arrayClass.isArray());
Assert.isTrue(arrayClass instanceof GenericArrayClass);
arrayClass = oc.reflector().forName(array.getClass().getName());
Assert.isTrue(arrayClass.isArray());
Assert.isTrue(arrayClass instanceof GenericArrayClass);
arrayClass = oc.reflector().forClass(array.getClass());
Assert.isTrue(arrayClass.isArray());
Assert.isTrue(arrayClass instanceof GenericArrayClass);
Assert.areEqual(arrayClass.getName(), ReflectPlatform.fullyQualifiedName(array.getClass()));
Assert.areEqual("(GA) " + elementType.getName(), array.toString());
}
public void test() throws Exception {
int total = 10;
ExtObjectContainer[] containers = new ExtObjectContainer[total];
ExtObjectContainer container = null;
try {
for (int i = 0; i < total; i++) {
containers[i] = openNewSession();
Assert.areEqual(ELEMENT_COUNT, countOccurences(containers[i], SimpleObject.class));
}
for (int i = 0; i < total; i++) {
deleteAll(containers[i], SimpleObject.class);
}
container = openNewSession();
assertOccurrences(container, SimpleObject.class, ELEMENT_COUNT);
// ocs[0] deletes all SimpleObject
containers[0].commit();
containers[0].close();
// FIXME: the following assertion fails
assertOccurrences(container, SimpleObject.class, 0);
for (int i = 1; i < total; i++) {
containers[i].close();
}
assertOccurrences(container, SimpleObject.class, 0);
} finally {
if (container != null) {
container.close();
}
for (int i = 0; i < total; i++) {
if (containers[i] != null) {
containers[i].close();
}
}
}
}
public void checkUpdate(ExtObjectContainer oc) {
Query q = oc.query();
q.constrain(IndexedByIdentityTestCase.class);
ObjectSet os = q.execute();
Assert.areEqual(COUNT, os.size());
String expected = null;
while (os.hasNext()) {
IndexedByIdentityTestCase idi = (IndexedByIdentityTestCase) os.next();
if (expected == null) {
expected = idi.atom.name;
Assert.isTrue(expected.startsWith("updated"));
Assert.isTrue(expected.length() > "updated".length());
}
Assert.areEqual(expected, idi.atom.name);
}
}
private void tQueryInts(ExtObjectContainer oc, int expectedZeroSize) {
Query q = oc.query();
q.constrain(CreateIndexFor.class);
q.descend("i_int").constrain(new Integer(0));
int zeroSize = q.execute().size();
Assert.areEqual(expectedZeroSize, zeroSize);
q = oc.query();
q.constrain(CreateIndexFor.class);
q.descend("i_int").constrain(new Integer(4)).greater().equal();
tExpectInts(q, new int[] {5, 7});
q = oc.query();
q.constrain(CreateIndexFor.class);
q.descend("i_int").constrain(new Integer(4)).greater();
tExpectInts(q, new int[] {5, 7});
q = oc.query();
q.constrain(CreateIndexFor.class);
q.descend("i_int").constrain(new Integer(3)).greater();
tExpectInts(q, new int[] {5, 7});
q = oc.query();
q.constrain(CreateIndexFor.class);
q.descend("i_int").constrain(new Integer(3)).greater().equal();
tExpectInts(q, new int[] {3, 3, 5, 7});
q = oc.query();
q.constrain(CreateIndexFor.class);
q.descend("i_int").constrain(new Integer(2)).greater().equal();
tExpectInts(q, new int[] {2, 3, 3, 5, 7});
q = oc.query();
q = oc.query();
q.constrain(CreateIndexFor.class);
q.descend("i_int").constrain(new Integer(2)).greater();
tExpectInts(q, new int[] {3, 3, 5, 7});
q = oc.query();
q.constrain(CreateIndexFor.class);
q.descend("i_int").constrain(new Integer(1)).greater().equal();
tExpectInts(q, new int[] {1, 2, 3, 3, 5, 7});
q = oc.query();
q.constrain(CreateIndexFor.class);
q.descend("i_int").constrain(new Integer(1)).greater();
tExpectInts(q, new int[] {2, 3, 3, 5, 7});
q = oc.query();
q.constrain(CreateIndexFor.class);
q.descend("i_int").constrain(new Integer(4)).smaller();
tExpectInts(q, new int[] {1, 2, 3, 3}, zeroSize);
q = oc.query();
q.constrain(CreateIndexFor.class);
q.descend("i_int").constrain(new Integer(4)).smaller().equal();
tExpectInts(q, new int[] {1, 2, 3, 3}, zeroSize);
q = oc.query();
q.constrain(CreateIndexFor.class);
q.descend("i_int").constrain(new Integer(3)).smaller();
tExpectInts(q, new int[] {1, 2}, zeroSize);
q = oc.query();
q.constrain(CreateIndexFor.class);
q.descend("i_int").constrain(new Integer(3)).smaller().equal();
tExpectInts(q, new int[] {1, 2, 3, 3}, zeroSize);
q = oc.query();
q.constrain(CreateIndexFor.class);
q.descend("i_int").constrain(new Integer(2)).smaller().equal();
tExpectInts(q, new int[] {1, 2}, zeroSize);
q = oc.query();
q = oc.query();
q.constrain(CreateIndexFor.class);
q.descend("i_int").constrain(new Integer(2)).smaller();
tExpectInts(q, new int[] {1}, zeroSize);
q = oc.query();
q.constrain(CreateIndexFor.class);
q.descend("i_int").constrain(new Integer(1)).smaller().equal();
tExpectInts(q, new int[] {1}, zeroSize);
q = oc.query();
q.constrain(CreateIndexFor.class);
q.descend("i_int").constrain(new Integer(1)).smaller();
tExpectInts(q, new int[] {}, zeroSize);
}
/*
* delete - set - commit delete - commit set
*/
public void _testDS() {
ExtObjectContainer oc1 = openNewSession();
ExtObjectContainer oc2 = openNewSession();
ExtObjectContainer oc3 = openNewSession();
try {
SimpleObject o1 = (SimpleObject) retrieveOnlyInstance(oc1, SimpleObject.class);
oc1.delete(o1);
SimpleObject o2 = (SimpleObject) retrieveOnlyInstance(oc2, SimpleObject.class);
Assert.areEqual("hello", o2.getS());
o2.setS("o2");
oc2.store(o2);
oc1.commit();
oc2.commit();
o1 = (SimpleObject) retrieveOnlyInstance(oc1, SimpleObject.class);
oc1.refresh(o1, Integer.MAX_VALUE);
Assert.areEqual("o2", o1.getS());
o2 = (SimpleObject) retrieveOnlyInstance(oc2, SimpleObject.class);
oc2.refresh(o2, Integer.MAX_VALUE);
Assert.areEqual("o2", o2.getS());
SimpleObject o3 = (SimpleObject) retrieveOnlyInstance(oc3, SimpleObject.class);
oc1.refresh(o1, Integer.MAX_VALUE);
Assert.areEqual("o2", o3.getS());
} finally {
oc1.close();
oc2.close();
oc3.close();
}
}
private ReflectClass getReflectClass(ExtObjectContainer oc, String className) {
return oc.reflector().forName(className);
}
public void concQueryCaseInsenstive(ExtObjectContainer oc) {
Query q = oc.query();
q.constrain(CaseInsensitiveTestCase.class);
q.constrain(new CaseInsensitiveEvaluation("helloworld"));
Assert.areEqual(1, q.execute().size());
}
public void testRefresh() {
ExtObjectContainer client1 = openNewSession();
ExtObjectContainer client2 = openNewSession();
TAItem item1 = (TAItem) retrieveInstance(client1);
TAItem item2 = (TAItem) retrieveInstance(client2);
assertDescendingRange(10, item1);
assertDescendingRange(10, item2);
item1.value(100);
item1.next().value(200);
client1.store(item1, 2);
client1.commit();
Assert.areEqual(100, item1.value());
Assert.areEqual(200, item1.next().value());
Assert.areEqual(10, item2.value());
Assert.areEqual(9, item2.next().value());
// refresh 0
client2.refresh(item2, 0);
Assert.areEqual(10, item2.value());
Assert.areEqual(9, item2.next().value());
// refresh 1
client2.refresh(item2, 1);
Assert.areEqual(100, item2.value());
Assert.areEqual(9, item2.next().value());
// refresh 2
client2.refresh(item2, 2);
Assert.areEqual(100, item2.value());
Assert.areEqual(200, item2.next().value());
updateAscendingWithRange(item1, 1000);
client1.store(item1, 5);
client1.commit();
client2.refresh(item2, 5);
TAItem next2 = item2;
for (int i = 1000; i < 1005; i++) {
Assert.areEqual(i, next2.value());
next2 = next2.next();
}
client1.close();
client2.close();
}
private Object retrieveInstance(ExtObjectContainer client) {
Query query = client.query();
query.constrain(_class);
query.descend("_isRoot").constrain(new Boolean(true));
return query.execute().next();
}
private ObjectSet query(ExtObjectContainer oc, String n) {
Query q = oc.query();
q.constrain(CreateIndexFor.class);
q.descend("i_name").constrain(n);
return q.execute();
}
public void testRefresh() {
ExtObjectContainer client1 = openNewSession();
ExtObjectContainer client2 = openNewSession();
Item item1 = retrieveInstance(client1);
Item item2 = retrieveInstance(client2);
Item next1 = item1;
int value = 10;
while (next1 != null) {
Assert.areEqual(value, next1.getValue());
next1 = next1.next();
value--;
}
Item next2 = item2;
value = 10;
while (next2 != null) {
Assert.areEqual(value, next2.getValue());
next2 = next2.next();
value--;
}
item1.setValue(100);
item1.next().setValue(200);
client1.store(item1, 2);
client1.commit();
Assert.areEqual(100, item1.getValue());
Assert.areEqual(200, item1.next().getValue());
Assert.areEqual(10, item2.getValue());
Assert.areEqual(9, item2.next().getValue());
// refresh 0
client2.refresh(item2, 0);
Assert.areEqual(10, item2.getValue());
Assert.areEqual(9, item2.next().getValue());
// refresh 1
client2.refresh(item2, 1);
Assert.areEqual(100, item2.getValue());
Assert.areEqual(9, item2.next().getValue());
// refresh 2
client2.refresh(item2, 2);
Assert.areEqual(100, item2.getValue());
// FIXME: maybe a bug
// Assert.areEqual(200, item2.next().getValue());
next1 = item1;
value = 1000;
while (next1 != null) {
next1.setValue(value);
next1 = next1.next();
value++;
}
client1.store(item1, 5);
client1.commit();
client2.refresh(item2, 5);
next2 = item2;
for (int i = 1000; i < 1005; i++) {
Assert.areEqual(i, next2.getValue());
next2 = next2.next();
}
client1.close();
client2.close();
}