public void QueryStringUsingQxContains_MatchInStartOfStringExists_ItemIsReturned()
        {
            var item = new QxItemForQueries { StringValue = "ABC" };
            using (var uow = Database.CreateUnitOfWork())
            {
                uow.Insert(item);
                uow.Commit();
            }

            QxItemForQueries refetched;
            using (var uow = Database.CreateUnitOfWork())
            {
                refetched = uow.Query<QxItemForQueries>(i => i.StringValue.QxContains("A")).SingleOrDefault();
            }

            Assert.AreEqual("ABC", refetched.StringValue);
        }
        public void QueryStringUsingQxContains_NoMatch_NullIsReturned()
        {
            var item = new QxItemForQueries { StringValue = "ABC" };
            using (var uow = Database.CreateUnitOfWork())
            {
                uow.Insert(item);
                uow.Commit();
            }

            QxItemForQueries refetched;
            using (var uow = Database.CreateUnitOfWork())
            {
                refetched = uow.Query<QxItemForQueries>(i => i.StringValue.QxContains("D")).SingleOrDefault();
            }

            Assert.IsNull(refetched);
        }
        public void QueryStringUsingQxEndsWith_CompleteMatch_ItemIsReturned()
        {
            var item = new QxItemForQueries { StringValue = "ABC" };
            using (var uow = Database.CreateUnitOfWork())
            {
                uow.Insert(item);
                uow.Commit();
            }

            QxItemForQueries refetched;
            using (var uow = Database.CreateUnitOfWork())
            {
                refetched = uow.Query<QxItemForQueries>(i => i.StringValue.QxEndsWith("ABC")).SingleOrDefault();
            }

            Assert.AreEqual("ABC", refetched.StringValue);
        }
        public void QueryDecimalListUsingQxAny_MatchingFirstElementInList_ItemIsReturned()
        {
            var item = new QxItemForQueries { DecimalList = new List<decimal> { -1.12M, 0.13M, 3.14M } };
            using (var uow = Database.CreateUnitOfWork())
            {
                uow.Insert(item);
                uow.Commit();
            }

            QxItemForQueries refetched;
            using (var uow = Database.CreateUnitOfWork())
            {
                refetched = uow.Query<QxItemForQueries>(i => i.DecimalList.QxAny(e => e == 0.13M)).SingleOrDefault();
            }

            CollectionAssert.AreEqual(item.DecimalList, refetched.DecimalList);
        }
        public void QueryChildItemListUsingQxAny_SecondCriteriaMatchesMiddleElementInList_ItemIsReturned()
        {
            var item = new QxItemForQueries
            {
                ChildItemList = new List<ChildItem>
                {
                    new ChildItem { Int = -42 }, new ChildItem { Int = 42 }, new ChildItem { Int = 99 }
                }
            };
            using (var uow = Database.CreateUnitOfWork())
            {
                uow.Insert(item);
                uow.Commit();
            }

            QxItemForQueries refetched;
            using (var uow = Database.CreateUnitOfWork())
            {
                refetched = uow.Query<QxItemForQueries>(i => i.ChildItemList.QxAny(e => e.Int == 0 || e.Int == 42)).SingleOrDefault();
            }

            CustomAssert.AreEqual(item.ChildItemList, refetched.ChildItemList, (x, y) => x.Int.Equals(y.Int));
        }
        public void QueryStringListUsingQxAny_SecondCriteriaMatchesMiddleElementInList_ItemIsReturned()
        {
            var item = new QxItemForQueries { StringList = new List<string> { "Alpha", "Bravo", "Charlie" } };
            using (var uow = Database.CreateUnitOfWork())
            {
                uow.Insert(item);
                uow.Commit();
            }

            QxItemForQueries refetched;
            using (var uow = Database.CreateUnitOfWork())
            {
                refetched = uow.Query<QxItemForQueries>(i => i.StringList.QxAny(e => e == "Temp" || e == "Bravo")).SingleOrDefault();
            }

            CollectionAssert.AreEqual(item.StringList, refetched.StringList);
        }
        public void QueryStringArrayUsingQxAny_MatchingFirstElementInArray_ItemIsReturned()
        {
            var item = new QxItemForQueries { Strings = new[] { "Alpha", "Bravo", "Charlie" } };
            using (var uow = Database.CreateUnitOfWork())
            {
                uow.Insert(item);
                uow.Commit();
            }

            QxItemForQueries refetched;
            using (var uow = Database.CreateUnitOfWork())
            {
                refetched = uow.Query<QxItemForQueries>(i => i.Strings.QxAny(e => e == "Alpha")).SingleOrDefault();
            }

            CollectionAssert.AreEqual(item.Strings, refetched.Strings);
        }
        public void QueryListOnChildItemListUsingQxAny_MatchingPropOfFirstElementInList_ItemIsReturned()
        {
            var item = new QxItemForQueries
            {
                ChildItemList = new List<ChildItem> {
                    new ChildItem { IntegerList = new List<int>{-1, 1, 2}},
                }
            };
            using (var uow = Database.CreateUnitOfWork())
            {
                uow.Insert(item);
                uow.Commit();
            }

            QxItemForQueries refetched;
            using (var uow = Database.CreateUnitOfWork())
            {
                refetched = uow.Query<QxItemForQueries>(i => i.ChildItemList.QxAny(e => e.IntegerList.QxAny(e2 => e2 == -1))).SingleOrDefault();
            }

            CustomAssert.AreEqual(item.ChildItemList, refetched.ChildItemList, (x, y) => x.Int.Equals(y.Int));
        }
        public void QueryIntArrayUsingQxAny_SecondCriteriaMatchesMiddleElementInArray_ItemIsReturned()
        {
            var item = new QxItemForQueries { Integers = new[] { 1, 2, 3 } };
            using (var uow = Database.CreateUnitOfWork())
            {
                uow.Insert(item);
                uow.Commit();
            }

            QxItemForQueries refetched;
            using (var uow = Database.CreateUnitOfWork())
            {
                refetched = uow.Query<QxItemForQueries>(i => i.Integers.QxAny(e => e == -1 || e == 2)).SingleOrDefault();
            }

            CollectionAssert.AreEqual(item.Integers, refetched.Integers);
        }