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; }