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);
        }
Example #2
0
        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());
     });
 }
Example #5
0
            public void Test()
            {
                IDictionary actual = RetrieveOnlyInstance <Item>().dictionary;

                Iterator4Assert.AreEqual(Subject().Values, actual.Values);
                Iterator4Assert.AreEqual(Subject().Keys, actual.Keys);
            }
Example #6
0
        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()
                              );
 }
Example #8
0
        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()));
 }
Example #11
0
        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());
        }
Example #15
0
        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);
     });
 }
Example #18
0
 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);
        }
Example #22
0
        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());
        }
Example #23
0
        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));
        }
Example #28
0
        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());
        }
Example #30
0
        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
                                            ());
        }