public void run(STClass[] classes, STEngine[] engines, boolean a_quiet) { begin(); setSodaTestOn(classes); for (int i = 0; i < engines.length; i++) { engine = engines[i]; engine.reset(); engine.open(); store(classes); engine.commit(); engine.close(); engine.open(); test(classes); engine.close(); engine.reset(); } if (failedTestClasses.size() > 0) { System.err.println("\nFailed test classes:\n"); Iterator4 i = failedTestClasses.iterator(); while (i.moveNext()) { System.err.println(i.current().getClass().getName()); } System.err.println("\n"); } }
public Constraints constraints() { synchronized (streamLock()) { Constraint[] constraints = new Constraint[i_constraints.size()]; i_constraints.toArray(constraints); return new QConstraints(_trans, constraints); } }
private Collection4 fieldPathFromTop() { QQueryBase q = this; final Collection4 fieldPath = new Collection4(); while (q.i_parent != null) { fieldPath.prepend(q.i_field); q = q.i_parent; } return fieldPath; }
private void writeCachedDirty() { Iterator4 i = _dirtyClassMetadata.iterator(); while (i.moveNext()) { PersistentBase dirty = (PersistentBase) i.current(); dirty.write(systemTransaction()); dirty.notCachedDirty(); } _dirtyClassMetadata.clear(); }
public void error(String msg) { if (!failedTestClasses.contains(currentTestClass)) { failedTestClasses.add(currentTestClass); } if (!quiet) { System.err.println(msg); new ExpectationFailed().printStackTrace(); System.err.println(); } }
Constraint toConstraint(final Collection4 constraints) { if (constraints.size() == 1) { return (Constraint) constraints.singleElement(); } else if (constraints.size() > 0) { Constraint[] constraintArray = new Constraint[constraints.size()]; constraints.toArray(constraintArray); return new QConstraints(_trans, constraintArray); } return null; }
private Constraint addEvaluationToAllConstraints(QConEvaluation eval) { if (i_constraints.size() == 0) { _trans .container() .classCollection() .iterateTopLevelClasses( new Visitor4() { public void visit(Object obj) { ClassMetadata classMetadata = (ClassMetadata) obj; QConClass qcc = new QConClass(_trans, classMetadata.classReflector()); addConstraint(qcc); toConstraint(i_constraints).or(qcc); } }); } Iterator4 i = iterateConstraints(); while (i.moveNext()) { ((QCon) i.current()).addConstraint(eval); } // FIXME: should return valid Constraint object return null; }
private Collection4 introduceClassConstrain(ReflectClass claxx) { final Collection4 newConstraints = new Collection4(); final Iterator4 existingConstraints = iterateConstraints(); while (existingConstraints.moveNext()) { final QCon existingConstraint = (QConObject) existingConstraints.current(); final BooleanByRef removeExisting = new BooleanByRef(false); final QCon newConstraint = existingConstraint.shareParentForClass(claxx, removeExisting); if (newConstraint != null) { newConstraints.add(newConstraint); addConstraint(newConstraint); if (removeExisting.value) { removeConstraint(existingConstraint); } } } return newConstraints; }
private Constraint addClassConstraint(ReflectClass claxx) { if (isTheObjectClass(claxx)) { return null; } if (claxx.isInterface()) { return addInterfaceConstraint(claxx); } final Collection4 newConstraints = introduceClassConstrain(claxx); if (newConstraints.isEmpty()) { QConClass qcc = new QConClass(_trans, claxx); addConstraint(qcc); return qcc; } return toConstraint(newConstraints); }
private QConClass classConstraint() { if (i_constraints.size() != 1) { return null; } Constraint constr = singleConstraint(); if (constr.getClass() != QConClass.class) { return null; } return (QConClass) constr; }
private void addConstraint(Collection4 col, Object obj) { if (attachToExistingConstraints(col, obj, true)) { return; } if (attachToExistingConstraints(col, obj, false)) { return; } QConObject newConstraint = new QConObject(_trans, null, null, obj); addConstraint(newConstraint); col.add(newConstraint); }
public void test() { final Collection4 expected = new Collection4(new Object[] {"PING", Boolean.TRUE, new Integer(42)}); final MessageCollector recipient = new MessageCollector(); final ObjectServer server = openServerWith(recipient); try { final ObjectContainer client = openClient("client", server); try { final MessageSender sender = messageSender(client); sendAll(expected, sender); } finally { client.close(); } } finally { server.close(); } Assert.areEqual(expected.toString(), recipient.messages.toString()); }
public QueryResult getQueryResult() { synchronized (streamLock()) { if (i_constraints.size() == 0) { return executeAllObjectsQuery(); } QueryResult result = executeClassOnlyQuery(); if (result != null) { return result; } optimizeJoins(); return executeQuery(); } }
public Iterator4 executeSnapshot() { final CreateCandidateCollectionResult r = createCandidateCollection(); final Collection4 executionPath = executionPath(r); Iterator4 candidatesIterator = new Iterator4Impl(r.candidateCollection); Collection4 snapshots = new Collection4(); while (candidatesIterator.moveNext()) { QCandidates candidates = (QCandidates) candidatesIterator.current(); snapshots.add(candidates.executeSnapshot(executionPath)); } Iterator4 snapshotsIterator = snapshots.iterator(); final CompositeIterator4 resultingIDs = new CompositeIterator4(snapshotsIterator); if (!r.checkDuplicates) { return resultingIDs; } return checkDuplicates(resultingIDs); }
private Constraint addInterfaceConstraint(ReflectClass claxx) { Collection4 classes = stream().classCollection().forInterface(claxx); if (classes.size() == 0) { QConClass qcc = new QConClass(_trans, null, null, claxx); addConstraint(qcc); return qcc; } Iterator4 i = classes.iterator(); Constraint constr = null; while (i.moveNext()) { ClassMetadata classMetadata = (ClassMetadata) i.current(); ReflectClass classMetadataClaxx = classMetadata.classReflector(); if (classMetadataClaxx != null) { if (!classMetadataClaxx.isInterface()) { if (constr == null) { constr = constrain(classMetadataClaxx); } else { constr = constr.or(constrain(classMetadata.classReflector())); } } } } return constr; }
private boolean attachToExistingConstraints( Collection4 newConstraintsCollector, Object obj, boolean onlyForPaths) { boolean found = false; final Iterator4 j = iterateConstraints(); while (j.moveNext()) { QCon existingConstraint = (QCon) j.current(); final BooleanByRef removeExisting = new BooleanByRef(false); if (!onlyForPaths || (existingConstraint instanceof QConPath)) { QCon newConstraint = existingConstraint.shareParent(obj, removeExisting); if (newConstraint != null) { newConstraintsCollector.add(newConstraint); addConstraint(newConstraint); if (removeExisting.value) { removeConstraint(existingConstraint); } found = true; if (!onlyForPaths) { break; } } } } return found; }
public static int failedClassesSize() { return failedTestClasses.size(); }
private boolean descend1(final QQuery query, final String fieldName, IntByRef run) { if (run.value == 2 || i_constraints.size() == 0) { // On the second run we are really creating a second independant // query network that is not joined to other higher level // constraints. // Let's see how this works out. We may need to join networks. run.value = 0; // prevent a double run of this code stream() .classCollection() .attachQueryNode( fieldName, new Visitor4() { boolean untypedFieldConstraintCollected = false; public void visit(Object obj) { Object[] pair = ((Object[]) obj); ClassMetadata containingClass = (ClassMetadata) pair[0]; FieldMetadata field = (FieldMetadata) pair[1]; if (isTyped(field)) { addFieldConstraint(containingClass, field); return; } if (untypedFieldConstraintCollected) return; addFieldConstraint(containingClass, field); untypedFieldConstraintCollected = true; } private boolean isTyped(FieldMetadata field) { return !Handlers4.isUntyped(field.getHandler()); } private void addFieldConstraint( ClassMetadata containingClass, FieldMetadata field) { QConClass qcc = new QConClass( _trans, null, field.qField(_trans), containingClass.classReflector()); addConstraint(qcc); toConstraint(i_constraints).or(qcc); } }); } checkConstraintsEvaluationMode(); final BooleanByRef foundClass = new BooleanByRef(false); Iterator4 i = iterateConstraints(); while (i.moveNext()) { if (((QCon) i.current()).attach(query, fieldName)) { foundClass.value = true; } } return foundClass.value; }
private Constraint singleConstraint() { return (Constraint) i_constraints.singleElement(); }
void removeConstraint(QCon a_constraint) { i_constraints.remove(a_constraint); }
void addConstraint(QCon a_constraint) { i_constraints.add(a_constraint); }