private void AssertQBEQuery(Person[] expected, Person template)
{
ReconnectAndRun(delegate
{
Iterator4Assert.SameContent(expected, _client.QueryByExample(template).GetEnumerator());
});
}
public static void AssertSet <T>(IEnumerable <T> expected, IEnumerable <T> actual)
{
var message = string.Format("Expected {0}, got {1}", Iterators.ToString(expected), Iterators.ToString(actual));
Assert.AreEqual(expected.Count(), actual.Count(), message);
Iterator4Assert.SameContent(expected.GetEnumerator(), actual.GetEnumerator());
}
private void AssertCanRetrieveAll()
{
IQuery query = NewQuery(typeof(ValueTypeHolder));
IObjectSet result = query.Execute();
ValueTypeHolder[] expected = ObjectsToStore();
Iterator4Assert.SameContent(Flatten(expected).GetEnumerator(), result.GetEnumerator());
}
protected void AssertQueryFromJavaClient()
{
Iterator4Assert.SameContent(
Array.FindAll(
Persons,
delegate(Person candidate) { return(candidate.Name.StartsWith(WOODY_NAME)); }),
ParseJavaClientResults(RunJavaQuery("query-person", WOODY_NAME)));
}
private void AssertCanRetrieveAll()
{
IQuery query = NewQuery(typeof(Item));
IObjectSet result = query.Execute();
Assert.AreEqual(_items.Length, result.Count);
Iterator4Assert.SameContent(result.GetEnumerator(), _items.GetEnumerator());
}
private void AssertNativeQuery(Person[] expected, Predicate <Person> predicate)
{
ReconnectAndRun(
delegate
{
Iterator4Assert.SameContent(expected, _client.Query(predicate).GetEnumerator());
Assert.IsTrue(_queryStatus.Optimized);
});
}
private void AssertSodaQuery(Person[] expected, string name)
{
ReconnectAndRun(
delegate
{
ICollection actual = SodaQueryByName(name);
Assert.AreEqual(expected.Length, actual.Count);
Iterator4Assert.SameContent(expected, actual.GetEnumerator());
});
}
public virtual void TestIterable()
{
CacheTestUnit.TestPuppet puppet = new CacheTestUnit.TestPuppet();
Iterator4Assert.SameContent(new object[] { }, puppet.Values());
puppet.Produce(0);
Iterator4Assert.SameContent(new object[] { "0" }, puppet.Values());
puppet.FillCache();
Iterator4Assert.SameContent(new object[] { "0", "1", "2", "3", "4", "5", "6", "7"
, "8", "9" }, puppet.Values());
}
public virtual void TestDescQuery()
{
IQuery query = NewQuery(typeof(DescQueryTestCase.Item));
IQuery sq = query.Descend("_child");
query.Descend("_id").Constrain(42).And(sq.Descend("_id").Constrain(43).Greater());
IObjectSet result = sq.Execute();
Iterator4Assert.SameContent(Iterators.Iterate(new DescQueryTestCase.Item[] { new
DescQueryTestCase.Item(44) }), Iterators.Iterator(result));
}
public virtual void TestIterator()
{
IdentitySet4 set = new IdentitySet4();
object o1 = new object();
object o2 = new object();
set.Add(o1);
set.Add(o2);
Iterator4Assert.SameContent(Iterators.Iterate(new object[] { o1, o2 }), set.GetEnumerator
());
}
private void AssertSodaEvaluation(Person[] expected, string name)
{
ReconnectAndRun(
delegate
{
IQuery query = _client.Query();
query.Constrain(typeof(Person));
query.Constrain(new PersonEvaluator(name));
Iterator4Assert.SameContent(expected, query.Execute().GetEnumerator());
});
}
public virtual void TestValuesIterator()
{
object[] values = new object[5];
for (int i = 0; i < values.Length; ++i)
{
values[i] = ("value" + i);
}
for (int vIndex = 0; vIndex < values.Length; ++vIndex)
{
object v = values[vIndex];
subject.Put("key4" + v, v);
}
Iterator4Assert.SameContent(values, subject.Values().GetEnumerator());
}
public virtual void Test()
{
ItemDates item1 = new ItemDates(new DateTime(0), new DateTime());
ItemDates item2 = new ItemDates(new DateTime(10000), new DateTime(Runtime.CurrentTimeMillis
() - 10000));
A().Provider().StoreNew(item1);
A().Provider().StoreNew(item2);
A().Provider().Commit();
ReplicateAll(A().Provider(), B().Provider());
IObjectSet found = B().Provider().GetStoredObjects(typeof(ItemDates));
Iterator4Assert.SameContent(new object[] { item2, item1 }, ReplicationTestPlatform
.Adapt(found.GetEnumerator()));
}
public virtual void TestManyKeys()
{
for (int keyCount = 50; keyCount < 70; keyCount++)
{
_btree = NewBTree();
IEnumerable keys = RandomPositiveIntegersWithoutDuplicates(keyCount);
IEnumerator keyIterator = keys.GetEnumerator();
while (keyIterator.MoveNext())
{
int currentKey = (int)keyIterator.Current;
_btree.Add(Trans(), currentKey);
}
Iterator4Assert.SameContent(keys.GetEnumerator(), _btree.Iterator(Trans()));
}
}
public virtual void TestMultipleAddRemove()
{
object[] objs = new object[] { new object(), new object(), new object() };
for (int objIndex = 0; objIndex < objs.Length; ++objIndex)
{
object obj = objs[objIndex];
_set.Add(obj);
}
Assert.IsFalse(_set.IsEmpty());
Assert.AreEqual(objs.Length, _set.Size());
for (int objIndex = 0; objIndex < objs.Length; ++objIndex)
{
object obj = objs[objIndex];
Assert.IsTrue(_set.Contains(obj));
}
Assert.IsFalse(_set.Contains(new object()));
Iterator4Assert.SameContent(objs, _set.GetEnumerator());
}
public virtual void TestMultipleEntries()
{
IdentityHashtable4TestCase.Item key1 = new IdentityHashtable4TestCase.Item(Key);
IdentityHashtable4TestCase.Item key2 = new IdentityHashtable4TestCase.Item(Key +
1);
_map.Put(key1, Key);
_map.Put(key2, Key + 1);
Assert.IsTrue(_map.ContainsKey(key1));
Assert.IsTrue(_map.ContainsKey(key2));
Assert.IsFalse(_map.ContainsKey(new IdentityHashtable4TestCase.Item(Key)));
Assert.IsFalse(_map.ContainsKey(new IdentityHashtable4TestCase.Item(Key + 1)));
Assert.AreEqual(Key, _map.Get(key1));
Assert.AreEqual(Key + 1, _map.Get(key2));
Assert.IsNull(_map.Get(new IdentityHashtable4TestCase.Item(Key)));
Assert.IsNull(_map.Get(new IdentityHashtable4TestCase.Item(Key + 1)));
Assert.AreEqual(2, _map.Size());
Iterator4Assert.SameContent(new object[] { Key, Key + 1 }, _map.Values().GetEnumerator
());
}
public static void SameContent(IObjectSet objectSet, object[] expectedItems)
{
Iterator4Assert.SameContent(Iterators.Iterate(expectedItems), Iterate(objectSet));
}
public void TestCollectionTypeHandlerDoesntThrows()
{
CollectionHolder holder = RetrieveOnlyInstance <CollectionHolder>();
Iterator4Assert.SameContent(new object[] { "foo", "bar" }, holder._collection.GetEnumerator());
}
// The following fails after cleaning references has been removed from #replicate(obj)
// assertData(updated, "c3", "root");
private void AssertData(IEnumerable <PartialCollectionReplicationTestCase.Data> data
, params string[] expectedIds)
{
Iterator4Assert.SameContent(expectedIds, Ids(data));
}
public virtual void VerifyUnordered(MethodCall[] expectedCalls)
{
Iterator4Assert.SameContent(expectedCalls, GetEnumerator());
}
private static void Expect(IList list, string[] names)
{
names = names ?? new string[0];
Iterator4Assert.SameContent(names, CatNamesFrom(list).GetEnumerator());
}
private void AssertCollectedIds(CollectIdContext context, object[] expectedReferences
)
{
Iterator4Assert.SameContent(Iterators.Map(expectedReferences, new _IFunction4_66(
this)), new TreeKeyIterator(context.Ids()));
}