private void AssertItem <T>(IObjectContainer container, object objExpected, object objActual, T updateValue)
{
Item <T> expected = (Item <T>)objExpected;
Item <T> actual = (Item <T>)objActual;
Assert.AreEqual(expected.name, actual.name);
Iterator4Assert.AreEqual(
EnumeratorFor(expected.typed),
EnumeratorFor(actual.typed));
Iterator4Assert.AreEqual(
EnumeratorFor(expected.typedInterface),
EnumeratorFor(actual.typedInterface));
Iterator4Assert.AreEqual(
EnumeratorFor(expected.untyped),
EnumeratorFor(actual.untyped));
Iterator4Assert.AreEqual(
EnumeratorFor(expected.untypedEnumerable),
EnumeratorFor(actual.untypedEnumerable));
AssertQuery(container, actual);
}
private void CheckArbitraryValuesOf(Type expectedType)
{
IEnumerable values = Generators.ArbitraryValuesOf(expectedType);
Assert.IsTrue(values.GetEnumerator().MoveNext());
Iterator4Assert.AreInstanceOf(expectedType, values);
}
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 AssertQBEQuery(Person[] expected, Person template)
{
ReconnectAndRun(delegate
{
Iterator4Assert.SameContent(expected, _client.QueryByExample(template).GetEnumerator());
});
}
public void Test()
{
IDictionary actual = RetrieveOnlyInstance <Item>().dictionary;
Iterator4Assert.AreEqual(Subject().Values, actual.Values);
Iterator4Assert.AreEqual(Subject().Keys, actual.Keys);
}
public virtual void TestIterator()
{
string[] expected = new string[] { "1", "2", "3" };
Collection4 c = NewCollection(expected);
Iterator4Assert.AreEqual(expected, c.GetEnumerator());
}
public virtual void TestDuplicateEntry()
{
_map.Put(new IdentityHashtable4TestCase.Item(Key), Key);
_map.Put(new IdentityHashtable4TestCase.Item(Key), Key);
Iterator4Assert.AreEqual(new object[] { Key, Key }, _map.Values().GetEnumerator()
);
}
public void test()
{
Item item = (Item)RetrieveOnlyInstance(typeof(Item));
Assert.IsNotNull(item.nullableList);
Iterator4Assert.AreEqual(nullableIntList1().GetEnumerator(), item.nullableList.GetEnumerator());
}
private void AssertCanRetrieveAll()
{
IQuery query = NewQuery(typeof(ValueTypeHolder));
IObjectSet result = query.Execute();
ValueTypeHolder[] expected = ObjectsToStore();
Iterator4Assert.SameContent(Flatten(expected).GetEnumerator(), result.GetEnumerator());
}
private void AssertConverterBehaviorForVersion(int converterVersion)
{
ConverterTestCase.RecordingStage stage = new ConverterTestCase.RecordingStage(converterVersion
);
Converter.Convert(stage);
Iterator4Assert.AreEqual(Iterators.Iterator(ExpectedConversionsFor(converterVersion
)), Iterators.Iterator(stage.Conversions()));
}
public virtual void TestFlatten()
{
IEnumerator iterator = Iterate(new object[] { "1", "2", Iterate(new object[] { Iterate
(new object[] { "3", "4" }), Iterators.EmptyIterator, Iterators.EmptyIterator, "5" }), Iterators.EmptyIterator, "6" });
Iterator4Assert.AreEqual(new object[] { "1", "2", "3", "4", "5", "6" }, Iterators
.Flatten(iterator));
}
protected void AssertQueryFromJavaClient()
{
Iterator4Assert.SameContent(
Array.FindAll(
Persons,
delegate(Person candidate) { return(candidate.Name.StartsWith(WOODY_NAME)); }),
ParseJavaClientResults(RunJavaQuery("query-person", WOODY_NAME)));
}
private static void AssertItemArray(IEnumerable[] expected, IEnumerable[] actual)
{
Assert.AreEqual(expected.Length, actual.Length);
for (int i = 0; i < expected.Length; i++)
{
Iterator4Assert.AreEqual(expected[i].GetEnumerator(), actual[i].GetEnumerator());
}
}
public override void EnsureContent(ITestableReplicationProviderInside provider)
{
Container replicated = (Container)QueryItem(provider, typeof(Container));
Container expected = (Container)CreateItem();
Assert.AreNotSame(expected, replicated);
Assert.AreEqual(expected._name, replicated._name);
Iterator4Assert.AreEqual(expected._items.GetEnumerator(), replicated._items.GetEnumerator());
}
private void AssertPath(object t, object expression, string[] expected)
{
var path = _prototypes.BackingFieldPath(t.GetType(), expression
);
// print(Iterators.join(path, "[", "]", ", "));
path.Reset();
Iterator4Assert.AreEqual(expected, path);
}
private void AssertSingleEntry(IdentityHashtable4TestCase.Item key, int value)
{
Assert.IsTrue(_map.ContainsKey(key));
Assert.IsFalse(_map.ContainsKey(new IdentityHashtable4TestCase.Item(value)));
Assert.AreEqual(value, _map.Get(key));
Assert.IsNull(_map.Get(new IdentityHashtable4TestCase.Item(value)));
Assert.AreEqual(1, _map.Size());
Iterator4Assert.AreEqual(new object[] { value }, _map.Values().GetEnumerator());
}
private void AssertNativeQuery(Person[] expected, Predicate <Person> predicate)
{
ReconnectAndRun(
delegate
{
Iterator4Assert.SameContent(expected, _client.Query(predicate).GetEnumerator());
Assert.IsTrue(_queryStatus.Optimized);
});
}
public virtual void TestRange()
{
Iterator4Assert.AreEqual(new object[] {}, Iterators.Range(1, 1));
Iterator4Assert.AreEqual(new object[] { 1 }, Iterators.Range(1, 2));
Iterator4Assert.AreEqual(new object[] { 1, 2 }, Iterators.Range(1, 3));
Iterator4Assert.AreEqual(new object[] { -2, -1, 0, 1, 2 }, Iterators.Range(-2, 3)
);
Assert.Expect(typeof(ArgumentException), new _ICodeBlock_24());
}
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 AssertSort()
{
Person[] expectedOrder = (Person[])Persons.Clone();
Array.Sort(expectedOrder, Person.SortByYear);
Iterator4Assert.AreEqual(
expectedOrder,
_client.Query(Person.SortByYear).GetEnumerator());
}
public void TestProduceWithEqualityComparer()
{
var cache4 = CacheFactory.NewLRUCache(2);
var subject = CacheFactory <string, int> .For(cache4, StringComparer.CurrentCultureIgnoreCase);
Assert.AreEqual(42, subject.Produce("foo", key => 42));
Assert.AreEqual(42, subject.Produce("FOO", key => - 1));
Iterator4Assert.AreEqual(new object[] { 42 }, cache4);
}
public virtual void TestLabel()
{
FixtureBasedTestSuite suite = new _FixtureBasedTestSuite_142();
IEnumerable labels = Iterators.Map(suite, new _IFunction4_154());
Iterator4Assert.AreEqual(new object[] { TestLabel("testFoo", 0, 0), TestLabel("testFoo"
, 1, 0), TestLabel("testFoo", 0, 1), TestLabel("testFoo", 1, 1), TestLabel("testBar"
, 0, 0), TestLabel("testBar", 1, 0), TestLabel("testBar", 0, 1), TestLabel("testBar"
, 1, 1) }, labels.GetEnumerator());
}
public virtual void TestCrossProduct()
{
IEnumerable[] source = new IEnumerable[] { Iterable(new object[] { "1", "2" }), Iterable
(new object[] { "3", "4" }), Iterable(new object[] { "5", "6" }) };
string[] expected = new string[] { "[1, 3, 5]", "[1, 3, 6]", "[1, 4, 5]", "[1, 4, 6]"
, "[2, 3, 5]", "[2, 3, 6]", "[2, 4, 5]", "[2, 4, 6]" };
IEnumerator iterator = Iterators.CrossProduct(source).GetEnumerator();
Iterator4Assert.AreEqual(expected, Iterators.Map(iterator, new _IFunction4_75()));
}
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());
}
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 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));
}
private void AssertQuery(int[] expectedItemIds, SodaQueryComparator.Ordering[] orderings
)
{
long[] ids = NewQuery(typeof(SodaQueryComparatorTestCase.Item)).Execute().Ext().GetIDs
();
IList sorted = new SodaQueryComparator(FileSession(), typeof(SodaQueryComparatorTestCase.Item
), orderings).Sort(ids);
Iterator4Assert.AreEqual(Iterators.Map(expectedItemIds, oidByItemId), Iterators.Iterator
(sorted));
}
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 void AssertOrderBy(Comparison <object> comparison, Action <IQuery> setOrderBy)
{
_items.Sort(comparison);
IQuery query = NewQuery(ItemVariable().Type());
setOrderBy(query.Descend("_value"));
Iterator4Assert.AreEqual(
_items.ToArray(),
query.Execute().GetEnumerator());
}
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
());
}
