private Collection4 CommitCapturingUpdatedObjects(IExtObjectContainer container) { var updated = new Collection4(); EventRegistryFor(container).Updated += new _IEventListener4_51(updated).OnEvent; container.Commit(); return updated; }
public _IRunnable_23(DynamicVariableTestCase _enclosing, DynamicVariable variable , Collection4 failures) { this._enclosing = _enclosing; this.variable = variable; this.failures = failures; }
public virtual void TestContainsAll() { var a = new Item(42); var b = new Item(a.id + 1); var c = new Item(b.id + 1); var a_ = new Item(a.id); var needle = new Collection4(); var haystack = new Collection4(); haystack.Add(a); needle.Add(a); needle.Add(b); Assert.IsFalse(haystack.ContainsAll(needle)); needle.Remove(b); Assert.IsTrue(haystack.ContainsAll(needle)); needle.Add(b); haystack.Add(b); Assert.IsTrue(haystack.ContainsAll(needle)); needle.Add(a_); Assert.IsTrue(haystack.ContainsAll(needle)); needle.Add(c); Assert.IsFalse(haystack.ContainsAll(needle)); needle.Clear(); Assert.IsTrue(haystack.ContainsAll(needle)); haystack.Clear(); Assert.IsTrue(haystack.ContainsAll(needle)); }
internal virtual void Process(ClassMetadata newClassMetadata) { if (_pending.Contains(newClassMetadata)) { return; } ClassMetadata ancestor = newClassMetadata.GetAncestor(); if (ancestor != null) { Process(ancestor); } _pending.Add(newClassMetadata); _members.Add(newClassMetadata); if (_running) { return; } _running = true; try { CheckInits(); _pending = new Collection4(); } finally { _running = false; } }
public virtual void Test() { Collection4 expected = new Collection4(new object[] { "PING", true, 42 }); MessagingTestCaseBase.MessageCollector recipient = new MessagingTestCaseBase.MessageCollector (); IObjectServer server = OpenServerWith(recipient); try { IObjectContainer client = OpenClient("client", server); try { IMessageSender sender = MessageSender(client); SendAll(expected, sender); } finally { client.Close(); } } finally { server.Close(); } Assert.AreEqual(expected.ToString(), recipient.messages.ToString()); }
public virtual void AddListener(IDiagnosticListener listener) { if (_listeners == null) { _listeners = new Collection4(); } _listeners.Add(listener); }
internal virtual void CacheDirty(Collection4 col) { if (!BitIsTrue(Const4.CachedDirty)) { BitTrue(Const4.CachedDirty); col.Add(this); } }
private void CollectKnownClasses(Collection4 collector, IEnumerator knownClasses) { while (knownClasses.MoveNext()) { IReflectClass clazz = (IReflectClass)knownClasses.Current; CollectKnownClass(collector, clazz); } }
public virtual void TestMultiThread() { DynamicVariable variable = new DynamicVariable(); Collection4 failures = new Collection4(); variable.With("mine", new _IRunnable_23(this, variable, failures)); Assert.IsNull(variable.Value); Assert.IsTrue(failures.IsEmpty(), failures.ToString()); }
private Collection4 CommitCapturingUpdatedObjects(IExtObjectContainer container) { Collection4 updated = new Collection4(); EventRegistryFor(container).Updated += new System.EventHandler<Db4objects.Db4o.Events.ObjectInfoEventArgs> (new _IEventListener4_51(updated).OnEvent); container.Commit(); return updated; }
public ExcludingReflector(Type[] excludedClasses) { _excludedClasses = new Collection4(); for (var claxxIndex = 0; claxxIndex < excludedClasses.Length; ++claxxIndex) { var claxx = excludedClasses[claxxIndex]; _excludedClasses.Add(claxx.FullName); } }
public virtual void TestFieldTraversal() { Collection4 expectedNames = new Collection4(new ArrayIterator4(new string[] { "_id" , "_name", "_age" })); ClassMetadata classMetadata = ClassMetadataFor(typeof(ClassMetadataIntegrationTestCase.SubClazz )); classMetadata.TraverseAllAspects(new _TraverseFieldCommand_31(expectedNames)); Assert.IsTrue(expectedNames.IsEmpty()); }
public ExcludingReflector(ByRef loaderClass, Type[] excludedClasses) { _excludedClasses = new Collection4(); for (int claxxIndex = 0; claxxIndex < excludedClasses.Length; ++claxxIndex) { Type claxx = excludedClasses[claxxIndex]; _excludedClasses.Add(claxx.FullName); } }
private Collection4 Range(int end) { var range = new Collection4(); for (var i = 0; i < end; ++i) { range.Add(i); } return range; }
public virtual void Run() { dontRemove = true; Collection4 copy = new Collection4(_containers); IEnumerator i = copy.GetEnumerator(); while (i.MoveNext()) { ((ObjectContainerBase)i.Current).ShutdownHook(); } }
private Thread[] CreateThreads(DynamicVariable variable, Collection4 failures) { Thread[] threads = new Thread[5]; for (int i = 0; i < threads.Length; i++) { threads[i] = new Thread(new _IRunnable_56(this, variable, failures), "DynamicVariableTestCase.checkVariableBehavior Thread[" + i + "]"); } return threads; }
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()); }
public virtual void TraverseMutable(IVisitor4 visitor) { Collection4 currentContent = new Collection4(); TraverseLocked(new _IVisitor4_51(currentContent)); IEnumerator i = currentContent.GetEnumerator(); while (i.MoveNext()) { visitor.Visit(i.Current); } }
private IEnumerator Ids(IEnumerable<PartialCollectionReplicationTestCase.Data> data ) { Collection4 ids = new Collection4(); foreach (PartialCollectionReplicationTestCase.Data d in data) { ids.Add(d.Id()); } return ids.GetEnumerator(); }
private Collection4 Copy(IEnumerable subject) { Collection4 result = new Collection4(); IEnumerator it = subject.GetEnumerator(); while (it.MoveNext()) { result.Add(it.Current); } return result; }
public virtual void TestSeries() { Collection4 calls = new Collection4(); IEnumerator series = Iterators.Series(string.Empty, new _IFunction4_11(calls)).GetEnumerator (); Assert.IsTrue(series.MoveNext()); Assert.IsTrue(series.MoveNext()); Iterator4Assert.AreEqual(new object[] { string.Empty, "*" }, calls.GetEnumerator( )); }
private IEnumerator CollectChildIdsFor(int id) { Collection4 references = ((Collection4)referenceCache[id]); if (null == references) { references = new Collection4(_referenceCollector.ReferencesFrom(id)); referenceCache[id] = references; } return references.GetEnumerator(); }
private CompositeIterator4 NewIterator() { Collection4 iterators = new Collection4(); iterators.Add(IntArrays4.NewIterator(new int[] { 1, 2, 3 })); iterators.Add(IntArrays4.NewIterator(new int[] { })); iterators.Add(IntArrays4.NewIterator(new int[] { 4 })); iterators.Add(IntArrays4.NewIterator(new int[] { 5, 6 })); CompositeIterator4 iterator = new CompositeIterator4(iterators.GetEnumerator()); return iterator; }
public virtual void TestContains() { object a = new object(); Collection4 c = new Collection4(); c.Add(new object()); Assert.IsFalse(c.Contains(a)); c.Add(a); Assert.IsTrue(c.Contains(a)); c.Remove(a); Assert.IsFalse(c.Contains(a)); }
protected override void Free(IFreespaceManager freespaceManager, Slot slot) { if (slot.IsNull()) { return; } if (_freed == null) { _freed = new Collection4(); } _freed.Add(slot); }
private void CollectKnownClasses(Collection4 classes) { IListener4 collectingListener = NewCollectingClassListener(classes); _repository.AddListener(collectingListener); try { CollectKnownClasses(classes, Iterators.Copy(_repository.Classes())); } finally { _repository.RemoveListener(collectingListener); } }
public virtual void TestReplace() { var c = new Collection4(); c.Replace("one", "two"); c.Add("one"); c.Add("two"); c.Add("three"); c.Replace("two", "two.half"); AssertCollection(new[] {"one", "two.half", "three"}, c); c.Replace("two.half", "one"); c.Replace("one", "half"); AssertCollection(new[] {"half", "one", "three"}, c); }
public virtual IEnumerator IteratorFor(object collection) { IDictionary map = (IDictionary)collection; Collection4 result = new Collection4(); IEnumerator it = map.GetEnumerator(); while (it.MoveNext()) { DictionaryEntry entry = (DictionaryEntry)it.Current; result.Add(entry.Key); result.Add(entry.Value); } return result.GetEnumerator(); }
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 static void SameContent(IEnumerator expected, IEnumerator actual) { var allExpected = new Collection4(expected); while (actual.MoveNext()) { var current = actual.Current; var removed = allExpected.Remove(current); if (!removed) { Unexpected(current); } } Assert.IsTrue(allExpected.IsEmpty(), "Still missing: " + allExpected); }
public virtual object DeepClone(object newParent) { Db4objects.Db4o.Foundation.Collection4 col = new Db4objects.Db4o.Foundation.Collection4 (); object element = null; IEnumerator i = InternalIterator(); while (i.MoveNext()) { element = i.Current; if (element is IDeepClone) { col.Add(((IDeepClone)element).DeepClone(newParent)); } else { col.Add(element); } } return(col); }
public static object[] ToArray(IEnumerator tests, IArrayFactory factory) { Collection4 elements = new Collection4(tests); return(elements.ToArray(factory.NewArray(elements.Size()))); }
public _IClosure4_54(BlockingQueue _enclosing, Collection4 target) { this._enclosing = _enclosing; this.target = target; }
public virtual int DrainTo(Collection4 target) { return(((int)_lock.Run(new _IClosure4_54(this, target)))); }
public virtual int DrainTo(Collection4 list) { return(queue.DrainTo(list)); }