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