public virtual void TestToString()
{
Collection4 c = new Collection4();
Assert.AreEqual("[]", c.ToString());
c.Add("foo");
Assert.AreEqual("[foo]", c.ToString());
c.Add("bar");
Assert.AreEqual("[foo, bar]", c.ToString());
}
private void AssertUpdatedObjects(IExtObjectContainer container, Item expected)
{
Collection4 updated = CommitCapturingUpdatedObjects(container);
Assert.AreEqual(1, updated.Size(), updated.ToString());
Assert.AreSame(expected, updated.SingleElement());
}
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 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());
}
public virtual void AssertExpectations()
{
if (_unexpected.Size() > 0)
{
Assert.Fail("UNEXPECTED: " + _unexpected.ToString());
}
for (int i = 0; i < _expected.Length; i++)
{
Assert.AreSame(Found, _expected[i]);
}
}
private void AssertAllItems(IEnumerator result)
{
Collection4 expected = Range(ItemCount);
for (int i = 0; i < ItemCount; ++i)
{
ConcurrentLazyQueriesTestCase.Item nextItem = (ConcurrentLazyQueriesTestCase.Item
)IteratorPlatform.Next(result);
expected.Remove(nextItem.id);
}
Assert.AreEqual("[]", expected.ToString());
}
private void AssertIterator(Hashtable4 table, object[] keys)
{
IEnumerator iter = table.Iterator();
Collection4 expected = new Collection4(keys);
while (iter.MoveNext())
{
IEntry4 entry = (IEntry4)iter.Current;
bool removedOK = expected.Remove(entry.Key());
Assert.IsTrue(removedOK);
}
Assert.IsTrue(expected.IsEmpty(), expected.ToString());
}
public static void SameContent(IEnumerator expected, IEnumerator actual)
{
Collection4 allExpected = new Collection4(expected);
while (actual.MoveNext())
{
object current = actual.Current;
bool removed = allExpected.Remove(current);
if (!removed)
{
Unexpected(current);
}
}
Assert.IsTrue(allExpected.IsEmpty(), "Still missing: " + allExpected.ToString());
}
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());
}
public static void SameContent(IEnumerator expected, IEnumerator actual)
{
var allExpected = new Collection4();
while (expected.MoveNext())
{
allExpected.Add(expected.Current);
}
while (actual.MoveNext())
{
var current = actual.Current;
var removed = allExpected.Remove(current);
if (!removed)
{
Unexpected(current);
}
}
Assert.IsTrue(allExpected.IsEmpty(), allExpected.ToString());
}
