public void TestConcatWithLazyEnumerable()
        {
            var ids      = new List <int>();
            var elements = new List <Element>();
            var result   = new DummyEnumerable(e => elements.Add(e), id => ids.Add(id), 0, 2)
                           .Concat(new DummyEnumerable(e => elements.Add(e), id => ids.Add(id), 2, 2))
                           .ToArray();

            Assert.AreEqual(4, elements.Count);
            Assert.AreEqual(0, elements[0].ID);
            Assert.AreEqual(1, elements[1].ID);
            Assert.AreEqual(2, elements[2].ID);
            Assert.AreEqual(3, elements[3].ID);

            Assert.AreEqual(4, ids.Count);
            Assert.AreEqual(0, ids[0]);
            Assert.AreEqual(1, ids[1]);
            Assert.AreEqual(2, ids[2]);
            Assert.AreEqual(3, ids[3]);

            Assert.AreEqual(4, result.Length);
            Assert.AreEqual(0, result[0].ID);
            Assert.AreEqual(1, result[1].ID);
            Assert.AreEqual(2, result[2].ID);
            Assert.AreEqual(3, result[3].ID);
        }
        public void TestCount()
        {
            var ids      = new List <int>();
            var elements = new List <Element>();
            var result   = new DummyEnumerable(e => elements.Add(e), id => ids.Add(id), 0, 4)
                           .Count();

            Assert.AreEqual(0, elements.Count);
            Assert.AreEqual(0, ids.Count);
            Assert.AreEqual(4, result);
        }
        public void TestSequenceEquals()
        {
            var ids      = new List <int>();
            var elements = new List <Element>();
            var result   = new DummyEnumerable(e => elements.Add(e), id => ids.Add(id), 0, 2)
                           .SequenceEqual(new DummyEnumerable(e => elements.Add(e), id => ids.Add(id), 0, 2));

            Assert.AreEqual(0, elements.Count);
            Assert.AreEqual(4, ids.Count);
            Assert.IsTrue(result);
        }
        public void TestCountAfterConcatWithArray()
        {
            var ids      = new List <int>();
            var elements = new List <Element>();
            var result   = new DummyEnumerable(e => elements.Add(e), id => ids.Add(id), 0, 2)
                           .Concat(new[] { new Element(3), new Element(4) })
                           .Count();

            Assert.AreEqual(2, elements.Count);
            Assert.AreEqual(2, ids.Count);
            Assert.AreEqual(4, result);
        }
        public void TestCountAfterConcatWithTwoLazyEnumerables()
        {
            var ids      = new List <int>();
            var elements = new List <Element>();
            var result   = new DummyEnumerable(e => elements.Add(e), id => ids.Add(id), 0, 2)
                           .Concat(new DummyEnumerable(e => elements.Add(e), id => ids.Add(id), 2, 2))
                           .Concat(new DummyEnumerable(e => elements.Add(e), id => ids.Add(id), 4, 2))
                           .Count();

            Assert.AreEqual(0, elements.Count);
            Assert.AreEqual(0, ids.Count);
            Assert.AreEqual(6, result);
        }
        public void TestLastAfterConcat()
        {
            var ids      = new List <int>();
            var elements = new List <Element>();
            var result   = new DummyEnumerable(e => elements.Add(e), id => ids.Add(id), 0, 2)
                           .Concat(new DummyEnumerable(e => elements.Add(e), id => ids.Add(id), 2, 2))
                           .Last();

            Assert.AreEqual(1, elements.Count);
            Assert.AreEqual(3, elements[0].ID);
            Assert.AreEqual(1, ids.Count);

            Assert.AreEqual(3, result.ID);
        }
        public void TestSkip()
        {
            var ids      = new List <int>();
            var elements = new List <Element>();
            var result   = new DummyEnumerable(e => elements.Add(e), id => ids.Add(id), 0, 4)
                           .Skip(2)
                           .ToArray();

            Assert.AreEqual(2, elements.Count);
            Assert.AreEqual(2, ids.Count);

            Assert.AreEqual(2, result.Length);
            Assert.AreEqual(2, result[0].ID);
            Assert.AreEqual(3, result[1].ID);
        }
        public void TestOfType()
        {
            var ids      = new List <int>();
            var elements = new List <Element>();
            var result   = new DummyEnumerable(e => elements.Add(e), id => ids.Add(id), 0, 3, new Element(0),
                                               new DerivedElement(1),
                                               new Element(2))
                           .OfType <DerivedElement>()
                           .ToArray();

            Assert.AreEqual(1, elements.Count);
            Assert.AreEqual(1, elements[0].ID);
            Assert.AreEqual(3, ids.Count);

            Assert.AreEqual(1, result.Length);
            Assert.AreEqual(1, result[0].ID);
        }
Esempio n. 9
0
        public void TestEQUALS()
        {
            var temp    = new DummyEnumerable();
            var dummies = temp.Dummies.AsQueryable();

            var tfilter = new TableFilterBuilder()
            {
                Field    = "Id",
                Operator = "EQUALS",
                Value    = "1"
            };

            var expected = dummies.ElementAt(0);

            var actual = tfilter.FilterWithCondition(dummies).First();

            Assert.AreEqual(expected, actual);
        }
Esempio n. 10
0
        public void TestNOT_EQUALS()
        {
            var temp    = new DummyEnumerable();
            var dummies = temp.Dummies.AsQueryable();

            // Daniele
            var tfilter = new TableFilterBuilder()
            {
                Field    = "Id",
                Operator = "NOT_EQUALS",
                Value    = "1"
            };

            var expected = dummies.Where(w => w.Id != 1);

            var actual = tfilter.FilterWithCondition(dummies);

            Assert.AreEqual(expected.First(), actual.First());
        }