/Tests/DynamicWhereClause/DynamicWhereClauseTests.cs

using System;

using System.Collections.Generic;

using System.Linq.Expressions;

using AutoMapper;

using FluentAssertions;

using NUnit.Framework;

using Telerik.Web.Mvc;

using TelerikMvcGridCustomBindingHelper;

using TelerikMvcGridCustomBindingHelper.DynamicQuery;

using TelerikMvcGridCustomBindingHelper.Mapper;

using TelerikMvcGridCustomBindingHelper.Util;

using Tests.Entity;

using Tests.ViewModel;



namespace Tests.DynamicWhereClause

{

    public class ExpressionWhereClauseWithBooleanSubstituteTests

    {

        //todo: CustomExpressions

        [SetUp]

        public void SetUp()

        {

            Mapper.Reset();

            GridModelMapper.Reset();



            GridModelMapper.CreateMap<Foo, FooModel>()

                // Add a BooleanSubstitute to a single property

                .MapProperty(foo => foo.EnabledFlag, model => model.Enabled, options => options.SetBooleanSubstitute<BooleanSubstitute>());

                //todo: .MapProperty(foo => foo.EnabledFlag == "" && foo.EnabledFlag == "", model => model.ComplexEnabled, options => options.SetBooleanSubstitute<BooleanSubstitute>());



            // GlobalBooleanSubstitutes have lower precedence

            GridModelMapper.Configuration.SetGlobalBooleanSubstitute<EfBooleanSubstitute>();

        }



        private class BooleanSubstitute : IBooleanSubstitute

        {

            public IList<object> TrueValues()

            {

                return new[] { "Y" };

            }



            public IList<object> FalseValues()

            {

                return new[] { "N", null };

            }

        }



        private class EfBooleanSubstitute : IBooleanSubstitute

        {

            public IList<object> TrueValues()

            {

                return new object[] { true };

            }



            public IList<object> FalseValues()

            {

                return new object[] { false, null };

            }

        }



        #region ExpressionCases



        // ReSharper disable InconsistentNaming

        // ReSharper disable NegativeEqualityExpression

        static readonly Expression<Func<Foo, bool>> Exp_IsEqualToTrue = foo => foo.EnabledFlag == "Y";

        static readonly Expression<Func<Foo, bool>> Exp_IsNotEqualToTrue = foo => !(foo.EnabledFlag == "Y");

        static readonly Expression<Func<Foo, bool>> Exp_IsEqualToFalse = foo => foo.EnabledFlag == null || foo.EnabledFlag == "N";

        static readonly Expression<Func<Foo, bool>> Exp_IsNotEqualToFalse = foo => !(foo.EnabledFlag == null) || !(foo.EnabledFlag == "N");

        static readonly Expression<Func<Foo, bool>> Exp_EfIsEqualToTrue = foo => foo.EfEnabled == true;

        static readonly Expression<Func<Foo, bool>> Exp_EfIsNotEqualToTrue = foo => !(foo.EfEnabled == true);

        static readonly Expression<Func<Foo, bool>> Exp_EfIsEqualToFalse = foo => foo.EfEnabled == null || foo.EfEnabled == false;

        static readonly Expression<Func<Foo, bool>> Exp_EfIsNotEqualToFalse = foo => !(foo.EfEnabled == null) || !(foo.EfEnabled == false);



        static readonly object[] ExpressionCases =

        {

            new object[] { "EnabledFlag", FilterOperator.IsEqualTo, Exp_IsEqualToTrue, true },

            new object[] { "EnabledFlag", FilterOperator.IsNotEqualTo, Exp_IsNotEqualToTrue, true},

            new object[] { "EnabledFlag", FilterOperator.IsEqualTo, Exp_IsEqualToFalse, false },

            new object[] { "EnabledFlag", FilterOperator.IsNotEqualTo, Exp_IsNotEqualToFalse, false},

            new object[] { "EnabledFlag", FilterOperator.IsEqualTo, Exp_IsEqualToFalse, null},

            new object[] { "EnabledFlag", FilterOperator.IsNotEqualTo, Exp_IsNotEqualToFalse, null},

            new object[] { "EfEnabled", FilterOperator.IsEqualTo, Exp_EfIsEqualToTrue, true },

            new object[] { "EfEnabled", FilterOperator.IsNotEqualTo, Exp_EfIsNotEqualToTrue, true},

            new object[] { "EfEnabled", FilterOperator.IsEqualTo, Exp_EfIsEqualToFalse, false },

            new object[] { "EfEnabled", FilterOperator.IsNotEqualTo, Exp_EfIsNotEqualToFalse, false},

            new object[] { "EfEnabled", FilterOperator.IsEqualTo, Exp_EfIsEqualToFalse, null},

            new object[] { "EfEnabled", FilterOperator.IsNotEqualTo, Exp_EfIsNotEqualToFalse, null}

        };

        // ReSharper restore NegativeEqualityExpression

        // ReSharper restore InconsistentNaming



        #endregion



        [TestCaseSource("ExpressionCases")]

        public void expressionWhereClause_single_expressions_with_booleanSubstitute(string member, FilterOperator @operator, Expression<Func<Foo, bool>> exp, object value)

        {

            var filter = new FilterDescriptor(member, @operator, value);

            var expressionWhereClause = new ExpressionWhereClause<Foo, FooModel>(filter, null, false, null);



            expressionWhereClause.Predicate.ToString().Replace("Tests.DynamicWhereClause.ExpressionWhereClauseWithBooleanSubstituteTests+Foo", "foo").Should().Be(exp.ToString());

        }



        [TestCaseSource("ExpressionCases")]

        public void expressionWhereClause_double_expressions_with_orElse_operator(string member, FilterOperator @operator, Expression<Func<Foo, bool>> exp, object value)

        {

            var filter = new FilterDescriptor(member, @operator, value);

            var expressionWhereClause = new ExpressionWhereClause<Foo, FooModel>(filter, null, false, null);



            expressionWhereClause.Predicate.ToString().Replace("Tests.DynamicWhereClause.ExpressionWhereClauseWithBooleanSubstituteTests+Foo", "foo").Should().Be(exp.ToString());



            expressionWhereClause.OrElse(expressionWhereClause);



            expressionWhereClause.Predicate.ToString().Replace("Tests.DynamicWhereClause.ExpressionWhereClauseWithBooleanSubstituteTests+Foo", "foo").Should().Be(exp.OrElse(exp).ToString());

        }



        [TestCaseSource("ExpressionCases")]

        public void expressionWhereClause_double_expressions_with_andAlso_operator(string member, FilterOperator @operator, Expression<Func<Foo, bool>> exp, object value)

        {

            var filter = new FilterDescriptor(member, @operator, value);

            var expressionWhereClause = new ExpressionWhereClause<Foo, FooModel>(filter, null, false, null);



            expressionWhereClause.Predicate.ToString().Replace("Tests.DynamicWhereClause.ExpressionWhereClauseWithBooleanSubstituteTests+Foo", "foo").Should().Be(exp.ToString());



            expressionWhereClause.AndAlso(expressionWhereClause);



            expressionWhereClause.Predicate.ToString().Replace("Tests.DynamicWhereClause.ExpressionWhereClauseWithBooleanSubstituteTests+Foo", "foo").Should().Be(exp.AndAlso(exp).ToString());

        }



        #region Test models



        // ReSharper disable ClassNeverInstantiated.Global

        // ReSharper disable UnusedAutoPropertyAccessor.Global

        // ReSharper disable ClassNeverInstantiated.Local

        // ReSharper disable UnusedAutoPropertyAccessor.Local

        // ReSharper disable UnusedMember.Local

        public class Foo

        {

            public bool? EfEnabled { get; set; }

            public string EnabledFlag { get; set; }

        }



        private class FooModel

        {

            public bool? EfEnabled { get; set; }

            public bool Enabled { get; set; }

            public bool ComplexEnabled { get; set; }

        }

        // ReSharper restore UnusedMember.Local

        // ReSharper restore UnusedAutoPropertyAccessor.Local

        // ReSharper restore ClassNeverInstantiated.Local

        // ReSharper restore UnusedAutoPropertyAccessor.Global

        // ReSharper restore ClassNeverInstantiated.Global



        #endregion

    }



    public class ExpressionWhereClauseWithNullSubstituteTests

    {

        //todo: CustomExpressions

        [SetUp]

        public void SetUp()

        {

            Mapper.Reset(); GridModelMapper.Reset();

            //GridModelMapper.CreateMap<Foo, FooModel>()

            //    .MapProperty(foo => foo.FirstName + " " + foo.LastName, model => model.FullName)

            //    .MapProperty(foo => foo.UnitPrice + foo.UnitsInStock, model => model.TotalPrice);



            GridModelMapper.CreateMap<Foo, FooModel>();



            // Can be set globally, per property, or in per query basis

            GridModelMapper.Configuration.SetGlobalNullSubstitute<NullSubstitute>();

        }



        private class NullSubstitute : INullSubstitute

        {

            public bool IsCaseInsensitive { get { return false; } }



            public IList<object> NullValues()

            {

                return new object[] { "none", string.Empty, 0, new DateTime(), null };

            }

        }



        #region ExpressionCases



        // ReSharper disable InconsistentNaming

        // ReSharper disable NegativeEqualityExpression

        static readonly Expression<Func<Foo, bool>> Exp_NullableIsEqualTo = foo => foo.NullableDecimal == null || foo.NullableDecimal.Value == 0;

        static readonly Expression<Func<Foo, bool>> Exp_StringIsEqualTo = foo => foo.Name == "none" || foo.Name == "" || foo.Name == "0" || foo.Name == "01/01/0001 00:00:00" || foo.Name == null;

        static readonly Expression<Func<Foo, bool>> Exp_StringIsNotEqualTo = foo => !(foo.Name == "none") || !(foo.Name == "") || !(foo.Name == "0") || !(foo.Name == "01/01/0001 00:00:00") || !(foo.Name == null);

        static readonly Expression<Func<Foo, bool>> Exp_NotNullableIsEqualTo = foo => foo.NotNullableDecimal == 0;

        static readonly Expression<Func<Foo, bool>> Exp_NotNullableIsNotEqualTo = foo => foo.NotNullableDecimal != 0;

        static readonly Expression<Func<Foo, bool>> Exp_NotSubstituteIsEqualTo = foo => foo.Name == "value";

        static readonly Expression<Func<Foo, bool>> Exp_NotSubstituteIsNotEqualTo = foo => foo.Name != "value";

        static readonly Expression<Func<Foo, bool>> Exp_DateTimeIsEqualTo = foo => foo.DateTime == new DateTime(2012, 10, 19);

        static readonly Expression<Func<Foo, bool>> Exp_DateTimeIsNotEqualTo = foo => foo.DateTime != new DateTime(2012, 10, 19);



        static readonly object[] ExpressionCases =

        {

            new object[] { "NullableDecimal", FilterOperator.IsLessThan, Exp_NullableIsEqualTo, null },

            new object[] { "NullableDecimal", FilterOperator.IsLessThanOrEqualTo, Exp_NullableIsEqualTo, null },

            new object[] { "NullableDecimal", FilterOperator.IsGreaterThanOrEqualTo, Exp_NullableIsEqualTo, null },

            new object[] { "NullableDecimal", FilterOperator.IsGreaterThan, Exp_NullableIsEqualTo, null },

            new object[] { "Name", FilterOperator.StartsWith, Exp_StringIsEqualTo, null },

            new object[] { "Name", FilterOperator.EndsWith, Exp_StringIsEqualTo, null },

            new object[] { "Name", FilterOperator.Contains, Exp_StringIsEqualTo, null },

            new object[] { "Name", FilterOperator.DoesNotContain, Exp_StringIsNotEqualTo, null },

            new object[] { "Name", FilterOperator.IsEqualTo, Exp_StringIsEqualTo, null },

            new object[] { "Name", FilterOperator.IsNotEqualTo, Exp_StringIsNotEqualTo, null },



            new object[] { "NotNullableDecimal", FilterOperator.IsEqualTo, Exp_NotNullableIsEqualTo, null },

            new object[] { "NotNullableDecimal", FilterOperator.IsNotEqualTo, Exp_NotNullableIsNotEqualTo, null },

            new object[] { "Name", FilterOperator.IsEqualTo, Exp_NotSubstituteIsEqualTo, "value" },

            new object[] { "Name", FilterOperator.IsNotEqualTo, Exp_NotSubstituteIsNotEqualTo, "value" },

            new object[] { "DateTime", FilterOperator.IsEqualTo, Exp_DateTimeIsEqualTo, new DateTime(2012, 10, 19) },

            new object[] { "DateTime", FilterOperator.IsNotEqualTo, Exp_DateTimeIsNotEqualTo, new DateTime(2012, 10, 19) }

        };

        // ReSharper restore NegativeEqualityExpression

        // ReSharper restore InconsistentNaming



        #endregion



        [TestCaseSource("ExpressionCases")]

        public void expressionWhereClause_single_expressions_with_booleanSubstitute(string member, FilterOperator @operator, Expression<Func<Foo, bool>> exp, object value)

        {

            var filter = new FilterDescriptor(member, @operator, value);

            var expressionWhereClause = new ExpressionWhereClause<Foo, FooModel>(filter, null, false, null);



            expressionWhereClause.Predicate.ToString()

                .Replace("Tests.DynamicWhereClause.ExpressionWhereClauseWithNullSubstituteTests+Foo", "foo")

                .Should().Be(exp.ToString().Replace(".Value", "").Replace("new DateTime(2012, 10, 19)", "19/10/2012 00:00:00"));

        }



        [TestCaseSource("ExpressionCases")]

        public void expressionWhereClause_double_expressions_with_orElse_operator(string member, FilterOperator @operator, Expression<Func<Foo, bool>> exp, object value)

        {

            var filter = new FilterDescriptor(member, @operator, value);

            var expressionWhereClause = new ExpressionWhereClause<Foo, FooModel>(filter, null, false, null);



            expressionWhereClause.Predicate.ToString()

                .Replace("Tests.DynamicWhereClause.ExpressionWhereClauseWithNullSubstituteTests+Foo", "foo")

                .Should().Be(exp.ToString().Replace(".Value", "").Replace("new DateTime(2012, 10, 19)", "19/10/2012 00:00:00"));



            expressionWhereClause.OrElse(expressionWhereClause);



            expressionWhereClause.Predicate.ToString()

                .Replace("Tests.DynamicWhereClause.ExpressionWhereClauseWithNullSubstituteTests+Foo", "foo")

                .Should().Be(exp.OrElse(exp).ToString().Replace(".Value", "").Replace("new DateTime(2012, 10, 19)", "19/10/2012 00:00:00"));

        }



        [TestCaseSource("ExpressionCases")]

        public void expressionWhereClause_double_expressions_with_andAlso_operator(string member, FilterOperator @operator, Expression<Func<Foo, bool>> exp, object value)

        {

            var filter = new FilterDescriptor(member, @operator, value);

            var expressionWhereClause = new ExpressionWhereClause<Foo, FooModel>(filter, null, false, null);



            expressionWhereClause.Predicate.ToString()

                .Replace("Tests.DynamicWhereClause.ExpressionWhereClauseWithNullSubstituteTests+Foo", "foo")

                .Should().Be(exp.ToString().Replace(".Value", "").Replace("new DateTime(2012, 10, 19)", "19/10/2012 00:00:00"));



            expressionWhereClause.AndAlso(expressionWhereClause);



            expressionWhereClause.Predicate.ToString()

                .Replace("Tests.DynamicWhereClause.ExpressionWhereClauseWithNullSubstituteTests+Foo", "foo")

                .Should().Be(exp.AndAlso(exp).ToString().Replace(".Value", "").Replace("new DateTime(2012, 10, 19)", "19/10/2012 00:00:00"));

        }



        #region Test models



        // ReSharper disable ClassNeverInstantiated.Global

        // ReSharper disable UnusedAutoPropertyAccessor.Global

        // ReSharper disable ClassNeverInstantiated.Local

        // ReSharper disable UnusedAutoPropertyAccessor.Local

        // ReSharper disable UnusedMember.Local

        public class Foo

        {

            public string Name { get; set; }

            public decimal? NullableDecimal { get; set; }

            public decimal NotNullableDecimal { get; set; }

            public DateTime DateTime { get; set; }

        }



        private class FooModel

        {

            public string Name { get; set; }

            public decimal? NullableDecimal { get; set; }

            public decimal NotNullableDecimal { get; set; }

            public DateTime DateTime { get; set; }

        }

        // ReSharper restore UnusedMember.Local

        // ReSharper restore UnusedAutoPropertyAccessor.Local

        // ReSharper restore ClassNeverInstantiated.Local

        // ReSharper restore UnusedAutoPropertyAccessor.Global

        // ReSharper restore ClassNeverInstantiated.Global



        #endregion

    }



    public class ExpressionWhereClauseWithNullSubstituteWithCaseInsensitiveTests

    {

        //todo: CustomExpressions

        [SetUp]

        public void SetUp()

        {

            Mapper.Reset(); GridModelMapper.Reset();

            //GridModelMapper.CreateMap<Foo, FooModel>()

            //    .MapProperty(foo => foo.FirstName + " " + foo.LastName, model => model.FullName)

            //    .MapProperty(foo => foo.UnitPrice + foo.UnitsInStock, model => model.TotalPrice);



            GridModelMapper.CreateMap<Foo, FooModel>();



            // Can be set globally, per property, or in per query basis

            GridModelMapper.Configuration.SetGlobalNullSubstitute<NullSubstitute>();

        }



        private class NullSubstitute : INullSubstitute

        {

            public bool IsCaseInsensitive { get { return true; } }



            public IList<object> NullValues()

            {

                return new object[] { "NoNe", string.Empty, 0, new DateTime(), null };

            }

        }



        #region ExpressionCases



        // ReSharper disable InconsistentNaming

        // ReSharper disable NegativeEqualityExpression

        static readonly Expression<Func<Foo, bool>> Exp_NullableIsEqualTo = foo => foo.NullableDecimal == null || foo.NullableDecimal.Value == 0;

        static readonly Expression<Func<Foo, bool>> Exp_StringIsEqualTo = foo => foo.Name.ToLowerInvariant() == "none" || foo.Name.ToLowerInvariant() == "" || foo.Name.ToLowerInvariant() == "0" || foo.Name.ToLowerInvariant() == "01/01/0001 00:00:00" || foo.Name == null;

        static readonly Expression<Func<Foo, bool>> Exp_StringIsNotEqualTo = foo => !(foo.Name.ToLowerInvariant() == "none") || !(foo.Name.ToLowerInvariant() == "") || !(foo.Name.ToLowerInvariant() == "0") || !(foo.Name.ToLowerInvariant() == "01/01/0001 00:00:00") || !(foo.Name == null);

        static readonly Expression<Func<Foo, bool>> Exp_NotNullableIsEqualTo = foo => foo.NotNullableDecimal == 0;

        static readonly Expression<Func<Foo, bool>> Exp_NotNullableIsNotEqualTo = foo => foo.NotNullableDecimal != 0;

        static readonly Expression<Func<Foo, bool>> Exp_NotSubstituteIsEqualTo = foo => foo.Name == "value";

        static readonly Expression<Func<Foo, bool>> Exp_NotSubstituteIsNotEqualTo = foo => foo.Name != "value";

        static readonly Expression<Func<Foo, bool>> Exp_DateTimeIsEqualTo = foo => foo.DateTime == new DateTime(2012, 10, 19);

        static readonly Expression<Func<Foo, bool>> Exp_DateTimeIsNotEqualTo = foo => foo.DateTime != new DateTime(2012, 10, 19);



        static readonly object[] ExpressionCases =

        {

            new object[] { "NullableDecimal", FilterOperator.IsLessThan, Exp_NullableIsEqualTo, null },

            new object[] { "NullableDecimal", FilterOperator.IsLessThanOrEqualTo, Exp_NullableIsEqualTo, null },

            new object[] { "NullableDecimal", FilterOperator.IsGreaterThanOrEqualTo, Exp_NullableIsEqualTo, null },

            new object[] { "NullableDecimal", FilterOperator.IsGreaterThan, Exp_NullableIsEqualTo, null },

            new object[] { "Name", FilterOperator.StartsWith, Exp_StringIsEqualTo, null },

            new object[] { "Name", FilterOperator.EndsWith, Exp_StringIsEqualTo, null },

            new object[] { "Name", FilterOperator.Contains, Exp_StringIsEqualTo, null },

            new object[] { "Name", FilterOperator.DoesNotContain, Exp_StringIsNotEqualTo, null },

            new object[] { "Name", FilterOperator.IsEqualTo, Exp_StringIsEqualTo, null },

            new object[] { "Name", FilterOperator.IsNotEqualTo, Exp_StringIsNotEqualTo, null },



            new object[] { "NotNullableDecimal", FilterOperator.IsEqualTo, Exp_NotNullableIsEqualTo, null },

            new object[] { "NotNullableDecimal", FilterOperator.IsNotEqualTo, Exp_NotNullableIsNotEqualTo, null },

            new object[] { "Name", FilterOperator.IsEqualTo, Exp_NotSubstituteIsEqualTo, "value" },

            new object[] { "Name", FilterOperator.IsNotEqualTo, Exp_NotSubstituteIsNotEqualTo, "value" },

            new object[] { "DateTime", FilterOperator.IsEqualTo, Exp_DateTimeIsEqualTo, new DateTime(2012, 10, 19) },

            new object[] { "DateTime", FilterOperator.IsNotEqualTo, Exp_DateTimeIsNotEqualTo, new DateTime(2012, 10, 19) }

        };

        // ReSharper restore NegativeEqualityExpression

        // ReSharper restore InconsistentNaming



        #endregion



        [TestCaseSource("ExpressionCases")]

        public void expressionWhereClause_single_expressions_with_booleanSubstitute(string member, FilterOperator @operator, Expression<Func<Foo, bool>> exp, object value)

        {

            var filter = new FilterDescriptor(member, @operator, value);

            var expressionWhereClause = new ExpressionWhereClause<Foo, FooModel>(filter, null, false, null);



            expressionWhereClause.Predicate.ToString()

                .Replace("Tests.DynamicWhereClause.ExpressionWhereClauseWithNullSubstituteWithCaseInsensitiveTests+Foo", "foo")

                .Should().Be(exp.ToString().Replace(".Value", "").Replace("new DateTime(2012, 10, 19)", "19/10/2012 00:00:00"));

        }



        [TestCaseSource("ExpressionCases")]

        public void expressionWhereClause_double_expressions_with_orElse_operator(string member, FilterOperator @operator, Expression<Func<Foo, bool>> exp, object value)

        {

            var filter = new FilterDescriptor(member, @operator, value);

            var expressionWhereClause = new ExpressionWhereClause<Foo, FooModel>(filter, null, false, null);



            expressionWhereClause.Predicate.ToString()

                .Replace("Tests.DynamicWhereClause.ExpressionWhereClauseWithNullSubstituteWithCaseInsensitiveTests+Foo", "foo")

                .Should().Be(exp.ToString().Replace(".Value", "").Replace("new DateTime(2012, 10, 19)", "19/10/2012 00:00:00"));



            expressionWhereClause.OrElse(expressionWhereClause);



            expressionWhereClause.Predicate.ToString()

                .Replace("Tests.DynamicWhereClause.ExpressionWhereClauseWithNullSubstituteWithCaseInsensitiveTests+Foo", "foo")

                .Should().Be(exp.OrElse(exp).ToString().Replace(".Value", "").Replace("new DateTime(2012, 10, 19)", "19/10/2012 00:00:00"));

        }



        [TestCaseSource("ExpressionCases")]

        public void expressionWhereClause_double_expressions_with_andAlso_operator(string member, FilterOperator @operator, Expression<Func<Foo, bool>> exp, object value)

        {

            var filter = new FilterDescriptor(member, @operator, value);

            var expressionWhereClause = new ExpressionWhereClause<Foo, FooModel>(filter, null, false, null);



            expressionWhereClause.Predicate.ToString()

                .Replace("Tests.DynamicWhereClause.ExpressionWhereClauseWithNullSubstituteWithCaseInsensitiveTests+Foo", "foo")

                .Should().Be(exp.ToString().Replace(".Value", "").Replace("new DateTime(2012, 10, 19)", "19/10/2012 00:00:00"));



            expressionWhereClause.AndAlso(expressionWhereClause);



            expressionWhereClause.Predicate.ToString()

                .Replace("Tests.DynamicWhereClause.ExpressionWhereClauseWithNullSubstituteWithCaseInsensitiveTests+Foo", "foo")

                .Should().Be(exp.AndAlso(exp).ToString().Replace(".Value", "").Replace("new DateTime(2012, 10, 19)", "19/10/2012 00:00:00"));

        }



        #region Test models



        // ReSharper disable ClassNeverInstantiated.Global

        // ReSharper disable UnusedAutoPropertyAccessor.Global

        // ReSharper disable ClassNeverInstantiated.Local

        // ReSharper disable UnusedAutoPropertyAccessor.Local

        // ReSharper disable UnusedMember.Local

        public class Foo

        {

            public string Name { get; set; }

            public decimal? NullableDecimal { get; set; }

            public decimal NotNullableDecimal { get; set; }

            public DateTime DateTime { get; set; }

        }



        private class FooModel

        {

            public string Name { get; set; }

            public decimal? NullableDecimal { get; set; }

            public decimal NotNullableDecimal { get; set; }

            public DateTime DateTime { get; set; }

        }

        // ReSharper restore UnusedMember.Local

        // ReSharper restore UnusedAutoPropertyAccessor.Local

        // ReSharper restore ClassNeverInstantiated.Local

        // ReSharper restore UnusedAutoPropertyAccessor.Global

        // ReSharper restore ClassNeverInstantiated.Global



        #endregion

    }



    public class ExpressionWhereClauseWithNullAliasTests

    {

        //todo: CustomExpressions

        [SetUp]

        public void SetUp()

        {

            Mapper.Reset(); GridModelMapper.Reset();

            //GridModelMapper.CreateMap<Foo, FooModel>()

            //    .MapProperty(foo => foo.FirstName + " " + foo.LastName, model => model.FullName)

            //    .MapProperty(foo => foo.UnitPrice + foo.UnitsInStock, model => model.TotalPrice);



            GridModelMapper.CreateMap<Foo, FooModel>();



            GridModelMapper.Configuration.SetGlobalNullAlias<NullAlias>();

        }



        private class NullAlias : INullAlias

        {

            public bool IsCaseInsensitive { get { return false; } }



            //the query should contain these aliases explicitly?

            public bool SearchExplicit { get { return false; } }



            public IList<object> Aliases()

            {

                return new object[] { "none", "empty", -1, null };

            }

        }



        #region ExpressionCases



        // ReSharper disable InconsistentNaming

        // ReSharper disable NegativeEqualityExpression

        static readonly Expression<Func<Foo, bool>> Exp_NullableIsEqualTo = foo => foo.NullableDecimal == null;

        static readonly Expression<Func<Foo, bool>> Exp_NullableValidValueIsLessThan = foo => foo.NullableDecimal.Value < 10;

        static readonly Expression<Func<Foo, bool>> Exp_NullableValidValueIsLessThanOrEqualTo = foo => foo.NullableDecimal.Value <= 10;

        static readonly Expression<Func<Foo, bool>> Exp_NullableValidValueIsGreaterThanOrEqualTo = foo => foo.NullableDecimal.Value >= 10;

        static readonly Expression<Func<Foo, bool>> Exp_NullableValidValueIsGreaterThan = foo => foo.NullableDecimal.Value > 10;

        static readonly Expression<Func<Foo, bool>> Exp_NullableValidValueIsEqualTo = foo => foo.NullableDecimal.Value == 10;

        static readonly Expression<Func<Foo, bool>> Exp_NullableValidValueIsNotEqualTo = foo => foo.NullableDecimal.Value != 10;

        static readonly Expression<Func<Foo, bool>> Exp_IsEqualTo = foo => foo.Name == null;

        static readonly Expression<Func<Foo, bool>> Exp_IsNotEqualTo = foo => !(foo.Name == null);

        static readonly Expression<Func<Foo, bool>> Exp_NotValidAliasIsEqualTo = foo => foo.Name == "value";

        static readonly Expression<Func<Foo, bool>> Exp_NotValidAliasIsNotEqualTo = foo => foo.Name != "value";

        static readonly Expression<Func<Foo, bool>> Exp_CaseSensitiveIsEqualTo = foo => foo.Name == "NoNe";

        static readonly Expression<Func<Foo, bool>> Exp_CaseSensitiveIsNotEqualTo = foo => foo.Name != "EmPtY";

        static readonly Expression<Func<Foo, bool>> Exp_NotNullableNullValueIsEqualTo = foo => foo.NotNullableDecimal == 0;

        static readonly Expression<Func<Foo, bool>> Exp_NotNullableNullValueIsNotEqualTo = foo => foo.NotNullableDecimal != 0;

        static readonly Expression<Func<Foo, bool>> Exp_NotNullableValidValueIsEqualTo = foo => foo.NotNullableDecimal == -1;

        static readonly Expression<Func<Foo, bool>> Exp_NotNullableValidValueIsNotEqualTo = foo => foo.NotNullableDecimal != -1;

        static readonly Expression<Func<Foo, bool>> Exp_NotNullableIsEqualTo = foo => foo.NotNullableDecimal == 10;

        static readonly Expression<Func<Foo, bool>> Exp_NotNullableIsNotEqualTo = foo => foo.NotNullableDecimal != 10;



        static readonly object[] ExpressionCases =

        {

            new object[] { "NullableDecimal", FilterOperator.IsLessThan, Exp_NullableIsEqualTo, null },

            new object[] { "NullableDecimal", FilterOperator.IsLessThanOrEqualTo, Exp_NullableIsEqualTo, null },

            new object[] { "NullableDecimal", FilterOperator.IsGreaterThanOrEqualTo, Exp_NullableIsEqualTo, null },

            new object[] { "NullableDecimal", FilterOperator.IsGreaterThan, Exp_NullableIsEqualTo, null },

            new object[] { "NullableDecimal", FilterOperator.IsLessThan, Exp_NullableIsEqualTo, -1 },

            new object[] { "NullableDecimal", FilterOperator.IsLessThanOrEqualTo, Exp_NullableIsEqualTo, -1 },

            new object[] { "NullableDecimal", FilterOperator.IsGreaterThanOrEqualTo, Exp_NullableIsEqualTo, -1 },

            new object[] { "NullableDecimal", FilterOperator.IsGreaterThan, Exp_NullableIsEqualTo, -1 },

            new object[] { "NullableDecimal", FilterOperator.IsLessThan, Exp_NullableValidValueIsLessThan, 10 },

            new object[] { "NullableDecimal", FilterOperator.IsLessThanOrEqualTo, Exp_NullableValidValueIsLessThanOrEqualTo, 10 },

            new object[] { "NullableDecimal", FilterOperator.IsGreaterThanOrEqualTo, Exp_NullableValidValueIsGreaterThanOrEqualTo, 10 },

            new object[] { "NullableDecimal", FilterOperator.IsGreaterThan, Exp_NullableValidValueIsGreaterThan, 10 },

            new object[] { "NullableDecimal", FilterOperator.IsEqualTo, Exp_NullableValidValueIsEqualTo, 10 },

            new object[] { "NullableDecimal", FilterOperator.IsNotEqualTo, Exp_NullableValidValueIsNotEqualTo, 10 },



            new object[] { "NotNullableDecimal", FilterOperator.IsEqualTo, Exp_NotNullableNullValueIsEqualTo, null },

            new object[] { "NotNullableDecimal", FilterOperator.IsNotEqualTo, Exp_NotNullableNullValueIsNotEqualTo, null },

            new object[] { "NotNullableDecimal", FilterOperator.IsEqualTo, Exp_NotNullableNullValueIsEqualTo, "invalid-value" },

            new object[] { "NotNullableDecimal", FilterOperator.IsNotEqualTo, Exp_NotNullableNullValueIsNotEqualTo, "invalid-value" },

            new object[] { "NotNullableDecimal", FilterOperator.IsEqualTo, Exp_NotNullableValidValueIsEqualTo, -1 },

            new object[] { "NotNullableDecimal", FilterOperator.IsNotEqualTo, Exp_NotNullableValidValueIsNotEqualTo, -1 },

            new object[] { "NotNullableDecimal", FilterOperator.IsEqualTo, Exp_NotNullableIsEqualTo, 10 },

            new object[] { "NotNullableDecimal", FilterOperator.IsNotEqualTo, Exp_NotNullableIsNotEqualTo, 10 },



            new object[] { "Name", FilterOperator.StartsWith, Exp_IsEqualTo, "none" },

            new object[] { "Name", FilterOperator.EndsWith, Exp_IsEqualTo, "none" },

            new object[] { "Name", FilterOperator.Contains, Exp_IsEqualTo, "none" },

            new object[] { "Name", FilterOperator.DoesNotContain, Exp_IsNotEqualTo, "none" },



            new object[] { "Name", FilterOperator.IsEqualTo, Exp_IsEqualTo, null },

            new object[] { "Name", FilterOperator.IsNotEqualTo, Exp_IsNotEqualTo, null },

            new object[] { "Name", FilterOperator.IsEqualTo, Exp_IsEqualTo, "none" },

            new object[] { "Name", FilterOperator.IsEqualTo, Exp_IsEqualTo, "empty" },

            new object[] { "Name", FilterOperator.IsNotEqualTo, Exp_IsNotEqualTo, "none" },

            new object[] { "Name", FilterOperator.IsNotEqualTo, Exp_IsNotEqualTo, "empty" },

            new object[] { "Name", FilterOperator.IsEqualTo, Exp_NotValidAliasIsEqualTo, "value" },

            new object[] { "Name", FilterOperator.IsNotEqualTo, Exp_NotValidAliasIsNotEqualTo, "value" },

            new object[] { "Name", FilterOperator.IsEqualTo, Exp_CaseSensitiveIsEqualTo, "NoNe" },

            new object[] { "Name", FilterOperator.IsNotEqualTo, Exp_CaseSensitiveIsNotEqualTo, "EmPtY" }

        };

        // ReSharper restore NegativeEqualityExpression

        // ReSharper restore InconsistentNaming



        #endregion



        [TestCaseSource("ExpressionCases")]

        public void single_expressions(string member, FilterOperator @operator, Expression<Func<Foo, bool>> exp, object value)

        {

            var filter = new FilterDescriptor(member, @operator, value);

            var expressionWhereClause = new ExpressionWhereClause<Foo, FooModel>(filter, null, false, null);



            expressionWhereClause.Predicate.ToString()

                .Replace("Tests.DynamicWhereClause.ExpressionWhereClauseWithNullAliasTests+Foo", "foo")

                .Should().Be(exp.ToString().Replace(".Value", ""));

        }



        [TestCaseSource("ExpressionCases")]

        public void double_expressions_with_orElse_operator(string member, FilterOperator @operator, Expression<Func<Foo, bool>> exp, object value)

        {

            var filter = new FilterDescriptor(member, @operator, value);

            var expressionWhereClause = new ExpressionWhereClause<Foo, FooModel>(filter, null, false, null);



            expressionWhereClause.Predicate.ToString()

                .Replace("Tests.DynamicWhereClause.ExpressionWhereClauseWithNullAliasTests+Foo", "foo")

                .Should().Be(exp.ToString().Replace(".Value", ""));



            expressionWhereClause.OrElse(expressionWhereClause);



            expressionWhereClause.Predicate.ToString()

                .Replace("Tests.DynamicWhereClause.ExpressionWhereClauseWithNullAliasTests+Foo", "foo")

                .Should().Be(exp.OrElse(exp).ToString().Replace(".Value", ""));

        }



        [TestCaseSource("ExpressionCases")]

        public void double_expressions_with_andAlso_operator(string member, FilterOperator @operator, Expression<Func<Foo, bool>> exp, object value)

        {

            var filter = new FilterDescriptor(member, @operator, value);

            var expressionWhereClause = new ExpressionWhereClause<Foo, FooModel>(filter, null, false, null);



            expressionWhereClause.Predicate.ToString()

                .Replace("Tests.DynamicWhereClause.ExpressionWhereClauseWithNullAliasTests+Foo", "foo")

                .Should().Be(exp.ToString().Replace(".Value", ""));



            expressionWhereClause.AndAlso(expressionWhereClause);



            expressionWhereClause.Predicate.ToString()

                .Replace("Tests.DynamicWhereClause.ExpressionWhereClauseWithNullAliasTests+Foo", "foo")

                .Should().Be(exp.AndAlso(exp).ToString().Replace(".Value", ""));

        }



        #region Test models



        // ReSharper disable ClassNeverInstantiated.Global

        // ReSharper disable UnusedAutoPropertyAccessor.Global

        // ReSharper disable ClassNeverInstantiated.Local

        // ReSharper disable UnusedAutoPropertyAccessor.Local

        // ReSharper disable UnusedMember.Local

        // ReSharper disable UnusedMember.Global

        public class Foo

        {

            public string Name { get; set; }

            public decimal? NullableDecimal { get; set; }

            public decimal NotNullableDecimal { get; set; }

            public DateTime DateTime { get; set; }

        }



        private class FooModel

        {

            public string Name { get; set; }

            public decimal? NullableDecimal { get; set; }

            public decimal NotNullableDecimal { get; set; }

            public DateTime DateTime { get; set; }

        }

        // ReSharper restore UnusedMember.Global

        // ReSharper restore UnusedMember.Local

        // ReSharper restore UnusedAutoPropertyAccessor.Local

        // ReSharper restore ClassNeverInstantiated.Local

        // ReSharper restore UnusedAutoPropertyAccessor.Global

        // ReSharper restore ClassNeverInstantiated.Global



        #endregion

    }



    public class ExpressionWhereClauseWithNullAliasAndSearchExplicitTests

    {

        //todo: CustomExpressions

        [SetUp]

        public void SetUp()

        {

            Mapper.Reset(); GridModelMapper.Reset();

            //GridModelMapper.CreateMap<Foo, FooModel>()

            //    .MapProperty(foo => foo.FirstName + " " + foo.LastName, model => model.FullName)

            //    .MapProperty(foo => foo.UnitPrice + foo.UnitsInStock, model => model.TotalPrice);



            GridModelMapper.CreateMap<Foo, FooModel>();



            GridModelMapper.Configuration.SetGlobalNullAlias<NullAlias>();

        }



        private class NullAlias : INullAlias

        {

            public bool IsCaseInsensitive { get { return false; } }



            //the query should contain these aliases explicitly?

            public bool SearchExplicit { get { return true; } }



            public IList<object> Aliases()

            {

                return new object[] { "none", "empty", -1, null };

            }

        }



        #region ExpressionCases



        // ReSharper disable InconsistentNaming

        // ReSharper disable NegativeEqualityExpression

        static readonly Expression<Func<Foo, bool>> Exp_NullableValidValueIsEqualTo = foo => foo.NullableDecimal.Value == 10;

        static readonly Expression<Func<Foo, bool>> Exp_NullableIsEqualTo = foo => foo.NullableDecimal == null || foo.NullableDecimal.Value == -1;

        static readonly Expression<Func<Foo, bool>> Exp_NullableIsLessThan = foo => foo.NullableDecimal == null || foo.NullableDecimal.Value < -1;

        static readonly Expression<Func<Foo, bool>> Exp_NullableIsLessThanOrEqualTo = foo => foo.NullableDecimal == null || foo.NullableDecimal.Value <= -1;

        static readonly Expression<Func<Foo, bool>> Exp_NullableIsGreaterThan = foo => foo.NullableDecimal == null || foo.NullableDecimal.Value > -1;

        static readonly Expression<Func<Foo, bool>> Exp_NullableIsGreaterThanOrEqualTo = foo => foo.NullableDecimal == null || foo.NullableDecimal.Value >= -1;

        static readonly Expression<Func<Foo, bool>> Exp_NullableIsNotEqualTo = foo => !(foo.NullableDecimal == null) && foo.NullableDecimal.Value != -1;

        static readonly Expression<Func<Foo, bool>> Exp_IsEqualTo = foo => foo.Name == null || (foo.Name == "none" || foo.Name == "empty");

        static readonly Expression<Func<Foo, bool>> Exp_Contains = foo => foo.Name == null || (foo.Name.Contains("none") || foo.Name.Contains("empty"));

        static readonly Expression<Func<Foo, bool>> Exp_EndsWith = foo => foo.Name == null || (foo.Name.EndsWith("none") || foo.Name.EndsWith("empty"));

        static readonly Expression<Func<Foo, bool>> Exp_DoesNotContain = foo => !(foo.Name == null) && (!(foo.Name.Contains("none")) && !(foo.Name.Contains("empty")));

        static readonly Expression<Func<Foo, bool>> Exp_StartsWith = foo => foo.Name == null || (foo.Name.StartsWith("none") || foo.Name.StartsWith("empty"));

        static readonly Expression<Func<Foo, bool>> Exp_IsNotEqualTo = foo => !(foo.Name == null) && (foo.Name != "none" && foo.Name != "empty");

        static readonly Expression<Func<Foo, bool>> Exp_NotValidAliasIsEqualTo = foo => foo.Name == "value";

        static readonly Expression<Func<Foo, bool>> Exp_NotValidAliasIsNotEqualTo = foo => foo.Name != "value";

        static readonly Expression<Func<Foo, bool>> Exp_CaseSensitiveIsEqualTo = foo => foo.Name == "NoNe";

        static readonly Expression<Func<Foo, bool>> Exp_CaseSensitiveIsNotEqualTo = foo => foo.Name != "EmPtY";

        static readonly Expression<Func<Foo, bool>> Exp_NotNullableDefaultValueIsEqualTo = foo => foo.NotNullableDecimal == 0;

        static readonly Expression<Func<Foo, bool>> Exp_NotNullableIsEqualTo = foo => foo.NotNullableDecimal == -1;

        static readonly Expression<Func<Foo, bool>> Exp_NotNullableValidValueIsEqualTo = foo => foo.NotNullableDecimal == 10;

        static readonly Expression<Func<Foo, bool>> Exp_NotNullableIsNotEqualTo = foo => foo.NotNullableDecimal != 0;



        static readonly object[] ExpressionCases =

        {

            new object[] { "NullableDecimal", FilterOperator.IsLessThan, Exp_NullableIsLessThan, null },

            new object[] { "NullableDecimal", FilterOperator.IsLessThan, Exp_NullableIsLessThan, -1 },

            new object[] { "NullableDecimal", FilterOperator.IsLessThanOrEqualTo, Exp_NullableIsLessThanOrEqualTo, null },

            new object[] { "NullableDecimal", FilterOperator.IsLessThanOrEqualTo, Exp_NullableIsLessThanOrEqualTo, -1 },



            new object[] { "NullableDecimal", FilterOperator.IsGreaterThan, Exp_NullableIsGreaterThan, null },

            new object[] { "NullableDecimal", FilterOperator.IsGreaterThan, Exp_NullableIsGreaterThan, -1 },

            new object[] { "NullableDecimal", FilterOperator.IsGreaterThanOrEqualTo, Exp_NullableIsGreaterThanOrEqualTo, null },

            new object[] { "NullableDecimal", FilterOperator.IsGreaterThanOrEqualTo, Exp_NullableIsGreaterThanOrEqualTo, -1 },



            new object[] { "NullableDecimal", FilterOperator.IsEqualTo, Exp_NullableIsEqualTo, null },

            new object[] { "NullableDecimal", FilterOperator.IsEqualTo, Exp_NullableIsEqualTo, -1 },

            new object[] { "NullableDecimal", FilterOperator.IsNotEqualTo, Exp_NullableIsNotEqualTo, null },

            new object[] { "NullableDecimal", FilterOperator.IsNotEqualTo, Exp_NullableIsNotEqualTo, -1 },

            new object[] { "NullableDecimal", FilterOperator.IsEqualTo, Exp_NullableValidValueIsEqualTo, 10 },



            new object[] { "NotNullableDecimal", FilterOperator.IsEqualTo, Exp_NotNullableValidValueIsEqualTo, 10 },

            new object[] { "NotNullableDecimal", FilterOperator.IsEqualTo, Exp_NotNullableIsEqualTo, -1 },

            new object[] { "NotNullableDecimal", FilterOperator.IsEqualTo, Exp_NotNullableDefaultValueIsEqualTo, null },

            new object[] { "NotNullableDecimal", FilterOperator.IsEqualTo, Exp_NotNullableDefaultValueIsEqualTo, "none" },

            new object[] { "NotNullableDecimal", FilterOperator.IsNotEqualTo, Exp_NotNullableIsNotEqualTo, null },



            new object[] { "Name", FilterOperator.StartsWith, Exp_StartsWith, "none" },

            new object[] { "Name", FilterOperator.EndsWith, Exp_EndsWith, "none" },

            new object[] { "Name", FilterOperator.Contains, Exp_Contains, "none" },

            new object[] { "Name", FilterOperator.DoesNotContain, Exp_DoesNotContain, "none" },



            new object[] { "Name", FilterOperator.IsEqualTo, Exp_IsEqualTo, null },

            new object[] { "Name", FilterOperator.IsNotEqualTo, Exp_IsNotEqualTo, null },

            new object[] { "Name", FilterOperator.IsEqualTo, Exp_IsEqualTo, "none" },

            new object[] { "Name", FilterOperator.IsEqualTo, Exp_IsEqualTo, "empty" },

            new object[] { "Name", FilterOperator.IsNotEqualTo, Exp_IsNotEqualTo, "none" },

            new object[] { "Name", FilterOperator.IsNotEqualTo, Exp_IsNotEqualTo, "empty" },

            new object[] { "Name", FilterOperator.IsEqualTo, Exp_NotValidAliasIsEqualTo, "value" },

            new object[] { "Name", FilterOperator.IsNotEqualTo, Exp_NotValidAliasIsNotEqualTo, "value" },

            new object[] { "Name", FilterOperator.IsEqualTo, Exp_CaseSensitiveIsEqualTo, "NoNe" },

            new object[] { "Name", FilterOperator.IsNotEqualTo, Exp_CaseSensitiveIsNotEqualTo, "EmPtY" }

        };

        // ReSharper restore NegativeEqualityExpression

        // ReSharper restore InconsistentNaming



        #endregion



        [TestCaseSource("ExpressionCases")]

        public void single_expressions(string member, FilterOperator @operator, Expression<Func<Foo, bool>> exp, object value)

        {

            var filter = new FilterDescriptor(member, @operator, value);

            var expressionWhereClause = new ExpressionWhereClause<Foo, FooModel>(filter, null, false, null);



            expressionWhereClause.Predicate.ToString()

                .Replace("Tests.DynamicWhereClause.ExpressionWhereClauseWithNullAliasAndSearchExplicitTests+Foo", "foo")

                .Should().Be(exp.ToString().Replace(".Value", ""));

        }



        [TestCaseSource("ExpressionCases")]

        public void double_expressions_with_orElse_operator(string member, FilterOperator @operator, Expression<Func<Foo, bool>> exp, object value)

        {

            var filter = new FilterDescriptor(member, @operator, value);

            var expressionWhereClause = new ExpressionWhereClause<Foo, FooModel>(filter, null, false, null);



            expressionWhereClause.Predicate.ToString()

                .Replace("Tests.DynamicWhereClause.ExpressionWhereClauseWithNullAliasAndSearchExplicitTests+Foo", "foo")

                .Should().Be(exp.ToString().Replace(".Value", ""));



            expressionWhereClause.OrElse(expressionWhereClause);



            expressionWhereClause.Predicate.ToString()

                .Replace("Tests.DynamicWhereClause.ExpressionWhereClauseWithNullAliasAndSearchExplicitTests+Foo", "foo")

                .Should().Be(exp.OrElse(exp).ToString().Replace(".Value", ""));

        }



        [TestCaseSource("ExpressionCases")]

        public void double_expressions_with_andAlso_operator(string member, FilterOperator @operator, Expression<Func<Foo, bool>> exp, object value)

        {

            var filter = new FilterDescriptor(member, @operator, value);

            var expressionWhereClause = new ExpressionWhereClause<Foo, FooModel>(filter, null, false, null);



            expressionWhereClause.Predicate.ToString()

                .Replace("Tests.DynamicWhereClause.ExpressionWhereClauseWithNullAliasAndSearchExplicitTests+Foo", "foo")

                .Should().Be(exp.ToString().Replace(".Value", ""));



            expressionWhereClause.AndAlso(expressionWhereClause);



            expressionWhereClause.Predicate.ToString()

                .Replace("Tests.DynamicWhereClause.ExpressionWhereClauseWithNullAliasAndSearchExplicitTests+Foo", "foo")

                .Should().Be(exp.AndAlso(exp).ToString().Replace(".Value", ""));

        }



        #region Test models



        // ReSharper disable ClassNeverInstantiated.Global

        // ReSharper disable UnusedAutoPropertyAccessor.Global

        // ReSharper disable ClassNeverInstantiated.Local

        // ReSharper disable UnusedAutoPropertyAccessor.Local

        // ReSharper disable UnusedMember.Local

        // ReSharper disable UnusedMember.Global

        public class Foo

        {

            public string Name { get; set; }

            public decimal? NullableDecimal { get; set; }

            public decimal NotNullableDecimal { get; set; }

            public DateTime DateTime { get; set; }

        }



        private class FooModel

        {

            public string Name { get; set; }

            public decimal? NullableDecimal { get; set; }

            public decimal NotNullableDecimal { get; set; }

            public DateTime DateTime { get; set; }

        }

        // ReSharper restore UnusedMember.Global

        // ReSharper restore UnusedMember.Local

        // ReSharper restore UnusedAutoPropertyAccessor.Local

        // ReSharper restore ClassNeverInstantiated.Local

        // ReSharper restore UnusedAutoPropertyAccessor.Global

        // ReSharper restore ClassNeverInstantiated.Global



        #endregion

    }



    public class ExpressionWhereClauseWithNullAliasAndCaseInsensitiveTests

    {

        [SetUp]

        public void SetUp()

        {

            Mapper.Reset();

            GridModelMapper.Reset();



            GridModelMapper.CreateMap<Foo, FooModel>()

                .MapProperty(foo => foo.FirstName + " " + foo.LastName, model => model.FullName)

                .MapProperty(foo => foo.NullableDecimal + foo.NullableDecimal, model => model.NullableTotalPrice)

                .MapProperty(foo => foo.NotNullableDecimal + foo.NotNullableDecimal, model => model.NotNullableTotalPrice);



            GridModelMapper.Configuration.SetGlobalNullAlias<NullAlias>();

        }



        private class NullAlias : INullAlias

        {

            public bool IsCaseInsensitive { get { return true; } }



            //the query should contain these aliases explicitly?

            public bool SearchExplicit { get { return false; } }



            public IList<object> Aliases()

            {

                return new object[] { "NoNe", "eMpTy", -1, null };

            }

        }



        #region ExpressionCases



        // ReSharper disable InconsistentNaming

        // ReSharper disable NegativeEqualityExpression

        static readonly Expression<Func<Foo, bool>> Exp_NullableIsEqualTo = foo => foo.NullableDecimal == null;

        static readonly Expression<Func<Foo, bool>> Exp_IsEqualTo = foo => foo.Name == null;

        static readonly Expression<Func<Foo, bool>> Exp_IsNotEqualTo = foo => !(foo.Name == null);

        static readonly Expression<Func<Foo, bool>> Exp_NotValidAliasIsEqualTo = foo => foo.Name == "value";

        static readonly Expression<Func<Foo, bool>> Exp_NotValidAliasIsNotEqualTo = foo => foo.Name != "value";

        static readonly Expression<Func<Foo, bool>> Exp_NotNullableWithNullValueIsEqualTo = foo => foo.NotNullableDecimal == 0;

        static readonly Expression<Func<Foo, bool>> Exp_NotNullableWithNullValueIsNotEqualTo = foo => foo.NotNullableDecimal != 0;

        static readonly Expression<Func<Foo, bool>> Exp_NotNullableIsEqualTo = foo => foo.NotNullableDecimal == -1;

        static readonly Expression<Func<Foo, bool>> Exp_NotNullableIsNotEqualTo = foo => foo.NotNullableDecimal != -1;

        static readonly Expression<Func<Foo, bool>> Exp_NotNullableValidValueIsEqualTo = foo => foo.NotNullableDecimal == 10;

        static readonly Expression<Func<Foo, bool>> Exp_NotNullableValidValueIsNotEqualTo = foo => foo.NotNullableDecimal != 10;



        static readonly object[] ExpressionCases =

        {

            new object[] { "NullableDecimal", FilterOperator.IsLessThan, Exp_NullableIsEqualTo, null },

            new object[] { "NullableDecimal", FilterOperator.IsLessThan, Exp_NullableIsEqualTo, -1 },

            new object[] { "NullableDecimal", FilterOperator.IsLessThanOrEqualTo, Exp_NullableIsEqualTo, null },

            new object[] { "NullableDecimal", FilterOperator.IsLessThanOrEqualTo, Exp_NullableIsEqualTo, -1 },

            new object[] { "NullableDecimal", FilterOperator.IsGreaterThanOrEqualTo, Exp_NullableIsEqualTo, null },

            new object[] { "NullableDecimal", FilterOperator.IsGreaterThanOrEqualTo, Exp_NullableIsEqualTo, -1 },

            new object[] { "NullableDecimal", FilterOperator.IsGreaterThan, Exp_NullableIsEqualTo, null },

            new object[] { "NullableDecimal", FilterOperator.IsGreaterThan, Exp_NullableIsEqualTo, -1 },



            new object[] { "NotNullableDecimal", FilterOperator.IsEqualTo, Exp_NotNullableWithNullValueIsEqualTo, null },

            new object[] { "NotNullableDecimal", FilterOperator.IsNotEqualTo, Exp_NotNullableWithNullValueIsNotEqualTo, null },

            new object[] { "NotNullableDecimal", FilterOperator.IsEqualTo, Exp_NotNullableIsEqualTo, -1 },

            new object[] { "NotNullableDecimal", FilterOperator.IsNotEqualTo, Exp_NotNullableIsNotEqualTo, -1 },

            new object[] { "NotNullableDecimal", FilterOperator.IsEqualTo, Exp_NotNullableValidValueIsEqualTo, 10 },

            new object[] { "NotNullableDecimal", FilterOperator.IsNotEqualTo, Exp_NotNullableValidValueIsNotEqualTo, 10 },

            new object[] { "NotNullableDecimal", FilterOperator.IsEqualTo, Exp_NotNullableWithNullValueIsEqualTo, "none" },

            new object[] { "NotNullableDecimal", FilterOperator.IsNotEqualTo, Exp_NotNullableWithNullValueIsNotEqualTo, "none" },

            new object[] { "NotNullableDecimal", FilterOperator.IsEqualTo, Exp_NotNullableWithNullValueIsEqualTo, "invalid-value" },

            new object[] { "NotNullableDecimal", FilterOperator.IsNotEqualTo, Exp_NotNullableWithNullValueIsNotEqualTo, "invalid-value" },



            new object[] { "Name", FilterOperator.StartsWith, Exp_IsEqualTo, "none" },

            new object[] { "Name", FilterOperator.EndsWith, Exp_IsEqualTo, "none" },

            new object[] { "Name", FilterOperator.Contains, Exp_IsEqualTo, "none" },

            new object[] { "Name", FilterOperator.DoesNotContain, Exp_IsNotEqualTo, "none" },



            new object[] { "Name", FilterOperator.IsEqualTo, Exp_IsEqualTo, null },

            new object[] { "Name", FilterOperator.IsNotEqualTo, Exp_IsNotEqualTo, null },

            new object[] { "Name", FilterOperator.IsEqualTo, Exp_IsEqualTo, "none" },

            new object[] { "Name", FilterOperator.IsEqualTo, Exp_IsEqualTo, "nOnE" },

            new object[] { "Name", FilterOperator.IsEqualTo, Exp_IsEqualTo, "empty" },

            new object[] { "Name", FilterOperator.IsNotEqualTo, Exp_IsNotEqualTo, "none" },

            new object[] { "Name", FilterOperator.IsNotEqualTo, Exp_IsNotEqualTo, "empty" },

            new object[] { "Name", FilterOperator.IsEqualTo, Exp_NotValidAliasIsEqualTo, "value" },

            new object[] { "Name", FilterOperator.IsNotEqualTo, Exp_NotValidAliasIsNotEqualTo, "value" }

        };

        // ReSharper restore NegativeEqualityExpression

        // ReSharper restore InconsistentNaming



        #endregion



        [TestCaseSource("ExpressionCases")]

        public void single_expressions(string member, FilterOperator @operator, Expression<Func<Foo, bool>> exp, object value)

        {

            var filter = new FilterDescriptor(member, @operator, value);

            var expressionWhereClause = new ExpressionWhereClause<Foo, FooModel>(filter, null, false, null);



            expressionWhereClause.Predicate.ToString()

                .Replace("Tests.DynamicWhereClause.ExpressionWhereClauseWithNullAliasAndCaseInsensitiveTests+Foo", "foo")

                .Should().Be(exp.ToString().Replace(".Value", ""));

        }



        [TestCaseSource("ExpressionCases")]

        public void double_expressions_with_orElse_operator(string member, FilterOperator @operator, Expression<Func<Foo, bool>> exp, object value)

        {

            var filter = new FilterDescriptor(member, @operator, value);

            var expressionWhereClause = new ExpressionWhereClause<Foo, FooModel>(filter, null, false, null);



            expressionWhereClause.Predicate.ToString()

                .Replace("Tests.DynamicWhereClause.ExpressionWhereClauseWithNullAliasAndCaseInsensitiveTests+Foo", "foo")

                .Should().Be(exp.ToString().Replace(".Value", ""));



            expressionWhereClause.OrElse(expressionWhereClause);



            expressionWhereClause.Predicate.ToString()

                .Replace("Tests.DynamicWhereClause.ExpressionWhereClauseWithNullAliasAndCaseInsensitiveTests+Foo", "foo")

                .Should().Be(exp.OrElse(exp).ToString().Replace(".Value", ""));

        }



        [TestCaseSource("ExpressionCases")]

        public void double_expressions_with_andAlso_operator(string member, FilterOperator @operator, Expression<Func<Foo, bool>> exp, object value)

        {

            var filter = new FilterDescriptor(member, @operator, value);

            var expressionWhereClause = new ExpressionWhereClause<Foo, FooModel>(filter, null, false, null);



            expressionWhereClause.Predicate.ToString()

                .Replace("Tests.DynamicWhereClause.ExpressionWhereClauseWithNullAliasAndCaseInsensitiveTests+Foo", "foo")

                .Should().Be(exp.ToString().Replace(".Value", ""));



            expressionWhereClause.AndAlso(expressionWhereClause);



            expressionWhereClause.Predicate.ToString()

                .Replace("Tests.DynamicWhereClause.ExpressionWhereClauseWithNullAliasAndCaseInsensitiveTests+Foo", "foo")

                .Should().Be(exp.AndAlso(exp).ToString().Replace(".Value", ""));

        }



        #region CustomExpression_Cases



        // ReSharper disable InconsistentNaming

        // ReSharper disable NegativeEqualityExpression

        static readonly Expression<Func<Foo, bool>> CustomExpression_NullableIsEqualTo = foo => foo.NullableDecimal + foo.NullableDecimal == null;

        static readonly Expression<Func<Foo, bool>> CustomExpression_IsEqualTo = foo => foo.FirstName + " " + foo.LastName == null;

        static readonly Expression<Func<Foo, bool>> CustomExpression_IsNotEqualTo = foo => !(foo.FirstName + " " + foo.LastName == null);

        static readonly Expression<Func<Foo, bool>> CustomExpression_NotValidAliasIsEqualTo = foo => foo.FirstName + " " + foo.LastName == "value";

        static readonly Expression<Func<Foo, bool>> CustomExpression_NotValidAliasIsNotEqualTo = foo => foo.FirstName + " " + foo.LastName != "value";

        static readonly Expression<Func<Foo, bool>> CustomExpression_NotNullableWithNullValueIsEqualTo = foo => foo.NotNullableDecimal + foo.NotNullableDecimal == 0;

        static readonly Expression<Func<Foo, bool>> CustomExpression_NotNullableWithNullValueIsNotEqualTo = foo => foo.NotNullableDecimal + foo.NotNullableDecimal != 0;

        static readonly Expression<Func<Foo, bool>> CustomExpression_NotNullableIsEqualTo = foo => foo.NotNullableDecimal + foo.NotNullableDecimal == -1;

        static readonly Expression<Func<Foo, bool>> CustomExpression_NotNullableIsNotEqualTo = foo => foo.NotNullableDecimal + foo.NotNullableDecimal != -1;

        static readonly Expression<Func<Foo, bool>> CustomExpression_NotNullableValidValueIsEqualTo = foo => foo.NotNullableDecimal + foo.NotNullableDecimal == 10;

        static readonly Expression<Func<Foo, bool>> CustomExpression_NotNullableValidValueIsNotEqualTo = foo => foo.NotNullableDecimal + foo.NotNullableDecimal != 10;



        static readonly object[] CustomExpression_Cases =

        {

            new object[] { "NullableTotalPrice", FilterOperator.IsLessThan, CustomExpression_NullableIsEqualTo, null },

            new object[] { "NullableTotalPrice", FilterOperator.IsLessThan, CustomExpression_NullableIsEqualTo, -1 },

            new object[] { "NullableTotalPrice", FilterOperator.IsLessThanOrEqualTo, CustomExpression_NullableIsEqualTo, null },

            new object[] { "NullableTotalPrice", FilterOperator.IsLessThanOrEqualTo, CustomExpression_NullableIsEqualTo, -1 },

            new object[] { "NullableTotalPrice", FilterOperator.IsGreaterThanOrEqualTo, CustomExpression_NullableIsEqualTo, null },

            new object[] { "NullableTotalPrice", FilterOperator.IsGreaterThanOrEqualTo, CustomExpression_NullableIsEqualTo, -1 },

            new object[] { "NullableTotalPrice", FilterOperator.IsGreaterThan, CustomExpression_NullableIsEqualTo, null },

            new object[] { "NullableTotalPrice", FilterOperator.IsGreaterThan, CustomExpression_NullableIsEqualTo, -1 },



            new object[] { "NotNullableTotalPrice", FilterOperator.IsEqualTo, CustomExpression_NotNullableWithNullValueIsEqualTo, null },

            new object[] { "NotNullableTotalPrice", FilterOperator.IsNotEqualTo, CustomExpression_NotNullableWithNullValueIsNotEqualTo, null },

            new object[] { "NotNullableTotalPrice", FilterOperator.IsEqualTo, CustomExpression_NotNullableIsEqualTo, -1 },

            new object[] { "NotNullableTotalPrice", FilterOperator.IsNotEqualTo, CustomExpression_NotNullableIsNotEqualTo, -1 },

            new object[] { "NotNullableTotalPrice", FilterOperator.IsEqualTo, CustomExpression_NotNullableValidValueIsEqualTo, 10 },

            new object[] { "NotNullableTotalPrice", FilterOperator.IsNotEqualTo, CustomExpression_NotNullableValidValueIsNotEqualTo, 10 },

            new object[] { "NotNullableTotalPrice", FilterOperator.IsEqualTo, CustomExpression_NotNullableWithNullValueIsEqualTo, "none" },

            new object[] { "NotNullableTotalPrice", FilterOperator.IsNotEqualTo, CustomExpression_NotNullableWithNullValueIsNotEqualTo, "none" },

            new object[] { "NotNullableTotalPrice", FilterOperator.IsEqualTo, CustomExpression_NotNullableWithNullValueIsEqualTo, "invalid-value" },

            new object[] { "NotNullableTotalPrice", FilterOperator.IsNotEqualTo, CustomExpression_NotNullableWithNullValueIsNotEqualTo, "invalid-value" },



            new object[] { "FullName", FilterOperator.StartsWith, CustomExpression_IsEqualTo, "none" },

            new object[] { "FullName", FilterOperator.EndsWith, CustomExpression_IsEqualTo, "none" },

            new object[] { "FullName", FilterOperator.Contains, CustomExpression_IsEqualTo, "none" },

            new object[] { "FullName", FilterOperator.DoesNotContain, CustomExpression_IsNotEqualTo, "none" },



            new object[] { "FullName", FilterOperator.IsEqualTo, CustomExpression_IsEqualTo, null },

            new object[] { "FullName", FilterOperator.IsNotEqualTo, CustomExpression_IsNotEqualTo, null },

            new object[] { "FullName", FilterOperator.IsEqualTo, CustomExpression_IsEqualTo, "none" },

            new object[] { "FullName", FilterOperator.IsEqualTo, CustomExpression_IsEqualTo, "nOnE" },

            new object[] { "FullName", FilterOperator.IsEqualTo, CustomExpression_IsEqualTo, "empty" },

            new object[] { "FullName", FilterOperator.IsNotEqualTo, CustomExpression_IsNotEqualTo, "none" },

            new object[] { "FullName", FilterOperator.IsNotEqualTo, CustomExpression_IsNotEqualTo, "empty" },

            new object[] { "FullName", FilterOperator.IsEqualTo, CustomExpression_NotValidAliasIsEqualTo, "value" },

            new object[] { "FullName", FilterOperator.IsNotEqualTo, CustomExpression_NotValidAliasIsNotEqualTo, "value" }

        };

        // ReSharper restore NegativeEqualityExpression

        // ReSharper restore InconsistentNaming



        #endregion

        

        [TestCaseSource("CustomExpression_Cases")]

        public void single_expressions_with_gridModelMapper_customExpression(string member, FilterOperator @operator, Expression<Func<Foo, bool>> exp, object value)

        {

            var filter = new FilterDescriptor(member, @operator, value);



            var expressionWhereClause = new ExpressionWhereClause<Foo, FooModel>(filter, null, false, null);



            expressionWhereClause.Predicate.ToString()

                .Replace("Tests.DynamicWhereClause.ExpressionWhereClauseWithNullAliasAndCaseInsensitiveTests+Foo", "foo")

                .Should().Be(exp.ToString());

        }



        [TestCaseSource("CustomExpression_Cases")]

        public void double_expressions_with_gridModelMapper_customExpression_and_orElse_operator(string member, FilterOperator @operator, Expression<Func<Foo, bool>> exp, object value)

        {

            var filter = new FilterDescriptor(member, @operator, value);

            var expressionWhereClause = new ExpressionWhereClause<Foo, FooModel>(filter, null, false, null);



            expressionWhereClause.Predicate.ToString()

                .Replace("Tests.DynamicWhereClause.ExpressionWhereClauseWithNullAliasAndCaseInsensitiveTests+Foo", "foo")

                .Should().Be(exp.ToString());



            expressionWhereClause.OrElse(expressionWhereClause);



            expressionWhereClause.Predicate.ToString()

                .Replace("Tests.DynamicWhereClause.ExpressionWhereClauseWithNullAliasAndCaseInsensitiveTests+Foo", "foo")

                .Should().Be(exp.OrElse(exp).ToString());

        }



        [TestCaseSource("CustomExpression_Cases")]

        public void double_expressions_with_gridModelMapper_customExpression_and_andAlso_operator(string member, FilterOperator @operator, Expression<Func<Foo, bool>> exp, object value)

        {

            var filter = new FilterDescriptor(member, @operator, value);

            var expressionWhereClause = new ExpressionWhereClause<Foo, FooModel>(filter, null, false, null);



            expressionWhereClause.Predicate.ToString()

                .Replace("Tests.DynamicWhereClause.ExpressionWhereClauseWithNullAliasAndCaseInsensitiveTests+Foo", "foo")

                .Should().Be(exp.ToString());



            expressionWhereClause.AndAlso(expressionWhereClause);



            expressionWhereClause.Predicate.ToString()

                .Replace("Tests.DynamicWhereClause.ExpressionWhereClauseWithNullAliasAndCaseInsensitiveTests+Foo", "foo")

                .Should().Be(exp.AndAlso(exp).ToString());

        }



        #region Test models



        // ReSharper disable ClassNeverInstantiated.Global

        // ReSharper disable UnusedAutoPropertyAccessor.Global

        // ReSharper disable ClassNeverInstantiated.Local

        // ReSharper disable UnusedAutoPropertyAccessor.Local

        // ReSharper disable UnusedMember.Local

        // ReSharper disable UnusedMember.Global

        public class Foo

        {

            public string Name { get; set; }

            public decimal? NullableDecimal { get; set; }

            public decimal NotNullableDecimal { get; set; }

            public DateTime DateTime { get; set; }

            public string FirstName { get; set; }

            public string LastName { get; set; }

        }



        private class FooModel

        {

            public string Name { get; set; }

            public decimal? NullableDecimal { get; set; }

            public decimal NotNullableDecimal { get; set; }

            public DateTime DateTime { get; set; }

            public string FullName { get; set; }

            public string NullableTotalPrice { get; set; }

            public decimal NotNullableTotalPrice { get; set; }

        }

        // ReSharper restore UnusedMember.Global

        // ReSharper restore UnusedMember.Local

        // ReSharper restore UnusedAutoPropertyAccessor.Local

        // ReSharper restore ClassNeverInstantiated.Local

        // ReSharper restore UnusedAutoPropertyAccessor.Global

        // ReSharper restore ClassNeverInstantiated.Global



        #endregion

    }



    public class ExpressionWhereClauseWithAcceptNullValuesAndCaseInsensitiveTests

    {

        [SetUp]

        public void SetUp()

        {

            Mapper.Reset();

            GridModelMapper.Reset();

            GridModelMapper.CreateMap<Foo, FooModel>()

                .MapProperty(foo => foo.FirstName + " " + foo.LastName, model => model.FullName)

                .MapProperty(foo => foo.NullableDecimal + foo.NullableDecimal, model => model.TotalPrice);

        }



        #region ExpressionCases



        // ReSharper disable InconsistentNaming

        static readonly Expression<Func<Foo, bool>> Exp_IsLessThan = foo => foo.NullableDecimal == null || foo.NullableDecimal.Value < 5;

        static readonly Expression<Func<Foo, bool>> Exp_IsLessThanOrEqualTo = foo => foo.NullableDecimal == null || foo.NullableDecimal.Value <= 5;

        static readonly Expression<Func<Foo, bool>> Exp_IsGreaterThanOrEqualTo = foo => foo.NullableDecimal == null || foo.NullableDecimal.Value >= 5;

        static readonly Expression<Func<Foo, bool>> Exp_IsGreaterThan = foo => foo.NullableDecimal == null || foo.NullableDecimal.Value > 5;

        static readonly Expression<Func<Foo, bool>> Exp_StartsWith = foo => foo.Name == null || foo.Name.ToLowerInvariant().StartsWith("luis");

        static readonly Expression<Func<Foo, bool>> Exp_EndsWith = foo => foo.Name == null || foo.Name.ToLowerInvariant().EndsWith("luis");

        static readonly Expression<Func<Foo, bool>> Exp_Contains = foo => foo.Name == null || foo.Name.ToLowerInvariant().Contains("luis");

        static readonly Expression<Func<Foo, bool>> Exp_DoesNotContains = foo => foo.Name == null || !foo.Name.ToLowerInvariant().Contains("luis");

        static readonly Expression<Func<Foo, bool>> Exp_IsEqualTo = foo => foo.Name == null || foo.Name.ToLowerInvariant() == "luis";

        static readonly Expression<Func<Foo, bool>> Exp_IsNotEqualTo = foo => foo.Name == null || foo.Name.ToLowerInvariant() != "luis";

        static readonly Expression<Func<Foo, bool>> Exp_NullLiteralIsEqualTo = foo => foo.Name == null;

        static readonly Expression<Func<Foo, bool>> Exp_NullLiteralIsNotEqualTo = foo => foo.Name != null;



        static readonly object[] ExpressionCases =

        {

            new object[] { "NullableDecimal", FilterOperator.IsLessThan, Exp_IsLessThan, 5 },

            new object[] { "NullableDecimal", FilterOperator.IsLessThanOrEqualTo, Exp_IsLessThanOrEqualTo, "5" },

            new object[] { "NullableDecimal", FilterOperator.IsGreaterThanOrEqualTo, Exp_IsGreaterThanOrEqualTo, "5" },

            new object[] { "NullableDecimal", FilterOperator.IsGreaterThan, Exp_IsGreaterThan, "5" },

            new object[] { "Name", FilterOperator.StartsWith, Exp_StartsWith, "Luis" },

            new object[] { "Name", FilterOperator.EndsWith, Exp_EndsWith, "Luis" },

            new object[] { "Name", FilterOperator.Contains, Exp_Contains, "Luis" },

            new object[] { "Name", FilterOperator.DoesNotContain, Exp_DoesNotContains, "Luis" },

            new object[] { "Name", FilterOperator.IsEqualTo, Exp_IsEqualTo, "Luis" },

            new object[] { "Name", FilterOperator.IsNotEqualTo, Exp_IsNotEqualTo, "Luis" },

            new object[] { "Name", FilterOperator.IsNotEqualTo, Exp_NullLiteralIsNotEqualTo, null },

            new object[] { "Name", FilterOperator.IsEqualTo, Exp_NullLiteralIsEqualTo, null }

        };

        // ReSharper restore InconsistentNaming



        #endregion



        [TestCaseSource("ExpressionCases")]

        public void single_expressions(string member, FilterOperator @operator, Expression<Func<Foo, bool>> exp, object value)

        {

            var filter = new FilterDescriptor(member, @operator, value);

            var expressionWhereClause = new ExpressionWhereClause<Foo, FooModel>(filter, new CaseInsensitive<Foo>(true, true), true, null);



            expressionWhereClause.Predicate.ToString().Replace("Tests.Entity.Foo", "foo").Should().Be(exp.ToString().Replace(".Value", ""));

        }



        [TestCaseSource("ExpressionCases")]

        public void double_expressions_with_orElse_operator(string member, FilterOperator @operator, Expression<Func<Foo, bool>> exp, object value)

        {

            var filter = new FilterDescriptor(member, @operator, value);

            var expressionWhereClause = new ExpressionWhereClause<Foo, FooModel>(filter, new CaseInsensitive<Foo>(true, true), true, null);



            expressionWhereClause.Predicate.ToString().Replace("Tests.Entity.Foo", "foo").Should().Be(exp.ToString().Replace(".Value", ""));



            expressionWhereClause.OrElse(expressionWhereClause);



            expressionWhereClause.Predicate.ToString().Replace("Tests.Entity.Foo", "foo").Should().Be(exp.OrElse(exp).ToString().Replace(".Value", ""));

        }



        [TestCaseSource("ExpressionCases")]

        public void double_expressions_with_andAlso_operator(string member, FilterOperator @operator, Expression<Func<Foo, bool>> exp, object value)

        {

            var filter = new FilterDescriptor(member, @operator, value);

            var expressionWhereClause = new ExpressionWhereClause<Foo, FooModel>(filter, new CaseInsensitive<Foo>(true, true), true, null);



            expressionWhereClause.Predicate.ToString().Replace("Tests.Entity.Foo", "foo").Should().Be(exp.ToString().Replace(".Value", ""));



            expressionWhereClause.AndAlso(expressionWhereClause);



            expressionWhereClause.Predicate.ToString().Replace("Tests.Entity.Foo", "foo").Should().Be(exp.AndAlso(exp).ToString().Replace(".Value", ""));

        }



        #region CustomExpression_Cases



        // ReSharper disable InconsistentNaming

        static readonly Expression<Func<Foo, bool>> CustomExpression_IsLessThan = foo => (foo.NullableDecimal + foo.NullableDecimal) == null || foo.NullableDecimal + foo.NullableDecimal < 5;

        static readonly Expression<Func<Foo, bool>> CustomExpression_IsLessThanOrEqualTo = foo => (foo.NullableDecimal + foo.NullableDecimal) == null || foo.NullableDecimal + foo.NullableDecimal <= 5;

        static readonly Expression<Func<Foo, bool>> CustomExpression_IsGreaterThanOrEqualTo = foo => (foo.NullableDecimal + foo.NullableDecimal) == null || foo.NullableDecimal + foo.NullableDecimal >= 5;

        static readonly Expression<Func<Foo, bool>> CustomExpression_IsGreaterThan = foo => (foo.NullableDecimal + foo.NullableDecimal) == null || foo.NullableDecimal + foo.NullableDecimal > 5;

        static readonly Expression<Func<Foo, bool>> CustomExpression_StartsWith = foo => (foo.FirstName + " " + foo.LastName) == null || (foo.FirstName + " " + foo.LastName).ToLowerInvariant().StartsWith("luis fernando");

        static readonly Expression<Func<Foo, bool>> CustomExpression_EndsWith = foo => (foo.FirstName + " " + foo.LastName) == null || (foo.FirstName + " " + foo.LastName).ToLowerInvariant().EndsWith("luis fernando");

        static readonly Expression<Func<Foo, bool>> CustomExpression_Contains = foo => (foo.FirstName + " " + foo.LastName) == null || (foo.FirstName + " " + foo.LastName).ToLowerInvariant().Contains("luis fernando");

        static readonly Expression<Func<Foo, bool>> CustomExpression_DoesNotContains = foo => (foo.FirstName + " " + foo.LastName) == null || !(foo.FirstName + " " + foo.LastName).ToLowerInvariant().Contains("luis fernando");

        static readonly Expression<Func<Foo, bool>> CustomExpression_IsEqualTo = foo => (foo.FirstName + " " + foo.LastName) == null || (foo.FirstName + " " + foo.LastName).ToLowerInvariant() == "luis fernando";

        static readonly Expression<Func<Foo, bool>> CustomExpression_IsNotEqualTo = foo => (foo.FirstName + " " + foo.LastName) == null || (foo.FirstName + " " + foo.LastName).ToLowerInvariant() != "luis fernando";

        static readonly Expression<Func<Foo, bool>> CustomExpression_NullLiteralIsEqualTo = foo => foo.FirstName + " " + foo.LastName == null;

        static readonly Expression<Func<Foo, bool>> CustomExpression_NullLiteralIsNotEqualTo = foo => foo.FirstName + " " + foo.LastName != null;



        static readonly object[] CustomExpression_Cases =

        {

            new object[] { "TotalPrice", FilterOperator.IsLessThan, CustomExpression_IsLessThan, 5 },

            new object[] { "TotalPrice", FilterOperator.IsLessThanOrEqualTo, CustomExpression_IsLessThanOrEqualTo, "5" },

            new object[] { "TotalPrice", FilterOperator.IsGreaterThanOrEqualTo, CustomExpression_IsGreaterThanOrEqualTo, "5" },

            new object[] { "TotalPrice", FilterOperator.IsGreaterThan, CustomExpression_IsGreaterThan, "5" },

            new object[] { "FullName", FilterOperator.StartsWith, CustomExpression_StartsWith, "Luis Fernando" },

            new object[] { "FullName", FilterOperator.EndsWith, CustomExpression_EndsWith, "Luis Fernando" },

            new object[] { "FullName", FilterOperator.Contains, CustomExpression_Contains, "Luis Fernando" },

            new object[] { "FullName", FilterOperator.DoesNotContain, CustomExpression_DoesNotContains, "Luis Fernando" },

            new object[] { "FullName", FilterOperator.IsEqualTo, CustomExpression_IsEqualTo, "Luis Fernando" },

            new object[] { "FullName", FilterOperator.IsNotEqualTo, CustomExpression_IsNotEqualTo, "Luis Fernando" },

            new object[] { "FullName", FilterOperator.IsEqualTo, CustomExpression_NullLiteralIsEqualTo, null },

            new object[] { "FullName", FilterOperator.IsNotEqualTo, CustomExpression_NullLiteralIsNotEqualTo, null }

        };

        // ReSharper restore InconsistentNaming



        #endregion



        [TestCaseSource("CustomExpression_Cases")]

        public void single_expressions_with_gridModelMapper_customExpression(string member, FilterOperator @operator, Expression<Func<Foo, bool>> exp, object value)

        {

            var filter = new FilterDescriptor(member, @operator, value);



            var expressionWhereClause = new ExpressionWhereClause<Foo, FooModel>(filter, new CaseInsensitive<Foo>(true, true), true, null);



            expressionWhereClause.Predicate.ToString().Should().Be(exp.ToString().Replace("Convert(5)", "5"));

        }



        [TestCaseSource("CustomExpression_Cases")]

        public void double_expressions_with_gridModelMapper_customExpression_and_orElse_operator(string member, FilterOperator @operator, Expression<Func<Foo, bool>> exp, object value)

        {

            var filter = new FilterDescriptor(member, @operator, value);

            var expressionWhereClause = new ExpressionWhereClause<Foo, FooModel>(filter, new CaseInsensitive<Foo>(true, true), true, null);



            expressionWhereClause.Predicate.ToString().Should().Be(exp.ToString().Replace("Convert(5)", "5"));



            expressionWhereClause.OrElse(expressionWhereClause);



            expressionWhereClause.Predicate.ToString().Should().Be(exp.OrElse(exp).ToString().Replace("Convert(5)", "5"));

        }



        [TestCaseSource("CustomExpression_Cases")]

        public void double_expressions_with_gridModelMapper_customExpression_and_andAlso_operator(string member, FilterOperator @operator, Expression<Func<Foo, bool>> exp, object value)

        {

            var filter = new FilterDescriptor(member, @operator, value);

            var expressionWhereClause = new ExpressionWhereClause<Foo, FooModel>(filter, new CaseInsensitive<Foo>(true, true), true, null);



            expressionWhereClause.Predicate.ToString().Should().Be(exp.ToString().Replace("Convert(5)", "5"));



            expressionWhereClause.AndAlso(expressionWhereClause);



            expressionWhereClause.Predicate.ToString().Should().Be(exp.AndAlso(exp).ToString().Replace("Convert(5)", "5"));

        }

    }



    public class ExpressionWhereClauseWithAcceptNullValuesTests

    {

        [SetUp]

        public void SetUp()

        {

            Mapper.Reset();

            GridModelMapper.Reset();

            GridModelMapper.CreateMap<Foo, FooModel>()

                .MapProperty(foo => foo.FirstName + " " + foo.LastName, model => model.FullName)

                .MapProperty(foo => foo.NullableDecimal + foo.NullableDecimal, model => model.TotalPrice);

        }



        #region ExpressionCases



        // ReSharper disable InconsistentNaming

        static readonly Expression<Func<Foo, bool>> Exp_IsLessThan = foo => foo.NullableDecimal == null || foo.NullableDecimal.Value < 5;

        static readonly Expression<Func<Foo, bool>> Exp_IsLessThanOrEqualTo = foo => foo.NullableDecimal == null || foo.NullableDecimal.Value <= 5;

        static readonly Expression<Func<Foo, bool>> Exp_IsGreaterThanOrEqualTo = foo => foo.NullableDecimal == null || foo.NullableDecimal.Value >= 5;

        static readonly Expression<Func<Foo, bool>> Exp_IsGreaterThan = foo => foo.NullableDecimal == null || foo.NullableDecimal.Value > 5;

        static readonly Expression<Func<Foo, bool>> Exp_StartsWith = foo => foo.Name == null || foo.Name.StartsWith("Luis");

        static readonly Expression<Func<Foo, bool>> Exp_EndsWith = foo => foo.Name == null || foo.Name.EndsWith("Luis");

        static readonly Expression<Func<Foo, bool>> Exp_Contains = foo => foo.Name == null || foo.Name.Contains("Luis");

        static readonly Expression<Func<Foo, bool>> Exp_DoesNotContains = foo => foo.Name == null || !foo.Name.Contains("Luis");

        static readonly Expression<Func<Foo, bool>> Exp_IsEqualTo = foo => foo.Name == null || foo.Name == "Luis";

        static readonly Expression<Func<Foo, bool>> Exp_IsNotEqualTo = foo => foo.Name == null || foo.Name != "Luis";

        static readonly Expression<Func<Foo, bool>> Exp_NullLiteralIsEqualTo = foo => foo.Name == null;

        static readonly Expression<Func<Foo, bool>> Exp_NullLiteralIsNotEqualTo = foo => foo.Name != null;



        static readonly object[] ExpressionCases =

        {

            new object[] { "NullableDecimal", FilterOperator.IsLessThan, Exp_IsLessThan, 5 },

            new object[] { "NullableDecimal", FilterOperator.IsLessThanOrEqualTo, Exp_IsLessThanOrEqualTo, "5" },

            new object[] { "NullableDecimal", FilterOperator.IsGreaterThanOrEqualTo, Exp_IsGreaterThanOrEqualTo, "5" },

            new object[] { "NullableDecimal", FilterOperator.IsGreaterThan, Exp_IsGreaterThan, "5" },

            new object[] { "Name", FilterOperator.StartsWith, Exp_StartsWith, "Luis" },

            new object[] { "Name", FilterOperator.EndsWith, Exp_EndsWith, "Luis" },

            new object[] { "Name", FilterOperator.Contains, Exp_Contains, "Luis" },

            new object[] { "Name", FilterOperator.DoesNotContain, Exp_DoesNotContains, "Luis" },

            new object[] { "Name", FilterOperator.IsEqualTo, Exp_IsEqualTo, "Luis" },

            new object[] { "Name", FilterOperator.IsNotEqualTo, Exp_IsNotEqualTo, "Luis" },

            new object[] { "Name", FilterOperator.IsNotEqualTo, Exp_NullLiteralIsNotEqualTo, null },

            new object[] { "Name", FilterOperator.IsEqualTo, Exp_NullLiteralIsEqualTo, null }

        };

        // ReSharper restore InconsistentNaming



        #endregion



        [TestCaseSource("ExpressionCases")]

        public void single_expressions(string member, FilterOperator @operator, Expression<Func<Foo, bool>> exp, object value)

        {

            var filter = new FilterDescriptor(member, @operator, value);

            var expressionWhereClause = new ExpressionWhereClause<Foo, FooModel>(filter, null, true, null);



            expressionWhereClause.Predicate.ToString().Replace("Tests.Entity.Foo", "foo").Should().Be(exp.ToString().Replace(".Value", ""));

        }



        [TestCaseSource("ExpressionCases")]

        public void double_expressions_with_orElse_operator(string member, FilterOperator @operator, Expression<Func<Foo, bool>> exp, object value)

        {

            var filter = new FilterDescriptor(member, @operator, value);

            var expressionWhereClause = new ExpressionWhereClause<Foo, FooModel>(filter, null, true, null);



            expressionWhereClause.Predicate.ToString().Replace("Tests.Entity.Foo", "foo").Should().Be(exp.ToString().Replace(".Value", ""));



            expressionWhereClause.OrElse(expressionWhereClause);



            expressionWhereClause.Predicate.ToString().Replace("Tests.Entity.Foo", "foo").Should().Be(exp.OrElse(exp).ToString().Replace(".Value", ""));

        }



        [TestCaseSource("ExpressionCases")]

        public void double_expressions_with_andAlso_operator(string member, FilterOperator @operator, Expression<Func<Foo, bool>> exp, object value)

        {

            var filter = new FilterDescriptor(member, @operator, value);

            var expressionWhereClause = new ExpressionWhereClause<Foo, FooModel>(filter, null, true, null);



            expressionWhereClause.Predicate.ToString().Replace("Tests.Entity.Foo", "foo").Should().Be(exp.ToString().Replace(".Value", ""));



            expressionWhereClause.AndAlso(expressionWhereClause);



            expressionWhereClause.Predicate.ToString().Replace("Tests.Entity.Foo", "foo").Should().Be(exp.AndAlso(exp).ToString().Replace(".Value", ""));

        }



        #region CustomExpression_Cases



        // ReSharper disable InconsistentNaming

        static readonly Expression<Func<Foo, bool>> CustomExpression_IsLessThan = foo => (foo.NullableDecimal + foo.NullableDecimal) == null || foo.NullableDecimal + foo.NullableDecimal < 5;

        static readonly Expression<Func<Foo, bool>> CustomExpression_IsLessThanOrEqualTo = foo => (foo.NullableDecimal + foo.NullableDecimal) == null || foo.NullableDecimal + foo.NullableDecimal <= 5;

        static readonly Expression<Func<Foo, bool>> CustomExpression_IsGreaterThanOrEqualTo = foo => (foo.NullableDecimal + foo.NullableDecimal) == null || foo.NullableDecimal + foo.NullableDecimal >= 5;

        static readonly Expression<Func<Foo, bool>> CustomExpression_IsGreaterThan = foo => (foo.NullableDecimal + foo.NullableDecimal) == null || foo.NullableDecimal + foo.NullableDecimal > 5;

        static readonly Expression<Func<Foo, bool>> CustomExpression_StartsWith = foo => (foo.FirstName + " " + foo.LastName) == null || (foo.FirstName + " " + foo.LastName).StartsWith("Luis Fernando");

        static readonly Expression<Func<Foo, bool>> CustomExpression_EndsWith = foo => (foo.FirstName + " " + foo.LastName) == null || (foo.FirstName + " " + foo.LastName).EndsWith("Luis Fernando");

        static readonly Expression<Func<Foo, bool>> CustomExpression_Contains = foo => (foo.FirstName + " " + foo.LastName) == null || (foo.FirstName + " " + foo.LastName).Contains("Luis Fernando");

        static readonly Expression<Func<Foo, bool>> CustomExpression_DoesNotContains = foo => (foo.FirstName + " " + foo.LastName) == null || !(foo.FirstName + " " + foo.LastName).Contains("Luis Fernando");

        static readonly Expression<Func<Foo, bool>> CustomExpression_IsEqualTo = foo => (foo.FirstName + " " + foo.LastName) == null || foo.FirstName + " " + foo.LastName == "Luis Fernando";

        static readonly Expression<Func<Foo, bool>> CustomExpression_IsNotEqualTo = foo => (foo.FirstName + " " + foo.LastName) == null || foo.FirstName + " " + foo.LastName != "Luis Fernando";

        static readonly Expression<Func<Foo, bool>> CustomExpression_NullLiteralIsEqualTo = foo => foo.FirstName + " " + foo.LastName == null;

        static readonly Expression<Func<Foo, bool>> CustomExpression_NullLiteralIsNotEqualTo = foo => foo.FirstName + " " + foo.LastName != null;



        static readonly object[] CustomExpression_Cases =

        {

            new object[] { "TotalPrice", FilterOperator.IsLessThan, CustomExpression_IsLessThan, 5 },

            new object[] { "TotalPrice", FilterOperator.IsLessThanOrEqualTo, CustomExpression_IsLessThanOrEqualTo, "5" },

            new object[] { "TotalPrice", FilterOperator.IsGreaterThanOrEqualTo, CustomExpression_IsGreaterThanOrEqualTo, "5" },

            new object[] { "TotalPrice", FilterOperator.IsGreaterThan, CustomExpression_IsGreaterThan, "5" },

            new object[] { "FullName", FilterOperator.StartsWith, CustomExpression_StartsWith, "Luis Fernando" },

            new object[] { "FullName", FilterOperator.EndsWith, CustomExpression_EndsWith, "Luis Fernando" },

            new object[] { "FullName", FilterOperator.Contains, CustomExpression_Contains, "Luis Fernando" },

            new object[] { "FullName", FilterOperator.DoesNotContain, CustomExpression_DoesNotContains, "Luis Fernando" },

            new object[] { "FullName", FilterOperator.IsEqualTo, CustomExpression_IsEqualTo, "Luis Fernando" },

            new object[] { "FullName", FilterOperator.IsNotEqualTo, CustomExpression_IsNotEqualTo, "Luis Fernando" },

            new object[] { "FullName", FilterOperator.IsEqualTo, CustomExpression_NullLiteralIsEqualTo, null },

            new object[] { "FullName", FilterOperator.IsNotEqualTo, CustomExpression_NullLiteralIsNotEqualTo, null }

        };

        // ReSharper restore InconsistentNaming



        #endregion



        [TestCaseSource("CustomExpression_Cases")]

        public void single_expressions_with_gridModelMapper_customExpression(string member, FilterOperator @operator, Expression<Func<Foo, bool>> exp, object value)

        {

            var filter = new FilterDescriptor(member, @operator, value);



            var expressionWhereClause = new ExpressionWhereClause<Foo, FooModel>(filter, null, true, null);



            expressionWhereClause.Predicate.ToString().Should().Be(exp.ToString().Replace("Convert(5)", "5"));

        }



        [TestCaseSource("CustomExpression_Cases")]

        public void double_expressions_with_gridModelMapper_customExpression_and_orElse_operator(string member, FilterOperator @operator, Expression<Func<Foo, bool>> exp, object value)

        {

            var filter = new FilterDescriptor(member, @operator, value);

            var expressionWhereClause = new ExpressionWhereClause<Foo, FooModel>(filter, null, true, null);



            expressionWhereClause.Predicate.ToString().Should().Be(exp.ToString().Replace("Convert(5)", "5"));



            expressionWhereClause.OrElse(expressionWhereClause);



            expressionWhereClause.Predicate.ToString().Should().Be(exp.OrElse(exp).ToString().Replace("Convert(5)", "5"));

        }



        [TestCaseSource("CustomExpression_Cases")]

        public void double_expressions_with_gridModelMapper_customExpression_and_andAlso_operator(string member, FilterOperator @operator, Expression<Func<Foo, bool>> exp, object value)

        {

            var filter = new FilterDescriptor(member, @operator, value);

            var expressionWhereClause = new ExpressionWhereClause<Foo, FooModel>(filter, null, true, null);



            expressionWhereClause.Predicate.ToString().Should().Be(exp.ToString().Replace("Convert(5)", "5"));



            expressionWhereClause.AndAlso(expressionWhereClause);



            expressionWhereClause.Predicate.ToString().Should().Be(exp.AndAlso(exp).ToString().Replace("Convert(5)", "5"));

        }

    }



    public class ExpressionWhereClauseWithCaseInsensitiveTests

    {

        [SetUp]

        public void SetUp()

        {

            Mapper.Reset();

            GridModelMapper.Reset();

            GridModelMapper.CreateMap<Foo, FooModel>()

                .MapProperty(foo => foo.FirstName + " " + foo.LastName, model => model.FullName)

                .MapProperty(foo => foo.UnitPrice + foo.UnitsInStock, model => model.TotalPrice);

        }



        #region ExpressionCases



        // ReSharper disable InconsistentNaming

        static readonly Expression<Func<Foo, bool>> Exp_IsLessThan = foo => foo.UnitPrice < 5;

        static readonly Expression<Func<Foo, bool>> Exp_IsLessThanOrEqualTo = foo => foo.UnitPrice <= 5;

        static readonly Expression<Func<Foo, bool>> Exp_IsGreaterThanOrEqualTo = foo => foo.UnitPrice >= 5;

        static readonly Expression<Func<Foo, bool>> Exp_IsGreaterThan = foo => foo.UnitPrice > 5;

        static readonly Expression<Func<Foo, bool>> Exp_StartsWith = foo => foo.Name.ToLowerInvariant().StartsWith("luis");

        static readonly Expression<Func<Foo, bool>> Exp_EndsWith = foo => foo.Name.ToLowerInvariant().EndsWith("luis");

        static readonly Expression<Func<Foo, bool>> Exp_Contains = foo => foo.Name.ToLowerInvariant().Contains("luis");

        static readonly Expression<Func<Foo, bool>> Exp_DoesNotContains = foo => !foo.Name.ToLowerInvariant().Contains("luis");

        static readonly Expression<Func<Foo, bool>> Exp_IsEqualTo = foo => foo.Name.ToLowerInvariant() == "luis";

        static readonly Expression<Func<Foo, bool>> Exp_IsNotEqualTo = foo => foo.Name.ToLowerInvariant() != "luis";

        static readonly Expression<Func<Foo, bool>> Exp_NullLiteralIsEqualTo = foo => foo.Name == null;

        static readonly Expression<Func<Foo, bool>> Exp_NullLiteralIsNotEqualTo = foo => foo.Name != null;



        static readonly object[] ExpressionCases =

        {

            new object[] { "UnitPrice", FilterOperator.IsLessThan, Exp_IsLessThan, 5 },

            new object[] { "UnitPrice", FilterOperator.IsLessThanOrEqualTo, Exp_IsLessThanOrEqualTo, "5" },

            new object[] { "UnitPrice", FilterOperator.IsGreaterThanOrEqualTo, Exp_IsGreaterThanOrEqualTo, "5" },

            new object[] { "UnitPrice", FilterOperator.IsGreaterThan, Exp_IsGreaterThan, "5" },

            new object[] { "Name", FilterOperator.StartsWith, Exp_StartsWith, "Luis" },

            new object[] { "Name", FilterOperator.EndsWith, Exp_EndsWith, "Luis" },

            new object[] { "Name", FilterOperator.Contains, Exp_Contains, "Luis" },

            new object[] { "Name", FilterOperator.DoesNotContain, Exp_DoesNotContains, "Luis" },

            new object[] { "Name", FilterOperator.IsEqualTo, Exp_IsEqualTo, "Luis" },

            new object[] { "Name", FilterOperator.IsNotEqualTo, Exp_IsNotEqualTo, "Luis" },

            new object[] { "Name", FilterOperator.IsNotEqualTo, Exp_NullLiteralIsNotEqualTo, null },

            new object[] { "Name", FilterOperator.IsEqualTo, Exp_NullLiteralIsEqualTo, null }

        };

        // ReSharper restore InconsistentNaming



        #endregion



        [TestCaseSource("ExpressionCases")]

        public void single_expressions(string member, FilterOperator @operator, Expression<Func<Foo, bool>> exp, object value)

        {

            var filter = new FilterDescriptor(member, @operator, value);

            var expressionWhereClause = new ExpressionWhereClause<Foo, FooModel>(filter, new CaseInsensitive<Foo>(true, true), false, null);



            expressionWhereClause.Predicate.ToString().Replace("Tests.Entity.Foo", "foo").Should().Be(exp.ToString());

        }



        [TestCaseSource("ExpressionCases")]

        public void double_expressions_with_orElse_operator(string member, FilterOperator @operator, Expression<Func<Foo, bool>> exp, object value)

        {

            var filter = new FilterDescriptor(member, @operator, value);

            var expressionWhereClause = new ExpressionWhereClause<Foo, FooModel>(filter, new CaseInsensitive<Foo>(true, true), false, null);



            expressionWhereClause.Predicate.ToString().Replace("Tests.Entity.Foo", "foo").Should().Be(exp.ToString());



            expressionWhereClause.OrElse(expressionWhereClause);



            expressionWhereClause.Predicate.ToString().Replace("Tests.Entity.Foo", "foo").Should().Be(exp.OrElse(exp).ToString());

        }



        [TestCaseSource("ExpressionCases")]

        public void double_expressions_with_andAlso_operator(string member, FilterOperator @operator, Expression<Func<Foo, bool>> exp, object value)

        {

            var filter = new FilterDescriptor(member, @operator, value);

            var expressionWhereClause = new ExpressionWhereClause<Foo, FooModel>(filter, new CaseInsensitive<Foo>(true, true), false, null);



            expressionWhereClause.Predicate.ToString().Replace("Tests.Entity.Foo", "foo").Should().Be(exp.ToString());



            expressionWhereClause.AndAlso(expressionWhereClause);



            expressionWhereClause.Predicate.ToString().Replace("Tests.Entity.Foo", "foo").Should().Be(exp.AndAlso(exp).ToString());

        }



        #region CustomExpression_Cases



        // ReSharper disable InconsistentNaming

        static readonly Expression<Func<Foo, bool>> CustomExpression_IsLessThan = foo => foo.UnitPrice + foo.UnitsInStock < 5;

        static readonly Expression<Func<Foo, bool>> CustomExpression_IsLessThanOrEqualTo = foo => foo.UnitPrice + foo.UnitsInStock <= 5;

        static readonly Expression<Func<Foo, bool>> CustomExpression_IsGreaterThanOrEqualTo = foo => foo.UnitPrice + foo.UnitsInStock >= 5;

        static readonly Expression<Func<Foo, bool>> CustomExpression_IsGreaterThan = foo => foo.UnitPrice + foo.UnitsInStock > 5;

        static readonly Expression<Func<Foo, bool>> CustomExpression_StartsWith = foo => (foo.FirstName + " " + foo.LastName).ToLowerInvariant().StartsWith("luis fernando");

        static readonly Expression<Func<Foo, bool>> CustomExpression_EndsWith = foo => (foo.FirstName + " " + foo.LastName).ToLowerInvariant().EndsWith("luis fernando");

        static readonly Expression<Func<Foo, bool>> CustomExpression_Contains = foo => (foo.FirstName + " " + foo.LastName).ToLowerInvariant().Contains("luis fernando");

        static readonly Expression<Func<Foo, bool>> CustomExpression_DoesNotContains = foo => !(foo.FirstName + " " + foo.LastName).ToLowerInvariant().Contains("luis fernando");

        static readonly Expression<Func<Foo, bool>> CustomExpression_IsEqualTo = foo => (foo.FirstName + " " + foo.LastName).ToLowerInvariant() == "luis fernando";

        static readonly Expression<Func<Foo, bool>> CustomExpression_IsNotEqualTo = foo => (foo.FirstName + " " + foo.LastName).ToLowerInvariant() != "luis fernando";

        static readonly Expression<Func<Foo, bool>> CustomExpression_NullLiteralIsEqualTo = foo => foo.FirstName + " " + foo.LastName == null;

        static readonly Expression<Func<Foo, bool>> CustomExpression_NullLiteralIsNotEqualTo = foo => foo.FirstName + " " + foo.LastName != null;



        static readonly object[] CustomExpression_Cases =

        {

            new object[] { "TotalPrice", FilterOperator.IsLessThan, CustomExpression_IsLessThan, 5 },

            new object[] { "TotalPrice", FilterOperator.IsLessThanOrEqualTo, CustomExpression_IsLessThanOrEqualTo, "5" },

            new object[] { "TotalPrice", FilterOperator.IsGreaterThanOrEqualTo, CustomExpression_IsGreaterThanOrEqualTo, "5" },

            new object[] { "TotalPrice", FilterOperator.IsGreaterThan, CustomExpression_IsGreaterThan, "5" },

            new object[] { "FullName", FilterOperator.StartsWith, CustomExpression_StartsWith, "Luis Fernando" },

            new object[] { "FullName", FilterOperator.EndsWith, CustomExpression_EndsWith, "Luis Fernando" },

            new object[] { "FullName", FilterOperator.Contains, CustomExpression_Contains, "Luis Fernando" },

            new object[] { "FullName", FilterOperator.DoesNotContain, CustomExpression_DoesNotContains, "Luis Fernando" },

            new object[] { "FullName", FilterOperator.IsEqualTo, CustomExpression_IsEqualTo, "Luis Fernando" },

            new object[] { "FullName", FilterOperator.IsNotEqualTo, CustomExpression_IsNotEqualTo, "Luis Fernando" },

            new object[] { "FullName", FilterOperator.IsEqualTo, CustomExpression_NullLiteralIsEqualTo, null },

            new object[] { "FullName", FilterOperator.IsNotEqualTo, CustomExpression_NullLiteralIsNotEqualTo, null }

        };

        // ReSharper restore InconsistentNaming



        #endregion



        [TestCaseSource("CustomExpression_Cases")]

        public void single_expressions_with_gridModelMapper_customExpression(string member, FilterOperator @operator, Expression<Func<Foo, bool>> exp, object value)

        {

            var filter = new FilterDescriptor(member, @operator, value);



            var expressionWhereClause = new ExpressionWhereClause<Foo, FooModel>(filter, new CaseInsensitive<Foo>(true, true), false, null);



            expressionWhereClause.Predicate.ToString().Should().Be(exp.ToString().Replace("Convert(5)", "5"));

        }



        [TestCaseSource("CustomExpression_Cases")]

        public void double_expressions_with_gridModelMapper_customExpression_and_orElse_operator(string member, FilterOperator @operator, Expression<Func<Foo, bool>> exp, object value)

        {

            var filter = new FilterDescriptor(member, @operator, value);

            var expressionWhereClause = new ExpressionWhereClause<Foo, FooModel>(filter, new CaseInsensitive<Foo>(true, true), false, null);



            expressionWhereClause.Predicate.ToString().Should().Be(exp.ToString().Replace("Convert(5)", "5"));



            expressionWhereClause.OrElse(expressionWhereClause);



            expressionWhereClause.Predicate.ToString().Should().Be(exp.OrElse(exp).ToString().Replace("Convert(5)", "5"));

        }



        [TestCaseSource("CustomExpression_Cases")]

        public void double_expressions_with_gridModelMapper_customExpression_and_andAlso_operator(string member, FilterOperator @operator, Expression<Func<Foo, bool>> exp, object value)

        {

            var filter = new FilterDescriptor(member, @operator, value);

            var expressionWhereClause = new ExpressionWhereClause<Foo, FooModel>(filter, new CaseInsensitive<Foo>(true, true), false, null);



            expressionWhereClause.Predicate.ToString().Should().Be(exp.ToString().Replace("Convert(5)", "5"));



            expressionWhereClause.AndAlso(expressionWhereClause);



            expressionWhereClause.Predicate.ToString().Should().Be(exp.AndAlso(exp).ToString().Replace("Convert(5)", "5"));

        }

    }



    public class ExpressionWhereClauseWithClientSideCaseInsensitiveTests

    {

        [SetUp]

        public void SetUp()

        {

            Mapper.Reset();

            GridModelMapper.Reset();

            GridModelMapper.CreateMap<Foo, FooModel>()

                .MapProperty(foo => foo.FirstName + " " + foo.LastName, model => model.FullName)

                .MapProperty(foo => foo.UnitPrice + foo.UnitsInStock, model => model.TotalPrice);

        }



        #region ExpressionCases



        // ReSharper disable InconsistentNaming

        static readonly Expression<Func<Foo, bool>> Exp_IsLessThan = foo => foo.UnitPrice < 5;

        static readonly Expression<Func<Foo, bool>> Exp_IsLessThanOrEqualTo = foo => foo.UnitPrice <= 5;

        static readonly Expression<Func<Foo, bool>> Exp_IsGreaterThanOrEqualTo = foo => foo.UnitPrice >= 5;

        static readonly Expression<Func<Foo, bool>> Exp_IsGreaterThan = foo => foo.UnitPrice > 5;

        static readonly Expression<Func<Foo, bool>> Exp_StartsWith = foo => foo.Name.StartsWith("luis");

        static readonly Expression<Func<Foo, bool>> Exp_EndsWith = foo => foo.Name.EndsWith("luis");

        static readonly Expression<Func<Foo, bool>> Exp_Contains = foo => foo.Name.Contains("luis");

        static readonly Expression<Func<Foo, bool>> Exp_DoesNotContains = foo => !foo.Name.Contains("luis");

        static readonly Expression<Func<Foo, bool>> Exp_IsEqualTo = foo => foo.Name == "luis";

        static readonly Expression<Func<Foo, bool>> Exp_IsNotEqualTo = foo => foo.Name != "luis";

        static readonly Expression<Func<Foo, bool>> Exp_NullLiteralIsEqualTo = foo => foo.Name == null;

        static readonly Expression<Func<Foo, bool>> Exp_NullLiteralIsNotEqualTo = foo => foo.Name != null;



        static readonly object[] ExpressionCases =

        {

            new object[] { "UnitPrice", FilterOperator.IsLessThan, Exp_IsLessThan, 5 },

            new object[] { "UnitPrice", FilterOperator.IsLessThanOrEqualTo, Exp_IsLessThanOrEqualTo, "5" },

            new object[] { "UnitPrice", FilterOperator.IsGreaterThanOrEqualTo, Exp_IsGreaterThanOrEqualTo, "5" },

            new object[] { "UnitPrice", FilterOperator.IsGreaterThan, Exp_IsGreaterThan, "5" },

            new object[] { "Name", FilterOperator.StartsWith, Exp_StartsWith, "Luis" },

            new object[] { "Name", FilterOperator.EndsWith, Exp_EndsWith, "Luis" },

            new object[] { "Name", FilterOperator.Contains, Exp_Contains, "Luis" },

            new object[] { "Name", FilterOperator.DoesNotContain, Exp_DoesNotContains, "Luis" },

            new object[] { "Name", FilterOperator.IsEqualTo, Exp_IsEqualTo, "Luis" },

            new object[] { "Name", FilterOperator.IsNotEqualTo, Exp_IsNotEqualTo, "Luis" },

            new object[] { "Name", FilterOperator.IsNotEqualTo, Exp_NullLiteralIsNotEqualTo, null },

            new object[] { "Name", FilterOperator.IsEqualTo, Exp_NullLiteralIsEqualTo, null }

        };

        // ReSharper restore InconsistentNaming



        #endregion



        [TestCaseSource("ExpressionCases")]

        public void single_expressions(string member, FilterOperator @operator, Expression<Func<Foo, bool>> exp, object value)

        {

            var filter = new FilterDescriptor(member, @operator, value);

            var expressionWhereClause = new ExpressionWhereClause<Foo, FooModel>(filter, new CaseInsensitive<Foo>(false, true), false, null);



            expressionWhereClause.Predicate.ToString().Replace("Tests.Entity.Foo", "foo").Should().Be(exp.ToString());

        }



        [TestCaseSource("ExpressionCases")]

        public void double_expressions_with_orElse_operator(string member, FilterOperator @operator, Expression<Func<Foo, bool>> exp, object value)

        {

            var filter = new FilterDescriptor(member, @operator, value);

            var expressionWhereClause = new ExpressionWhereClause<Foo, FooModel>(filter, new CaseInsensitive<Foo>(false, true), false, null);



            expressionWhereClause.Predicate.ToString().Replace("Tests.Entity.Foo", "foo").Should().Be(exp.ToString());



            expressionWhereClause.OrElse(expressionWhereClause);



            expressionWhereClause.Predicate.ToString().Replace("Tests.Entity.Foo", "foo").Should().Be(exp.OrElse(exp).ToString());

        }



        [TestCaseSource("ExpressionCases")]

        public void double_expressions_with_andAlso_operator(string member, FilterOperator @operator, Expression<Func<Foo, bool>> exp, object value)

        {

            var filter = new FilterDescriptor(member, @operator, value);

            var expressionWhereClause = new ExpressionWhereClause<Foo, FooModel>(filter, new CaseInsensitive<Foo>(false, true), false, null);



            expressionWhereClause.Predicate.ToString().Replace("Tests.Entity.Foo", "foo").Should().Be(exp.ToString());



            expressionWhereClause.AndAlso(expressionWhereClause);



            expressionWhereClause.Predicate.ToString().Replace("Tests.Entity.Foo", "foo").Should().Be(exp.AndAlso(exp).ToString());

        }



        #region CustomExpression_Cases



        // ReSharper disable InconsistentNaming

        static readonly Expression<Func<Foo, bool>> CustomExpression_IsLessThan = foo => foo.UnitPrice + foo.UnitsInStock < 5;

        static readonly Expression<Func<Foo, bool>> CustomExpression_IsLessThanOrEqualTo = foo => foo.UnitPrice + foo.UnitsInStock <= 5;

        static readonly Expression<Func<Foo, bool>> CustomExpression_IsGreaterThanOrEqualTo = foo => foo.UnitPrice + foo.UnitsInStock >= 5;

        static readonly Expression<Func<Foo, bool>> CustomExpression_IsGreaterThan = foo => foo.UnitPrice + foo.UnitsInStock > 5;

        static readonly Expression<Func<Foo, bool>> CustomExpression_StartsWith = foo => (foo.FirstName + " " + foo.LastName).StartsWith("luis fernando");

        static readonly Expression<Func<Foo, bool>> CustomExpression_EndsWith = foo => (foo.FirstName + " " + foo.LastName).EndsWith("luis fernando");

        static readonly Expression<Func<Foo, bool>> CustomExpression_Contains = foo => (foo.FirstName + " " + foo.LastName).Contains("luis fernando");

        static readonly Expression<Func<Foo, bool>> CustomExpression_DoesNotContains = foo => !(foo.FirstName + " " + foo.LastName).Contains("luis fernando");

        static readonly Expression<Func<Foo, bool>> CustomExpression_IsEqualTo = foo => (foo.FirstName + " " + foo.LastName) == "luis fernando";

        static readonly Expression<Func<Foo, bool>> CustomExpression_IsNotEqualTo = foo => (foo.FirstName + " " + foo.LastName) != "luis fernando";

        static readonly Expression<Func<Foo, bool>> CustomExpression_NullLiteralIsEqualTo = foo => foo.FirstName + " " + foo.LastName == null;

        static readonly Expression<Func<Foo, bool>> CustomExpression_NullLiteralIsNotEqualTo = foo => foo.FirstName + " " + foo.LastName != null;



        static readonly object[] CustomExpression_Cases =

        {

            new object[] { "TotalPrice", FilterOperator.IsLessThan, CustomExpression_IsLessThan, 5 },

            new object[] { "TotalPrice", FilterOperator.IsLessThanOrEqualTo, CustomExpression_IsLessThanOrEqualTo, "5" },

            new object[] { "TotalPrice", FilterOperator.IsGreaterThanOrEqualTo, CustomExpression_IsGreaterThanOrEqualTo, "5" },

            new object[] { "TotalPrice", FilterOperator.IsGreaterThan, CustomExpression_IsGreaterThan, "5" },

            new object[] { "FullName", FilterOperator.StartsWith, CustomExpression_StartsWith, "Luis Fernando" },

            new object[] { "FullName", FilterOperator.EndsWith, CustomExpression_EndsWith, "Luis Fernando" },

            new object[] { "FullName", FilterOperator.Contains, CustomExpression_Contains, "Luis Fernando" },

            new object[] { "FullName", FilterOperator.DoesNotContain, CustomExpression_DoesNotContains, "Luis Fernando" },

            new object[] { "FullName", FilterOperator.IsEqualTo, CustomExpression_IsEqualTo, "Luis Fernando" },

            new object[] { "FullName", FilterOperator.IsNotEqualTo, CustomExpression_IsNotEqualTo, "Luis Fernando" },

            new object[] { "FullName", FilterOperator.IsEqualTo, CustomExpression_NullLiteralIsEqualTo, null },

            new object[] { "FullName", FilterOperator.IsNotEqualTo, CustomExpression_NullLiteralIsNotEqualTo, null }

        };

        // ReSharper restore InconsistentNaming



        #endregion



        [TestCaseSource("CustomExpression_Cases")]

        public void single_expressions_with_gridModelMapper_customExpression(string member, FilterOperator @operator, Expression<Func<Foo, bool>> exp, object value)

        {

            var filter = new FilterDescriptor(member, @operator, value);



            var expressionWhereClause = new ExpressionWhereClause<Foo, FooModel>(filter, new CaseInsensitive<Foo>(false, true), false, null);



            expressionWhereClause.Predicate.ToString().Should().Be(exp.ToString().Replace("Convert(5)", "5"));

        }



        [TestCaseSource("CustomExpression_Cases")]

        public void double_expressions_with_gridModelMapper_customExpression_and_orElse_operator(string member, FilterOperator @operator, Expression<Func<Foo, bool>> exp, object value)

        {

            var filter = new FilterDescriptor(member, @operator, value);

            var expressionWhereClause = new ExpressionWhereClause<Foo, FooModel>(filter, new CaseInsensitive<Foo>(false, true), false, null);



            expressionWhereClause.Predicate.ToString().Should().Be(exp.ToString().Replace("Convert(5)", "5"));



            expressionWhereClause.OrElse(expressionWhereClause);



            expressionWhereClause.Predicate.ToString().Should().Be(exp.OrElse(exp).ToString().Replace("Convert(5)", "5"));

        }



        [TestCaseSource("CustomExpression_Cases")]

        public void double_expressions_with_gridModelMapper_customExpression_and_andAlso_operator(string member, FilterOperator @operator, Expression<Func<Foo, bool>> exp, object value)

        {

            var filter = new FilterDescriptor(member, @operator, value);

            var expressionWhereClause = new ExpressionWhereClause<Foo, FooModel>(filter, new CaseInsensitive<Foo>(false, true), false, null);



            expressionWhereClause.Predicate.ToString().Should().Be(exp.ToString().Replace("Convert(5)", "5"));



            expressionWhereClause.AndAlso(expressionWhereClause);



            expressionWhereClause.Predicate.ToString().Should().Be(exp.AndAlso(exp).ToString().Replace("Convert(5)", "5"));

        }

    }



    public class ExpressionWhereClauseWithServerSideCaseInsensitiveTests

    {

        [SetUp]

        public void SetUp()

        {

            Mapper.Reset();

            GridModelMapper.Reset();

            GridModelMapper.CreateMap<Foo, FooModel>()

                .MapProperty(foo => foo.FirstName + " " + foo.LastName, model => model.FullName)

                .MapProperty(foo => foo.UnitPrice + foo.UnitsInStock, model => model.TotalPrice);

        }



        #region ExpressionCases



        // ReSharper disable InconsistentNaming

        static readonly Expression<Func<Foo, bool>> Exp_IsLessThan = foo => foo.UnitPrice < 5;

        static readonly Expression<Func<Foo, bool>> Exp_IsLessThanOrEqualTo = foo => foo.UnitPrice <= 5;

        static readonly Expression<Func<Foo, bool>> Exp_IsGreaterThanOrEqualTo = foo => foo.UnitPrice >= 5;

        static readonly Expression<Func<Foo, bool>> Exp_IsGreaterThan = foo => foo.UnitPrice > 5;

        static readonly Expression<Func<Foo, bool>> Exp_StartsWith = foo => foo.Name.ToLowerInvariant().StartsWith("Luis");

        static readonly Expression<Func<Foo, bool>> Exp_EndsWith = foo => foo.Name.ToLowerInvariant().EndsWith("Luis");

        static readonly Expression<Func<Foo, bool>> Exp_Contains = foo => foo.Name.ToLowerInvariant().Contains("Luis");

        static readonly Expression<Func<Foo, bool>> Exp_DoesNotContains = foo => !foo.Name.ToLowerInvariant().Contains("Luis");

        static readonly Expression<Func<Foo, bool>> Exp_IsEqualTo = foo => foo.Name.ToLowerInvariant() == "Luis";

        static readonly Expression<Func<Foo, bool>> Exp_IsNotEqualTo = foo => foo.Name.ToLowerInvariant() != "Luis";

        static readonly Expression<Func<Foo, bool>> Exp_NullLiteralIsEqualTo = foo => foo.Name == null;

        static readonly Expression<Func<Foo, bool>> Exp_NullLiteralIsNotEqualTo = foo => foo.Name != null;



        static readonly object[] ExpressionCases =

        {

            new object[] { "UnitPrice", FilterOperator.IsLessThan, Exp_IsLessThan, 5 },

            new object[] { "UnitPrice", FilterOperator.IsLessThanOrEqualTo, Exp_IsLessThanOrEqualTo, "5" },

            new object[] { "UnitPrice", FilterOperator.IsGreaterThanOrEqualTo, Exp_IsGreaterThanOrEqualTo, "5" },

            new object[] { "UnitPrice", FilterOperator.IsGreaterThan, Exp_IsGreaterThan, "5" },

            new object[] { "Name", FilterOperator.StartsWith, Exp_StartsWith, "Luis" },

            new object[] { "Name", FilterOperator.EndsWith, Exp_EndsWith, "Luis" },

            new object[] { "Name", FilterOperator.Contains, Exp_Contains, "Luis" },

            new object[] { "Name", FilterOperator.DoesNotContain, Exp_DoesNotContains, "Luis" },

            new object[] { "Name", FilterOperator.IsEqualTo, Exp_IsEqualTo, "Luis" },

            new object[] { "Name", FilterOperator.IsNotEqualTo, Exp_IsNotEqualTo, "Luis" },

            new object[] { "Name", FilterOperator.IsNotEqualTo, Exp_NullLiteralIsNotEqualTo, null },

            new object[] { "Name", FilterOperator.IsEqualTo, Exp_NullLiteralIsEqualTo, null }

        };

        // ReSharper restore InconsistentNaming



        #endregion



        [TestCaseSource("ExpressionCases")]

        public void single_expressions(string member, FilterOperator @operator, Expression<Func<Foo, bool>> exp, object value)

        {

            var filter = new FilterDescriptor(member, @operator, value);

            var expressionWhereClause = new ExpressionWhereClause<Foo, FooModel>(filter, new CaseInsensitive<Foo>(true, false), false, null);



            expressionWhereClause.Predicate.ToString().Replace("Tests.Entity.Foo", "foo").Should().Be(exp.ToString());

        }



        [TestCaseSource("ExpressionCases")]

        public void double_expressions_with_orElse_operator(string member, FilterOperator @operator, Expression<Func<Foo, bool>> exp, object value)

        {

            var filter = new FilterDescriptor(member, @operator, value);

            var expressionWhereClause = new ExpressionWhereClause<Foo, FooModel>(filter, new CaseInsensitive<Foo>(true, false), false, null);



            expressionWhereClause.Predicate.ToString().Replace("Tests.Entity.Foo", "foo").Should().Be(exp.ToString());



            expressionWhereClause.OrElse(expressionWhereClause);



            expressionWhereClause.Predicate.ToString().Replace("Tests.Entity.Foo", "foo").Should().Be(exp.OrElse(exp).ToString());

        }



        [TestCaseSource("ExpressionCases")]

        public void double_expressions_with_andAlso_operator(string member, FilterOperator @operator, Expression<Func<Foo, bool>> exp, object value)

        {

            var filter = new FilterDescriptor(member, @operator, value);

            var expressionWhereClause = new ExpressionWhereClause<Foo, FooModel>(filter, new CaseInsensitive<Foo>(true, false), false, null);



            expressionWhereClause.Predicate.ToString().Replace("Tests.Entity.Foo", "foo").Should().Be(exp.ToString());



            expressionWhereClause.AndAlso(expressionWhereClause);



            expressionWhereClause.Predicate.ToString().Replace("Tests.Entity.Foo", "foo").Should().Be(exp.AndAlso(exp).ToString());

        }



        #region CustomExpression_Cases



        // ReSharper disable InconsistentNaming

        static readonly Expression<Func<Foo, bool>> CustomExpression_IsLessThan = foo => foo.UnitPrice + foo.UnitsInStock < 5;

        static readonly Expression<Func<Foo, bool>> CustomExpression_IsLessThanOrEqualTo = foo => foo.UnitPrice + foo.UnitsInStock <= 5;

        static readonly Expression<Func<Foo, bool>> CustomExpression_IsGreaterThanOrEqualTo = foo => foo.UnitPrice + foo.UnitsInStock >= 5;

        static readonly Expression<Func<Foo, bool>> CustomExpression_IsGreaterThan = foo => foo.UnitPrice + foo.UnitsInStock > 5;

        static readonly Expression<Func<Foo, bool>> CustomExpression_StartsWith = foo => (foo.FirstName + " " + foo.LastName).ToLowerInvariant().StartsWith("Luis Fernando");

        static readonly Expression<Func<Foo, bool>> CustomExpression_EndsWith = foo => (foo.FirstName + " " + foo.LastName).ToLowerInvariant().EndsWith("Luis Fernando");

        static readonly Expression<Func<Foo, bool>> CustomExpression_Contains = foo => (foo.FirstName + " " + foo.LastName).ToLowerInvariant().Contains("Luis Fernando");

        static readonly Expression<Func<Foo, bool>> CustomExpression_DoesNotContains = foo => !(foo.FirstName + " " + foo.LastName).ToLowerInvariant().Contains("Luis Fernando");

        static readonly Expression<Func<Foo, bool>> CustomExpression_IsEqualTo = foo => (foo.FirstName + " " + foo.LastName).ToLowerInvariant() == "Luis Fernando";

        static readonly Expression<Func<Foo, bool>> CustomExpression_IsNotEqualTo = foo => (foo.FirstName + " " + foo.LastName).ToLowerInvariant() != "Luis Fernando";

        static readonly Expression<Func<Foo, bool>> CustomExpression_NullLiteralIsEqualTo = foo => foo.FirstName + " " + foo.LastName == null;

        static readonly Expression<Func<Foo, bool>> CustomExpression_NullLiteralIsNotEqualTo = foo => foo.FirstName + " " + foo.LastName != null;



        static readonly object[] CustomExpression_Cases =

        {

            new object[] { "TotalPrice", FilterOperator.IsLessThan, CustomExpression_IsLessThan, 5 },

            new object[] { "TotalPrice", FilterOperator.IsLessThanOrEqualTo, CustomExpression_IsLessThanOrEqualTo, "5" },

            new object[] { "TotalPrice", FilterOperator.IsGreaterThanOrEqualTo, CustomExpression_IsGreaterThanOrEqualTo, "5" },

            new object[] { "TotalPrice", FilterOperator.IsGreaterThan, CustomExpression_IsGreaterThan, "5" },

            new object[] { "FullName", FilterOperator.StartsWith, CustomExpression_StartsWith, "Luis Fernando" },

            new object[] { "FullName", FilterOperator.EndsWith, CustomExpression_EndsWith, "Luis Fernando" },

            new object[] { "FullName", FilterOperator.Contains, CustomExpression_Contains, "Luis Fernando" },

            new object[] { "FullName", FilterOperator.DoesNotContain, CustomExpression_DoesNotContains, "Luis Fernando" },

            new object[] { "FullName", FilterOperator.IsEqualTo, CustomExpression_IsEqualTo, "Luis Fernando" },

            new object[] { "FullName", FilterOperator.IsNotEqualTo, CustomExpression_IsNotEqualTo, "Luis Fernando" },

            new object[] { "FullName", FilterOperator.IsEqualTo, CustomExpression_NullLiteralIsEqualTo, null },

            new object[] { "FullName", FilterOperator.IsNotEqualTo, CustomExpression_NullLiteralIsNotEqualTo, null }

        };

        // ReSharper restore InconsistentNaming



        #endregion



        [TestCaseSource("CustomExpression_Cases")]

        public void single_expressions_with_gridModelMapper_customExpression(string member, FilterOperator @operator, Expression<Func<Foo, bool>> exp, object value)

        {

            var filter = new FilterDescriptor(member, @operator, value);



            var expressionWhereClause = new ExpressionWhereClause<Foo, FooModel>(filter, new CaseInsensitive<Foo>(true, false), false, null);



            expressionWhereClause.Predicate.ToString().Should().Be(exp.ToString().Replace("Convert(5)", "5"));

        }



        [TestCaseSource("CustomExpression_Cases")]

        public void double_expressions_with_gridModelMapper_customExpression_and_orElse_operator(string member, FilterOperator @operator, Expression<Func<Foo, bool>> exp, object value)

        {

            var filter = new FilterDescriptor(member, @operator, value);

            var expressionWhereClause = new ExpressionWhereClause<Foo, FooModel>(filter, new CaseInsensitive<Foo>(true, false), false, null);



            expressionWhereClause.Predicate.ToString().Should().Be(exp.ToString().Replace("Convert(5)", "5"));



            expressionWhereClause.OrElse(expressionWhereClause);



            expressionWhereClause.Predicate.ToString().Should().Be(exp.OrElse(exp).ToString().Replace("Convert(5)", "5"));

        }



        [TestCaseSource("CustomExpression_Cases")]

        public void double_expressions_with_gridModelMapper_customExpression_and_andAlso_operator(string member, FilterOperator @operator, Expression<Func<Foo, bool>> exp, object value)

        {

            var filter = new FilterDescriptor(member, @operator, value);

            var expressionWhereClause = new ExpressionWhereClause<Foo, FooModel>(filter, new CaseInsensitive<Foo>(true, false), false, null);



            expressionWhereClause.Predicate.ToString().Should().Be(exp.ToString().Replace("Convert(5)", "5"));



            expressionWhereClause.AndAlso(expressionWhereClause);



            expressionWhereClause.Predicate.ToString().Should().Be(exp.AndAlso(exp).ToString().Replace("Convert(5)", "5"));

        }

    }



    public class ExpressionWhereClauseTests

    {

        [SetUp]

        public void SetUp()

        {

            Mapper.Reset();

            GridModelMapper.Reset();

            GridModelMapper.CreateMap<Foo, FooModel>()

                .MapProperty(foo => foo.FirstName + " " + foo.LastName, model => model.FullName)

                .MapProperty(foo => foo.UnitPrice + foo.UnitsInStock, model => model.TotalPrice);

        }



        #region ExpressionCases



        // ReSharper disable InconsistentNaming

        static readonly Expression<Func<Foo, bool>> Exp_IsLessThan = foo => foo.UnitPrice < 5;

        static readonly Expression<Func<Foo, bool>> Exp_IsLessThanOrEqualTo = foo => foo.UnitPrice <= 5;

        static readonly Expression<Func<Foo, bool>> Exp_IsGreaterThanOrEqualTo = foo => foo.UnitPrice >= 5;

        static readonly Expression<Func<Foo, bool>> Exp_IsGreaterThan = foo => foo.UnitPrice > 5;

        static readonly Expression<Func<Foo, bool>> Exp_StartsWith = foo => foo.Name.StartsWith("Luis");

        static readonly Expression<Func<Foo, bool>> Exp_EndsWith = foo => foo.Name.EndsWith("Luis");

        static readonly Expression<Func<Foo, bool>> Exp_Contains = foo => foo.Name.Contains("Luis");

        static readonly Expression<Func<Foo, bool>> Exp_DoesNotContains = foo => !foo.Name.Contains("Luis");

        static readonly Expression<Func<Foo, bool>> Exp_IsEqualTo = foo => foo.Name == "Luis";

        static readonly Expression<Func<Foo, bool>> Exp_IsNotEqualTo = foo => foo.Name != "Luis";

        static readonly Expression<Func<Foo, bool>> Exp_NullLiteralIsEqualTo = foo => foo.Name == null;

        static readonly Expression<Func<Foo, bool>> Exp_NullLiteralIsNotEqualTo = foo => foo.Name != null;



        static readonly object[] ExpressionCases =

        {

            new object[] { "UnitPrice", FilterOperator.IsLessThan, Exp_IsLessThan, 5 },

            new object[] { "UnitPrice", FilterOperator.IsLessThanOrEqualTo, Exp_IsLessThanOrEqualTo, "5" },

            new object[] { "UnitPrice", FilterOperator.IsGreaterThanOrEqualTo, Exp_IsGreaterThanOrEqualTo, "5" },

            new object[] { "UnitPrice", FilterOperator.IsGreaterThan, Exp_IsGreaterThan, "5" },

            new object[] { "Name", FilterOperator.StartsWith, Exp_StartsWith, "Luis" },

            new object[] { "Name", FilterOperator.EndsWith, Exp_EndsWith, "Luis" },

            new object[] { "Name", FilterOperator.Contains, Exp_Contains, "Luis" },

            new object[] { "Name", FilterOperator.DoesNotContain, Exp_DoesNotContains, "Luis" },

            new object[] { "Name", FilterOperator.IsEqualTo, Exp_IsEqualTo, "Luis" },

            new object[] { "Name", FilterOperator.IsNotEqualTo, Exp_IsNotEqualTo, "Luis" },

            new object[] { "Name", FilterOperator.IsNotEqualTo, Exp_NullLiteralIsNotEqualTo, null },

            new object[] { "Name", FilterOperator.IsEqualTo, Exp_NullLiteralIsEqualTo, null }

        };

        // ReSharper restore InconsistentNaming



        #endregion



        [TestCaseSource("ExpressionCases")]

        public void single_expressions(string member, FilterOperator @operator, Expression<Func<Foo, bool>> exp, object value)

        {

            var filter = new FilterDescriptor(member, @operator, value);

            var expressionWhereClause = new ExpressionWhereClause<Foo, FooModel>(filter, null, false, null);



            expressionWhereClause.Predicate.ToString().Replace("Tests.Entity.Foo", "foo").Should().Be(exp.ToString());

        }



        [TestCaseSource("ExpressionCases")]

        public void double_expressions_with_orElse_operator(string member, FilterOperator @operator, Expression<Func<Foo, bool>> exp, object value)

        {

            var filter = new FilterDescriptor(member, @operator, value);

            var expressionWhereClause = new ExpressionWhereClause<Foo, FooModel>(filter, null, false, null);



            expressionWhereClause.Predicate.ToString().Replace("Tests.Entity.Foo", "foo").Should().Be(exp.ToString());



            expressionWhereClause.OrElse(expressionWhereClause);



            expressionWhereClause.Predicate.ToString().Replace("Tests.Entity.Foo", "foo").Should().Be(exp.OrElse(exp).ToString());

        }



        [TestCaseSource("ExpressionCases")]

        public void double_expressions_with_andAlso_operator(string member, FilterOperator @operator, Expression<Func<Foo, bool>> exp, object value)

        {

            var filter = new FilterDescriptor(member, @operator, value);

            var expressionWhereClause = new ExpressionWhereClause<Foo, FooModel>(filter, null, false, null);



            expressionWhereClause.Predicate.ToString().Replace("Tests.Entity.Foo", "foo").Should().Be(exp.ToString());



            expressionWhereClause.AndAlso(expressionWhereClause);



            expressionWhereClause.Predicate.ToString().Replace("Tests.Entity.Foo", "foo").Should().Be(exp.AndAlso(exp).ToString());

        }



        #region CustomExpression_Cases



        // ReSharper disable InconsistentNaming

        static readonly Expression<Func<Foo, bool>> CustomExpression_IsLessThan = foo => foo.UnitPrice + foo.UnitsInStock < 5;

        static readonly Expression<Func<Foo, bool>> CustomExpression_IsLessThanOrEqualTo = foo => foo.UnitPrice + foo.UnitsInStock <= 5;

        static readonly Expression<Func<Foo, bool>> CustomExpression_IsGreaterThanOrEqualTo = foo => foo.UnitPrice + foo.UnitsInStock >= 5;

        static readonly Expression<Func<Foo, bool>> CustomExpression_IsGreaterThan = foo => foo.UnitPrice + foo.UnitsInStock > 5;

        static readonly Expression<Func<Foo, bool>> CustomExpression_StartsWith = foo => (foo.FirstName + " " + foo.LastName).StartsWith("Luis Fernando");

        static readonly Expression<Func<Foo, bool>> CustomExpression_EndsWith = foo => (foo.FirstName + " " + foo.LastName).EndsWith("Luis Fernando");

        static readonly Expression<Func<Foo, bool>> CustomExpression_Contains = foo => (foo.FirstName + " " + foo.LastName).Contains("Luis Fernando");

        static readonly Expression<Func<Foo, bool>> CustomExpression_DoesNotContains = foo => !(foo.FirstName + " " + foo.LastName).Contains("Luis Fernando");

        static readonly Expression<Func<Foo, bool>> CustomExpression_IsEqualTo = foo => foo.FirstName + " " + foo.LastName == "Luis Fernando";

        static readonly Expression<Func<Foo, bool>> CustomExpression_IsNotEqualTo = foo => foo.FirstName + " " + foo.LastName != "Luis Fernando";

        static readonly Expression<Func<Foo, bool>> CustomExpression_NullLiteralIsEqualTo = foo => foo.FirstName + " " + foo.LastName == null;

        static readonly Expression<Func<Foo, bool>> CustomExpression_NullLiteralIsNotEqualTo = foo => foo.FirstName + " " + foo.LastName != null;



        static readonly object[] CustomExpression_Cases =

        {

            new object[] { "TotalPrice", FilterOperator.IsLessThan, CustomExpression_IsLessThan, 5 },

            new object[] { "TotalPrice", FilterOperator.IsLessThanOrEqualTo, CustomExpression_IsLessThanOrEqualTo, "5" },

            new object[] { "TotalPrice", FilterOperator.IsGreaterThanOrEqualTo, CustomExpression_IsGreaterThanOrEqualTo, "5" },

            new object[] { "TotalPrice", FilterOperator.IsGreaterThan, CustomExpression_IsGreaterThan, "5" },

            new object[] { "FullName", FilterOperator.StartsWith, CustomExpression_StartsWith, "Luis Fernando" },

            new object[] { "FullName", FilterOperator.EndsWith, CustomExpression_EndsWith, "Luis Fernando" },

            new object[] { "FullName", FilterOperator.Contains, CustomExpression_Contains, "Luis Fernando" },

            new object[] { "FullName", FilterOperator.DoesNotContain, CustomExpression_DoesNotContains, "Luis Fernando" },

            new object[] { "FullName", FilterOperator.IsEqualTo, CustomExpression_IsEqualTo, "Luis Fernando" },

            new object[] { "FullName", FilterOperator.IsNotEqualTo, CustomExpression_IsNotEqualTo, "Luis Fernando" },

            new object[] { "FullName", FilterOperator.IsEqualTo, CustomExpression_NullLiteralIsEqualTo, null },

            new object[] { "FullName", FilterOperator.IsNotEqualTo, CustomExpression_NullLiteralIsNotEqualTo, null }

        };

        // ReSharper restore InconsistentNaming



        #endregion



        [TestCaseSource("CustomExpression_Cases")]

        public void single_expressions_with_gridModelMapper_customExpression(string member, FilterOperator @operator, Expression<Func<Foo, bool>> exp, object value)

        {

            var filter = new FilterDescriptor(member, @operator, value);



            var expressionWhereClause = new ExpressionWhereClause<Foo, FooModel>(filter, null, false, null);



            expressionWhereClause.Predicate.ToString().Should().Be(exp.ToString());

        }



        [TestCaseSource("CustomExpression_Cases")]

        public void double_expressions_with_gridModelMapper_customExpression_and_orElse_operator(string member, FilterOperator @operator, Expression<Func<Foo, bool>> exp, object value)

        {

            var filter = new FilterDescriptor(member, @operator, value);

            var expressionWhereClause = new ExpressionWhereClause<Foo, FooModel>(filter, null, false, null);



            expressionWhereClause.Predicate.ToString().Should().Be(exp.ToString());



            expressionWhereClause.OrElse(expressionWhereClause);



            expressionWhereClause.Predicate.ToString().Should().Be(exp.OrElse(exp).ToString());

        }



        [TestCaseSource("CustomExpression_Cases")]

        public void double_expressions_with_gridModelMapper_customExpression_and_andAlso_operator(string member, FilterOperator @operator, Expression<Func<Foo, bool>> exp, object value)

        {

            var filter = new FilterDescriptor(member, @operator, value);

            var expressionWhereClause = new ExpressionWhereClause<Foo, FooModel>(filter, null, false, null);



            expressionWhereClause.Predicate.ToString().Should().Be(exp.ToString());



            expressionWhereClause.AndAlso(expressionWhereClause);



            expressionWhereClause.Predicate.ToString().Should().Be(exp.AndAlso(exp).ToString());

        }

    }



    public class DynamicWhereClauseTests

    {

        [SetUp]

        public void SetUp()

        {

            Mapper.Reset();

            GridModelMapper.Reset();

            GridModelMapper.CreateMap<Foo, FooModel>()

                .MapProperty(foo => foo.FirstName + " " + foo.LastName, model => model.FullName)

                .MapProperty(foo => foo.UnitPrice + foo.UnitsInStock, model => model.TotalPrice);

        }



        #region ExpressionCases



        // ReSharper disable InconsistentNaming

        static readonly Expression<Func<Foo, bool>> Exp_IsLessThan = foo => foo.UnitPrice < 5;

        static readonly Expression<Func<Foo, bool>> Exp_IsLessThanOrEqualTo = foo => foo.UnitPrice <= 5;

        static readonly Expression<Func<Foo, bool>> Exp_IsGreaterThanOrEqualTo = foo => foo.UnitPrice >= 5;

        static readonly Expression<Func<Foo, bool>> Exp_IsGreaterThan = foo => foo.UnitPrice > 5;

        static readonly Expression<Func<Foo, bool>> Exp_StartsWith = foo => foo.Name.StartsWith("Luis");

        static readonly Expression<Func<Foo, bool>> Exp_EndsWith = foo => foo.Name.EndsWith("Luis");

        static readonly Expression<Func<Foo, bool>> Exp_Contains = foo => foo.Name.Contains("Luis");

        static readonly Expression<Func<Foo, bool>> Exp_DoesNotContains = foo => !foo.Name.Contains("Luis");

        static readonly Expression<Func<Foo, bool>> Exp_IsEqualTo = foo => foo.Name == "Luis";

        static readonly Expression<Func<Foo, bool>> Exp_IsNotEqualTo = foo => foo.Name != "Luis";

        static readonly Expression<Func<Foo, bool>> Exp_NullLiteralIsEqualTo = foo => foo.Name == null;

        static readonly Expression<Func<Foo, bool>> Exp_NullLiteralIsNotEqualTo = foo => foo.Name != null;



        static readonly object[] ExpressionCases =

        {

            new object[] { "UnitPrice", FilterOperator.IsLessThan, Exp_IsLessThan, 5 },

            new object[] { "UnitPrice", FilterOperator.IsLessThanOrEqualTo, Exp_IsLessThanOrEqualTo, "5" },

            new object[] { "UnitPrice", FilterOperator.IsGreaterThanOrEqualTo, Exp_IsGreaterThanOrEqualTo, "5" },

            new object[] { "UnitPrice", FilterOperator.IsGreaterThan, Exp_IsGreaterThan, "5" },

            new object[] { "Name", FilterOperator.StartsWith, Exp_StartsWith, "Luis" },

            new object[] { "Name", FilterOperator.EndsWith, Exp_EndsWith, "Luis" },

            new object[] { "Name", FilterOperator.Contains, Exp_Contains, "Luis" },

            new object[] { "Name", FilterOperator.DoesNotContain, Exp_DoesNotContains, "Luis" },

            new object[] { "Name", FilterOperator.IsEqualTo, Exp_IsEqualTo, "Luis" },

            new object[] { "Name", FilterOperator.IsNotEqualTo, Exp_IsNotEqualTo, "Luis" },

            new object[] { "Name", FilterOperator.IsNotEqualTo, Exp_NullLiteralIsNotEqualTo, null },

            new object[] { "Name", FilterOperator.IsEqualTo, Exp_NullLiteralIsEqualTo, null }

        };

        // ReSharper restore InconsistentNaming



        #endregion



        [TestCaseSource("ExpressionCases")]

        public void single_expressions(string member, FilterOperator @operator, Expression<Func<Foo, bool>> exp, object value)

        {

            var filter = new FilterDescriptor(member, @operator, value);

            var dynamicWhereClause = new DynamicWhereClause<Foo, FooModel>(filter, null, false, null);



            dynamicWhereClause.CustomExpression.ToString().Replace("Param_0", "foo").Should().Be(exp.ToString());

        }



        [TestCaseSource("ExpressionCases")]

        public void double_expressions_with_orElse_operator(string member, FilterOperator @operator, Expression<Func<Foo, bool>> exp, object value)

        {

            var filter = new FilterDescriptor(member, @operator, value);

            var dynamicWhereClause = new DynamicWhereClause<Foo, FooModel>(filter, null, false, null);



            dynamicWhereClause.CustomExpression.ToString().Replace("Param_0", "foo").Should().Be(exp.ToString());



            dynamicWhereClause.OrElse(dynamicWhereClause);



            dynamicWhereClause.CustomExpression.ToString().Replace("Param_0", "foo").Should().Be(exp.OrElse(exp).ToString());

        }



        [TestCaseSource("ExpressionCases")]

        public void double_expressions_with_andAlso_operator(string member, FilterOperator @operator, Expression<Func<Foo, bool>> exp, object value)

        {

            var filter = new FilterDescriptor(member, @operator, value);

            var dynamicWhereClause = new DynamicWhereClause<Foo, FooModel>(filter, null, false, null);



            dynamicWhereClause.CustomExpression.ToString().Replace("Param_0", "foo").Should().Be(exp.ToString());



            dynamicWhereClause.AndAlso(dynamicWhereClause);



            dynamicWhereClause.CustomExpression.ToString().Replace("Param_0", "foo").Should().Be(exp.AndAlso(exp).ToString());

        }



        #region CustomExpression_Cases



        // ReSharper disable InconsistentNaming

        static readonly Expression<Func<Foo, bool>> CustomExpression_IsLessThan = foo => foo.UnitPrice + foo.UnitsInStock < 5;

        static readonly Expression<Func<Foo, bool>> CustomExpression_IsLessThanOrEqualTo = foo => foo.UnitPrice + foo.UnitsInStock <= 5;

        static readonly Expression<Func<Foo, bool>> CustomExpression_IsGreaterThanOrEqualTo = foo => foo.UnitPrice + foo.UnitsInStock >= 5;

        static readonly Expression<Func<Foo, bool>> CustomExpression_IsGreaterThan = foo => foo.UnitPrice + foo.UnitsInStock > 5;

        static readonly Expression<Func<Foo, bool>> CustomExpression_StartsWith = foo => (foo.FirstName + " " + foo.LastName).StartsWith("Luis Fernando");

        static readonly Expression<Func<Foo, bool>> CustomExpression_EndsWith = foo => (foo.FirstName + " " + foo.LastName).EndsWith("Luis Fernando");

        static readonly Expression<Func<Foo, bool>> CustomExpression_Contains = foo => (foo.FirstName + " " + foo.LastName).Contains("Luis Fernando");

        static readonly Expression<Func<Foo, bool>> CustomExpression_DoesNotContains = foo => !(foo.FirstName + " " + foo.LastName).Contains("Luis Fernando");

        static readonly Expression<Func<Foo, bool>> CustomExpression_IsEqualTo = foo => foo.FirstName + " " + foo.LastName == "Luis Fernando";

        static readonly Expression<Func<Foo, bool>> CustomExpression_IsNotEqualTo = foo => foo.FirstName + " " + foo.LastName != "Luis Fernando";



        static readonly object[] CustomExpression_Cases =

        {

            new object[] { "TotalPrice", FilterOperator.IsLessThan, CustomExpression_IsLessThan, 5 },

            new object[] { "TotalPrice", FilterOperator.IsLessThanOrEqualTo, CustomExpression_IsLessThanOrEqualTo, "5" },

            new object[] { "TotalPrice", FilterOperator.IsGreaterThanOrEqualTo, CustomExpression_IsGreaterThanOrEqualTo, "5" },

            new object[] { "TotalPrice", FilterOperator.IsGreaterThan, CustomExpression_IsGreaterThan, "5" },

            new object[] { "FullName", FilterOperator.StartsWith, CustomExpression_StartsWith, "Luis Fernando" },

            new object[] { "FullName", FilterOperator.EndsWith, CustomExpression_EndsWith, "Luis Fernando" },

            new object[] { "FullName", FilterOperator.Contains, CustomExpression_Contains, "Luis Fernando" },

            new object[] { "FullName", FilterOperator.DoesNotContain, CustomExpression_DoesNotContains, "Luis Fernando" },

            new object[] { "FullName", FilterOperator.IsEqualTo, CustomExpression_IsEqualTo, "Luis Fernando" },

            new object[] { "FullName", FilterOperator.IsNotEqualTo, CustomExpression_IsNotEqualTo, "Luis Fernando" }

        };

        // ReSharper restore InconsistentNaming



        #endregion



        [TestCaseSource("CustomExpression_Cases")]

        public void single_expressions_with_gridModelMapper_customExpression(string member, FilterOperator @operator, Expression<Func<Foo, bool>> exp, object value)

        {

            var filter = new FilterDescriptor(member, @operator, value);

            var dynamicWhereClause = new DynamicWhereClause<Foo, FooModel>(filter, null, false, null);



            dynamicWhereClause.CustomExpression.ToString().Should().Be(exp.ToString());

        }



        [TestCaseSource("CustomExpression_Cases")]

        public void double_expressions_with_gridModelMapper_customExpression_and_orElse_operator(string member, FilterOperator @operator, Expression<Func<Foo, bool>> exp, object value)

        {

            var filter = new FilterDescriptor(member, @operator, value);

            var dynamicWhereClause = new DynamicWhereClause<Foo, FooModel>(filter, null, false, null);



            dynamicWhereClause.CustomExpression.ToString().Should().Be(exp.ToString());



            filter = new FilterDescriptor("Name", FilterOperator.IsEqualTo, "Luis");

            var anotherDynamicWhereClause = new DynamicWhereClause<Foo, FooModel>(filter, null, false, null);

            dynamicWhereClause.OrElse(anotherDynamicWhereClause);



            Expression<Func<Foo, bool>> anotherExp = foo => foo.Name == "Luis";

            dynamicWhereClause.CustomExpression.ToString().Should().Be(exp.OrElse(anotherExp).ToString());

        }



        [TestCaseSource("CustomExpression_Cases")]

        public void double_expressions_with_gridModelMapper_customExpression_and_andAlso_operator(string member, FilterOperator @operator, Expression<Func<Foo, bool>> exp, object value)

        {

            var filter = new FilterDescriptor(member, @operator, value);

            var dynamicWhereClause = new DynamicWhereClause<Foo, FooModel>(filter, null, false, null);



            dynamicWhereClause.CustomExpression.ToString().Should().Be(exp.ToString());



            filter = new FilterDescriptor("Name", FilterOperator.IsEqualTo, "Luis");

            var anotherDynamicWhereClause = new DynamicWhereClause<Foo, FooModel>(filter, null, false, null);

            dynamicWhereClause.AndAlso(anotherDynamicWhereClause);



            Expression<Func<Foo, bool>> anotherExp = foo => foo.Name == "Luis";

            dynamicWhereClause.CustomExpression.ToString().Should().Be(exp.AndAlso(anotherExp).ToString());

        }

    }

}