/Tests/DynamicWhereClause/DynamicWhereClauseTests.cs

Large files files are truncated, but you can click here to view the full file

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;…