public virtual void TestDrainTo()
{
var queue = new BlockingQueue();
queue.Add(new object());
queue.Add(new object());
var list = new Collection4();
Assert.AreEqual(2, queue.DrainTo(list));
Assert.AreEqual(2, list.Size());
Assert.IsFalse(queue.HasNext());
}
/// <exception cref="System.Exception"></exception>
public virtual void TestDrainTo()
{
IPausableBlockingQueue4 queue = new PausableBlockingQueue();
queue.Add(new object());
queue.Add(new object());
queue.Pause();
Collection4 list = new Collection4();
Thread t = ExecuteAfter("Pausable queue drainer", 0, new _IRunnable_66(queue, list
));
Runtime4.SleepThrowsOnInterrupt(200);
lock (list)
{
Assert.AreEqual(0, list.Size());
}
Assert.IsTrue(queue.HasNext());
queue.Resume();
t.Join();
lock (list)
{
Assert.AreEqual(2, list.Size());
}
Assert.IsFalse(queue.HasNext());
}
public virtual IConstraint[] ToArray()
{
lock (_cluster)
{
Collection4 all = new Collection4();
for (int i = 0; i < _constraints.Length; i++)
{
ClusterConstraint c = (ClusterConstraint)_constraints[i];
for (int j = 0; j < c._constraints.Length; j++)
{
all.Add(c._constraints[j]);
}
}
IConstraint[] res = new IConstraint[all.Size()];
all.ToArray(res);
return res;
}
}
internal virtual Db4objects.Db4o.Internal.Query.Processor.QCon ProduceTopLevelJoin
()
{
if (!HasJoins())
{
return this;
}
IEnumerator i = IterateJoins();
if (i_joins.Size() == 1)
{
i.MoveNext();
return ((Db4objects.Db4o.Internal.Query.Processor.QCon)i.Current).ProduceTopLevelJoin
();
}
Collection4 col = new Collection4();
while (i.MoveNext())
{
col.Ensure(((Db4objects.Db4o.Internal.Query.Processor.QCon)i.Current).ProduceTopLevelJoin
());
}
i = col.GetEnumerator();
i.MoveNext();
Db4objects.Db4o.Internal.Query.Processor.QCon qcon = (Db4objects.Db4o.Internal.Query.Processor.QCon
)i.Current;
if (col.Size() == 1)
{
return qcon;
}
while (i.MoveNext())
{
qcon = (Db4objects.Db4o.Internal.Query.Processor.QCon)qcon.And((IConstraint)i.Current
);
}
return qcon;
}
public static object[] ToArray(IEnumerator tests, IArrayFactory factory)
{
Collection4 elements = new Collection4(tests);
return(elements.ToArray(factory.NewArray(elements.Size())));
}
private void AssertNotContainsNull(Collection4 c)
{
Assert.IsFalse(c.Contains(null));
Assert.IsNull(c.Get(null));
int size = c.Size();
c.Ensure(null);
Assert.AreEqual(size + 1, c.Size());
c.Remove(null);
Assert.AreEqual(size, c.Size());
}
private void AssertCollection(string[] expected, Collection4 c)
{
Assert.AreEqual(expected.Length, c.Size());
Iterator4Assert.AreEqual(expected, c.GetEnumerator());
}
private ClassAspect[] ToClassAspectArray(Collection4 aspects)
{
var array = new ClassAspect[aspects.Size()];
aspects.ToArray(array);
for (var i = 0; i < array.Length; i++)
{
array[i].SetHandle(i);
}
return array;
}
internal virtual QCon ProduceTopLevelJoin
()
{
if (!HasJoins())
{
return this;
}
var i = IterateJoins();
if (i_joins.Size() == 1)
{
i.MoveNext();
return ((QCon) i.Current).ProduceTopLevelJoin
();
}
var col = new Collection4();
while (i.MoveNext())
{
col.Ensure(((QCon) i.Current).ProduceTopLevelJoin
());
}
i = col.GetEnumerator();
i.MoveNext();
var qcon = (QCon
) i.Current;
if (col.Size() == 1)
{
return qcon;
}
while (i.MoveNext())
{
qcon = (QCon) qcon.And((IConstraint) i.Current
);
}
return qcon;
}
public static object[] ToArray(IEnumerator tests, IArrayFactory factory)
{
Collection4 elements = new Collection4(tests);
return elements.ToArray(factory.NewArray(elements.Size()));
}
public virtual void TestMap()
{
int[] array = new int[] { 1, 2, 3 };
Collection4 args = new Collection4();
IEnumerator iterator = Iterators.Map(IntArrays4.NewIterator(array), new _IFunction4_149
(args));
Assert.IsNotNull(iterator);
Assert.AreEqual(0, args.Size());
for (int i = 0; i < array.Length; ++i)
{
Assert.IsTrue(iterator.MoveNext());
Assert.AreEqual(i + 1, args.Size());
Assert.AreEqual(array[i] * 2, iterator.Current);
}
}
private void AssertEntries(PersistentEntry[] expected, IEnumerator actual)
{
Collection4 checklist = new Collection4(actual);
Assert.AreEqual(expected.Length, checklist.Size());
for (int i = 0; i < expected.Length; ++i)
{
PersistentEntry e = expected[i];
PersistentEntry a = EntryByUid(checklist.GetEnumerator(), e.uid);
if (a != null)
{
AssertEqualEntries(e, a);
checklist.Remove(a);
}
}
Assert.IsTrue(checklist.IsEmpty(), checklist.ToString());
}
internal virtual IConstraint ToConstraint(Collection4 constraints)
{
if (constraints.Size() == 1)
{
return (IConstraint) constraints.SingleElement();
}
if (constraints.Size() > 0)
{
var constraintArray = new IConstraint[constraints.Size()];
constraints.ToArray(constraintArray);
return new QConstraints(_trans, constraintArray);
}
return null;
}
private void AssertContainsNull(Collection4 c)
{
Assert.IsTrue(c.Contains(null));
Assert.IsNull(c.Get(null));
var size = c.Size();
c.Ensure(null);
Assert.AreEqual(size, c.Size());
}
internal virtual IConstraint Join1(Db4objects.Db4o.Internal.Query.Processor.QCon
a_with, bool a_and)
{
if (a_with is QConstraints)
{
int j = 0;
Collection4 joinHooks = new Collection4();
IConstraint[] constraints = ((QConstraints)a_with).ToArray();
for (j = 0; j < constraints.Length; j++)
{
joinHooks.Ensure(((Db4objects.Db4o.Internal.Query.Processor.QCon)constraints[j]).
JoinHook());
}
IConstraint[] joins = new IConstraint[joinHooks.Size()];
j = 0;
IEnumerator i = joinHooks.GetEnumerator();
while (i.MoveNext())
{
joins[j++] = Join((IConstraint)i.Current, a_and);
}
return new QConstraints(i_trans, joins);
}
Db4objects.Db4o.Internal.Query.Processor.QCon myHook = JoinHook();
Db4objects.Db4o.Internal.Query.Processor.QCon otherHook = a_with.JoinHook();
if (myHook == otherHook)
{
// You might like to check out, what happens, if you
// remove this line. It seems to open a bug in an
// StOr testcase.
return myHook;
}
QConJoin cj = new QConJoin(i_trans, myHook, otherHook, a_and);
myHook.AddJoin(cj);
otherHook.AddJoin(cj);
return cj;
}
public virtual IStoredField[] GetStoredFields()
{
lock (Lock())
{
if (_aspects == null)
{
return new IStoredField[0];
}
var storedFields = new Collection4();
TraverseDeclaredFields(new _IProcedure4_1039(storedFields));
var fields = new IStoredField[storedFields.Size()];
storedFields.ToArray(fields);
return fields;
}
}
public virtual IReflectClass[] Collect()
{
Collection4 classes = new Collection4();
CollectKnownClasses(classes);
return (IReflectClass[])classes.ToArray(new IReflectClass[classes.Size()]);
}
private StaticField[] ToStaticFieldArray(Collection4 fields)
{
return (StaticField[]) fields.ToArray(new StaticField[fields.Size()]);
}
// Simple
// Collection
// Complex
// General
//regression
protected virtual Type[] Concat(Type[] x, Type[] y)
{
Collection4 c = new Collection4(x);
c.AddAll(y);
return (Type[])c.ToArray(new Type[c.Size()]);
}
private bool HasIncompatibleTranslatorAspect(Collection4 aspects)
{
bool translatorFound = false;
bool enabledAspectFound = false;
int size = aspects.Size();
IAspectVersionContext context = AspectVersionContextImpl.ForSize(size);
for (int i = 0; i < size; i++)
{
ClassAspect current = (ClassAspect)aspects.Get(i);
if (!current.IsEnabledOn(context))
{
continue;
}
if (current.IsVirtual())
{
continue;
}
if (current.AspectType() == AspectType.Translator)
{
translatorFound = true;
}
else
{
enabledAspectFound = true;
}
}
return enabledAspectFound && translatorFound;
}
