public void IgnoreEmptyInput()
        {
            var resultNull = DataSet.Build(
                _ => _.Where((x, input) => x.Name == input, string.Empty));

            resultNull.Should().BeEquivalentTo(DataSet);
        }
        public void IgnoreWhitespaceInput()
        {
            var resultNull = DataSet.Build(
                _ => _.Where((x, input) => x.Name == input, " "));

            resultNull.Should().BeEquivalentTo(DataSet);
        }
        public void IgnoreNullLongInput()
        {
            var resultNull = DataSet.Build(
                _ => _.Where((x, input) => x.ParentId == input, (long?)null));

            resultNull.Should().BeEquivalentTo(DataSet);
        }
Пример #4
0
        public void IgnoreWhitespaceInput()
        {
            var resultNull = DataSet.Build(
                _ => _.Equals(x => x.Name, " "));

            resultNull.Should().BeEquivalentTo(DataSet);
        }
        public void IgnoreEmptyEnumerableInput()
        {
            var resultNull = DataSet.Build(
                _ => _.Where((x, input) => input.Contains(x.Name), Array.Empty <string>()));

            resultNull.Should().BeEquivalentTo(DataSet);
        }
Пример #6
0
        public void NumberGt()
        {
            var result = DataSet.Build(
                _ => _.Not.Where(x => x.Id > 1));

            result.Should().BeEquivalentTo(DataSet.Where(x => x.Id <= 1));
        }
Пример #7
0
        public void IgnoreNullLongInput()
        {
            var resultNull = DataSet.Build(
                _ => _.Equals(x => x.ParentId, null));

            resultNull.Should().BeEquivalentTo(DataSet);
        }
Пример #8
0
        public void IgnoreEmptyInput()
        {
            var resultNull = DataSet.Build(
                _ => _.Equals(x => x.Name, string.Empty));

            resultNull.Should().BeEquivalentTo(DataSet);
        }
Пример #9
0
        public void StringEquals()
        {
            var result = DataSet.Build(
                _ => _.Not.Equals(x => x.Name, "aaAa1"));

            result.Should().BeEquivalentTo(DataSet.Where(x => x.Name.ToLower() != "aaaa1"));
        }
Пример #10
0
        public void Contains()
        {
            var result = DataSet.Build(
                _ => _.Not.Contains(x => x.Name, "b"));

            result.Should().BeEquivalentTo(DataSet.Where(x => !x.Name.ToLower().Contains("b")));
        }
Пример #11
0
        public void NonString()
        {
            var result = DataSet.Build(
                _ => _.Equals(x => x.ParentId, 1));

            result.Should().BeEquivalentTo(DataSet.Where(x => x.Id == 3));
        }
Пример #12
0
        public void IgnoreNullStringInput()
        {
            var resultNull = DataSet.Build(
                _ => _.In(x => x.Name, null));

            resultNull.Should().BeEquivalentTo(DataSet);
        }
        public void IgnoreNullStringInput()
        {
            var resultNull = DataSet.Build(
                _ => _.Where((x, input) => x.Name == input, (string)null));

            resultNull.Should().BeEquivalentTo(DataSet);
        }
Пример #14
0
        public void NonString()
        {
            var result = DataSet.Build(
                _ => _.In(x => x.ParentId, new long?[] { 1 }));

            result.Should().BeEquivalentTo(DataSet.Where(x => x.Id == 3));
        }
Пример #15
0
        public void IgnoreCase()
        {
            var result = DataSet.Build(
                _ => _.Equals(x => x.Name, "aAAa1"),
                BuilderOptions.IgnoreCase);

            result.Should().BeEquivalentTo(DataSet.Where(x => x.Id == 1));
        }
Пример #16
0
        public void CaseSensitiveEmpty()
        {
            var result = DataSet.Build(
                _ => _.Equals(x => x.Name, "aAAa1"),
                BuilderOptions.None);

            result.Should().BeEmpty();
        }
Пример #17
0
        public void UseDefaultNonStringInput()
        {
            var resultNull = DataSet.Build(
                _ => _.Equals(x => x.ParentId, null),
                BuilderOptions.None);

            resultNull.Should().BeEquivalentTo(DataSet.Where(x => x.Id == 1 || x.Id == 2));
        }
Пример #18
0
        public void CaseSensitive()
        {
            var result = DataSet.Build(
                _ => _.Equals(x => x.Name, "aaAa1"),
                BuilderOptions.None);

            result.Should().BeEquivalentTo(DataSet.Where(x => x.Id == 1));
        }
Пример #19
0
        public void UseDefaultOrEmptyOrWhitespaceInput()
        {
            var resultNull = DataSet.Build(
                _ => _.Equals(x => x.Name, null),
                BuilderOptions.None);

            resultNull.Should().BeEmpty();
        }
Пример #20
0
        public void IgnoreCase()
        {
            var result = DataSet.Build(
                _ => _.In(x => x.Name, new[] { "aaAa1", "baBa" }),
                BuilderOptions.IgnoreCase).ToList();

            result.Should().BeEquivalentTo(DataSet.Where(x => x.Id == 1 || x.Id == 3 || x.Id == 4));
        }
Пример #21
0
        public void TrimInput()
        {
            var result = DataSet.Build(
                _ => _.In(x => x.Name, new[] { " aaAa1", "baBa  " }),
                BuilderOptions.Trim);

            result.Should().BeEquivalentTo(DataSet.Where(x => x.Id == 1 || x.Id == 3));
        }
Пример #22
0
        public void IgnoreCaseEmpty()
        {
            var result = DataSet.Build(
                _ => _.In(x => x.Name, new[] { "baBae" }),
                BuilderOptions.IgnoreCase);

            result.Should().BeEmpty();
        }
Пример #23
0
        public void IgnoreCaseEmpty()
        {
            var result = DataSet.Build(
                _ => _.Equals(x => x.Name, "aaAb3"),
                BuilderOptions.IgnoreCase);

            result.Should().BeEmpty();
        }
Пример #24
0
        public void CaseSensitive()
        {
            var result = DataSet.Build(
                _ => _.In(x => x.Name, new[] { "aaAa1", "baBa" }),
                BuilderOptions.None);

            result.Should().BeEquivalentTo(DataSet.Where(x => x.Id == 1 || x.Id == 3));
        }
Пример #25
0
        public void TrimInput()
        {
            var result = DataSet.Build(
                _ => _.Equals(x => x.Name, " aaAa1 "),
                BuilderOptions.Trim);

            result.Should().BeEquivalentTo(DataSet.Where(x => x.Id == 1));
        }
Пример #26
0
        public void CaseSensitiveEmpty()
        {
            var result = DataSet.Build(
                _ => _.In(x => x.Name, new[] { " baBa" }),
                BuilderOptions.None);

            result.Should().BeEmpty();
        }
        public void NestedInEmpty()
        {
            var requestIdList = new long[] { -2, -1 };
            var result        = DataSet.Build(
                _ => _.Any(p => p.Requests, n => n.In(x => x.Id, requestIdList)));

            result.Should().BeEmpty();
        }
        public void IgnoreDefault()
        {
            long[] requestIdList = null;
            var    result        = DataSet.Build(
                _ => _.Any(p => p.Requests, n => n.In(x => x.Id, requestIdList)));

            result.Should().BeEquivalentTo(DataSet);
        }
Пример #29
0
        public void UseNullInput()
        {
            Action f = () => DataSet.Build(
                _ => _.In(x => x.Name, null),
                BuilderOptions.None);

            f.Should().Throw <ArgumentNullException>();
        }
        public void NestedIn()
        {
            var requestIdList = new long[] { 2, 3 };
            var result        = DataSet.Build(
                _ => _.Any(p => p.Requests, n => n.In(x => x.Id, requestIdList)));

            result.Should().BeEquivalentTo(DataSet.Where(x => x.Requests.Any(n => requestIdList.Contains(n.Id))));
        }