// Copyright (c) Microsoft Corporation. All rights reserved. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.ComponentModel.DataAnnotations;
using System.Linq;
using System.Linq.Expressions;
using Moq;
using Xunit;
using Assert = Microsoft.TestCommon.AssertEx;

namespace System.Web.Mvc.Test
{
    public class ModelMetadataTest
    {
        // Guard clauses

        [Fact]
        public void NullProviderThrows()
        {
            // Act & Assert
            Assert.ThrowsArgumentNull(
                () => new ModelMetadata(null /* provider */, null /* containerType */, null /* model */, typeof(object), null /* propertyName */),
                "provider");
        }

        [Fact]
        public void NullTypeThrows()
        {
            // Arrange
            Mock<ModelMetadataProvider> provider = new Mock<ModelMetadataProvider>();

            // Act & Assert
            Assert.ThrowsArgumentNull(
                () => new ModelMetadata(provider.Object, null /* containerType */, null /* model */, null /* modelType */, null /* propertyName */),
                "modelType");
        }

        // Constructor

        [Fact]
        public void DefaultValues()
        {
            // Arrange
            Mock<ModelMetadataProvider> provider = new Mock<ModelMetadataProvider>();

            // Act
            ModelMetadata metadata = new ModelMetadata(provider.Object, typeof(Exception), () => "model", typeof(string), "propertyName");

            // Assert
            Assert.Equal(typeof(Exception), metadata.ContainerType);
            Assert.True(metadata.ConvertEmptyStringToNull);
            Assert.Null(metadata.DataTypeName);
            Assert.Null(metadata.Description);
            Assert.Null(metadata.DisplayFormatString);
            Assert.Null(metadata.DisplayName);
            Assert.Null(metadata.EditFormatString);
            Assert.False(metadata.HideSurroundingHtml);
            Assert.Equal("model", metadata.Model);
            Assert.Equal(typeof(string), metadata.ModelType);
            Assert.Null(metadata.NullDisplayText);
            Assert.Equal(10000, metadata.Order);
            Assert.Equal("propertyName", metadata.PropertyName);
            Assert.False(metadata.IsReadOnly);
            Assert.True(metadata.RequestValidationEnabled);
            Assert.Null(metadata.ShortDisplayName);
            Assert.True(metadata.ShowForDisplay);
            Assert.True(metadata.ShowForEdit);
            Assert.Null(metadata.TemplateHint);
            Assert.Null(metadata.Watermark);
        }

        // IsComplexType

        struct IsComplexTypeModel
        {
        }

        [Fact]
        public void IsComplexTypeTests()
        {
            // Arrange
            Mock<ModelMetadataProvider> provider = new Mock<ModelMetadataProvider>();

            // Act & Assert
            Assert.True(new ModelMetadata(provider.Object, null, null, typeof(Object), null).IsComplexType);
            Assert.False(new ModelMetadata(provider.Object, null, null, typeof(string), null).IsComplexType);
            Assert.True(new ModelMetadata(provider.Object, null, null, typeof(IDisposable), null).IsComplexType);
            Assert.False(new ModelMetadata(provider.Object, null, null, typeof(Nullable<int>), null).IsComplexType);
            Assert.False(new ModelMetadata(provider.Object, null, null, typeof(int), null).IsComplexType);
            Assert.True(new ModelMetadata(provider.Object, null, null, typeof(IsComplexTypeModel), null).IsComplexType);
            Assert.True(new ModelMetadata(provider.Object, null, null, typeof(Nullable<IsComplexTypeModel>), null).IsComplexType);
        }

        // IsNullableValueType

        [Fact]
        public void IsNullableValueTypeTests()
        {
            // Arrange
            Mock<ModelMetadataProvider> provider = new Mock<ModelMetadataProvider>();

            // Act & Assert
            Assert.False(new ModelMetadata(provider.Object, null, null, typeof(string), null).IsNullableValueType);
            Assert.False(new ModelMetadata(provider.Object, null, null, typeof(IDisposable), null).IsNullableValueType);
            Assert.True(new ModelMetadata(provider.Object, null, null, typeof(Nullable<int>), null).IsNullableValueType);
            Assert.False(new ModelMetadata(provider.Object, null, null, typeof(int), null).IsNullableValueType);
        }

        // IsRequired

        [Fact]
        public void IsRequiredTests()
        {
            // Arrange
            Mock<ModelMetadataProvider> provider = new Mock<ModelMetadataProvider>();

            // Act & Assert
            Assert.False(new ModelMetadata(provider.Object, null, null, typeof(string), null).IsRequired); // Reference type not required
            Assert.False(new ModelMetadata(provider.Object, null, null, typeof(IDisposable), null).IsRequired); // Interface not required
            Assert.False(new ModelMetadata(provider.Object, null, null, typeof(Nullable<int>), null).IsRequired); // Nullable value type not required
            Assert.True(new ModelMetadata(provider.Object, null, null, typeof(int), null).IsRequired); // Value type required
            Assert.True(new ModelMetadata(provider.Object, null, null, typeof(DayOfWeek), null).IsRequired); // Enum (implicit value type) is required
        }

        // Properties

        [Fact]
        public void PropertiesCallsProvider()
        {
            // Arrange
            Type modelType = typeof(string);
            List<ModelMetadata> propertyMetadata = new List<ModelMetadata>();
            Mock<ModelMetadataProvider> provider = new Mock<ModelMetadataProvider>();
            ModelMetadata metadata = new ModelMetadata(provider.Object, null, null, modelType, null);
            provider.Setup(p => p.GetMetadataForProperties(null, modelType))
                .Returns(propertyMetadata)
                .Verifiable();

            // Act
            IEnumerable<ModelMetadata> result = metadata.Properties;

            // Assert
            Assert.Equal(propertyMetadata, result.ToList());
            provider.Verify();
        }

        [Fact]
        public void PropertiesUsesRealModelTypeRatherThanPassedModelType()
        {
            // Arrange
            string model = "String Value";
            Expression<Func<object, object>> accessor = _ => model;
            ModelMetadata metadata = ModelMetadata.FromLambdaExpression(accessor, new ViewDataDictionary<object>());

            // Act
            IEnumerable<ModelMetadata> result = metadata.Properties;

            // Assert
            Assert.Equal("Length", result.Single().PropertyName);
        }

        [Fact]
        public void PropertiesAreSortedByOrder()
        {
            // Arrange
            Type modelType = typeof(string);
            Mock<ModelMetadataProvider> provider = new Mock<ModelMetadataProvider>();
            List<ModelMetadata> propertyMetadata = new List<ModelMetadata>
            {
                new ModelMetadata(provider.Object, null, () => 1, typeof(int), null) { Order = 20 },
                new ModelMetadata(provider.Object, null, () => 2, typeof(int), null) { Order = 30 },
                new ModelMetadata(provider.Object, null, () => 3, typeof(int), null) { Order = 10 },
            };
            ModelMetadata metadata = new ModelMetadata(provider.Object, null, null, modelType, null);
            provider.Setup(p => p.GetMetadataForProperties(null, modelType))
                .Returns(propertyMetadata)
                .Verifiable();

            // Act
            List<ModelMetadata> result = metadata.Properties.ToList();

            // Assert
            Assert.Equal(3, result.Count);
            Assert.Equal(3, result[0].Model);
            Assert.Equal(1, result[1].Model);
            Assert.Equal(2, result[2].Model);
        }

        [Fact]
        public void PropertiesListGetsResetWhenModelGetsReset()
        { // Dev10 Bug #923263
            // Arrange
            var provider = new DataAnnotationsModelMetadataProvider();
            var metadata = new ModelMetadata(provider, null, () => new Class1(), typeof(Class1), null);

            // Act
            ModelMetadata[] originalProps = metadata.Properties.ToArray();
            metadata.Model = new Class2();
            ModelMetadata[] newProps = metadata.Properties.ToArray();

            // Assert
            ModelMetadata originalProp = Assert.Single(originalProps);
            Assert.Equal(typeof(string), originalProp.ModelType);
            Assert.Equal("Prop1", originalProp.PropertyName);
            ModelMetadata newProp = Assert.Single(newProps);
            Assert.Equal(typeof(int), newProp.ModelType);
            Assert.Equal("Prop2", newProp.PropertyName);
        }

        class Class1
        {
            public string Prop1 { get; set; }
        }

        class Class2
        {
            public int Prop2 { get; set; }
        }

        // SimpleDisplayText

        [Fact]
        public void SimpleDisplayTextReturnsNullDisplayTextForNullModel()
        {
            // Arrange
            string nullText = "(null)";
            Mock<ModelMetadataProvider> provider = new Mock<ModelMetadataProvider>();
            ModelMetadata metadata = new ModelMetadata(provider.Object, null, null, typeof(object), null) { NullDisplayText = nullText };

            // Act
            string result = metadata.SimpleDisplayText;

            // Assert
            Assert.Equal(nullText, result);
        }

        private class SimpleDisplayTextModelWithToString
        {
            public override string ToString()
            {
                return "Custom ToString Value";
            }
        }

        [Fact]
        public void SimpleDisplayTextReturnsToStringValueWhenOverridden()
        {
            // Arrange
            SimpleDisplayTextModelWithToString model = new SimpleDisplayTextModelWithToString();
            EmptyModelMetadataProvider provider = new EmptyModelMetadataProvider();
            ModelMetadata metadata = new ModelMetadata(provider, null, () => model, typeof(SimpleDisplayTextModelWithToString), null);

            // Act
            string result = metadata.SimpleDisplayText;

            // Assert
            Assert.Equal(model.ToString(), result);
        }

        private class SimpleDisplayTextModelWithoutToString
        {
            public string FirstProperty { get; set; }

            public int SecondProperty { get; set; }
        }

        [Fact]
        public void SimpleDisplayTextReturnsFirstPropertyValueForNonNullModel()
        {
            // Arrange
            SimpleDisplayTextModelWithoutToString model = new SimpleDisplayTextModelWithoutToString
            {
                FirstProperty = "First Property Value"
            };
            EmptyModelMetadataProvider provider = new EmptyModelMetadataProvider();
            ModelMetadata metadata = new ModelMetadata(provider, null, () => model, typeof(SimpleDisplayTextModelWithoutToString), null);

            // Act
            string result = metadata.SimpleDisplayText;

            // Assert
            Assert.Equal(model.FirstProperty, result);
        }

        [Fact]
        public void SimpleDisplayTextReturnsFirstPropertyNullDisplayTextForNonNullModelWithNullDisplayColumnPropertyValue()
        {
            // Arrange
            SimpleDisplayTextModelWithoutToString model = new SimpleDisplayTextModelWithoutToString();
            EmptyModelMetadataProvider propertyProvider = new EmptyModelMetadataProvider();
            ModelMetadata propertyMetadata = propertyProvider.GetMetadataForProperty(() => model.FirstProperty, typeof(SimpleDisplayTextModelWithoutToString), "FirstProperty");
            propertyMetadata.NullDisplayText = "Null Display Text";
            Mock<ModelMetadataProvider> provider = new Mock<ModelMetadataProvider>();
            provider.Setup(p => p.GetMetadataForProperties(model, typeof(SimpleDisplayTextModelWithoutToString)))
                .Returns(new[] { propertyMetadata });
            ModelMetadata metadata = new ModelMetadata(provider.Object, null, () => model, typeof(SimpleDisplayTextModelWithoutToString), null);

            // Act
            string result = metadata.SimpleDisplayText;

            // Assert
            Assert.Equal(propertyMetadata.NullDisplayText, result);
        }

        private class SimpleDisplayTextModelWithNoProperties
        {
        }

        [Fact]
        public void SimpleDisplayTextReturnsEmptyStringForNonNullModelWithNoVisibleProperties()
        {
            // Arrange
            SimpleDisplayTextModelWithNoProperties model = new SimpleDisplayTextModelWithNoProperties();
            EmptyModelMetadataProvider provider = new EmptyModelMetadataProvider();
            ModelMetadata metadata = new ModelMetadata(provider, null, () => model, typeof(SimpleDisplayTextModelWithNoProperties), null);

            // Act
            string result = metadata.SimpleDisplayText;

            // Assert
            Assert.Equal(String.Empty, result);
        }

        private class ObjectWithToStringOverride
        {
            private string _toStringValue;

            public ObjectWithToStringOverride(string toStringValue)
            {
                _toStringValue = toStringValue;
            }

            public override string ToString()
            {
                return _toStringValue;
            }
        }

        [Fact]
        public void SimpleDisplayTextReturnsToStringOfModelForNonNullModel()
        {
            // Arrange
            string toStringText = "text from ToString()";
            ObjectWithToStringOverride model = new ObjectWithToStringOverride(toStringText);
            Mock<ModelMetadataProvider> provider = new Mock<ModelMetadataProvider>();
            ModelMetadata metadata = new ModelMetadata(provider.Object, null, () => model, typeof(ObjectWithToStringOverride), null);

            // Act
            string result = metadata.SimpleDisplayText;

            // Assert
            Assert.Equal(toStringText, result);
        }

        [Fact]
        public void SimpleDisplayTextReturnsEmptyStringForNonNullModelWithToStringNull()
        {
            // Arrange
            string toStringText = null;
            ObjectWithToStringOverride model = new ObjectWithToStringOverride(toStringText);
            Mock<ModelMetadataProvider> provider = new Mock<ModelMetadataProvider>();
            ModelMetadata metadata = new ModelMetadata(provider.Object, null, () => model, typeof(ObjectWithToStringOverride), null);

            // Act
            string result = metadata.SimpleDisplayText;

            // Assert
            Assert.Equal(String.Empty, result);
        }

        // FromStringExpression()

        [Fact]
        public void FromStringExpressionGuardClauses()
        {
            // Null expression throws
            Assert.ThrowsArgumentNull(
                () => ModelMetadata.FromStringExpression(null, new ViewDataDictionary()),
                "expression");

            // Null view data dictionary throws
            Assert.ThrowsArgumentNull(
                () => ModelMetadata.FromStringExpression("expression", null),
                "viewData");
        }

        [Fact]
        public void FromStringExpressionEmptyExpressionReturnsExistingModelMetadata()
        {
            // Arrange
            Mock<ModelMetadataProvider> provider = new Mock<ModelMetadataProvider>();
            ModelMetadata metadata = new ModelMetadata(provider.Object, null, null, typeof(object), null);
            ViewDataDictionary viewData = new ViewDataDictionary();
            viewData.ModelMetadata = metadata;

            // Act
            ModelMetadata result = ModelMetadata.FromStringExpression(String.Empty, viewData, provider.Object);

            // Assert
            Assert.Same(metadata, result);
        }

        [Fact]
        public void FromStringExpressionItemNotFoundInViewData()
        {
            // Arrange
            Mock<ModelMetadataProvider> provider = new Mock<ModelMetadataProvider>();
            ViewDataDictionary viewData = new ViewDataDictionary();
            provider.Setup(p => p.GetMetadataForType(It.IsAny<Func<object>>(), It.IsAny<Type>()))
                .Callback<Func<object>, Type>((accessor, type) =>
                {
                    Assert.Null(accessor);
                    Assert.Equal(typeof(string), type); // Don't know the type, must fall back on string
                })
                .Returns(() => null)
                .Verifiable();

            // Act
            ModelMetadata.FromStringExpression("UnknownObject", viewData, provider.Object);

            // Assert
            provider.Verify();
        }

        [Fact]
        public void FromStringExpressionNullItemFoundAtRootOfViewData()
        {
            // Arrange
            Mock<ModelMetadataProvider> provider = new Mock<ModelMetadataProvider>();
            ViewDataDictionary viewData = new ViewDataDictionary();
            viewData["Object"] = null;
            provider.Setup(p => p.GetMetadataForType(It.IsAny<Func<object>>(), It.IsAny<Type>()))
                .Callback<Func<object>, Type>((accessor, type) =>
                {
                    Assert.Null(accessor());
                    Assert.Equal(typeof(string), type); // Don't know the type, must fall back on string
                })
                .Returns(() => null)
                .Verifiable();

            // Act
            ModelMetadata.FromStringExpression("Object", viewData, provider.Object);

            // Assert
            provider.Verify();
        }

        [Fact]
        public void FromStringExpressionNonNullItemFoundAtRootOfViewData()
        {
            // Arrange
            Mock<ModelMetadataProvider> provider = new Mock<ModelMetadataProvider>();
            object model = new object();
            ViewDataDictionary viewData = new ViewDataDictionary();
            viewData["Object"] = model;
            provider.Setup(p => p.GetMetadataForType(It.IsAny<Func<object>>(), It.IsAny<Type>()))
                .Callback<Func<object>, Type>((accessor, type) =>
                {
                    Assert.Same(model, accessor());
                    Assert.Equal(typeof(object), type);
                })
                .Returns(() => null)
                .Verifiable();

            // Act
            ModelMetadata.FromStringExpression("Object", viewData, provider.Object);

            // Assert
            provider.Verify();
        }

        [Fact]
        public void FromStringExpressionNullItemFoundOnPropertyOfItemInViewData()
        {
            // Arrange
            Mock<ModelMetadataProvider> provider = new Mock<ModelMetadataProvider>();
            DummyModelContainer model = new DummyModelContainer();
            ViewDataDictionary viewData = new ViewDataDictionary();
            viewData["Object"] = model;
            provider.Setup(p => p.GetMetadataForProperty(It.IsAny<Func<object>>(), It.IsAny<Type>(), It.IsAny<string>()))
                .Callback<Func<object>, Type, string>((accessor, type, propertyName) =>
                {
                    Assert.Null(accessor());
                    Assert.Equal(typeof(DummyModelContainer), type);
                    Assert.Equal("Model", propertyName);
                })
                .Returns(() => null)
                .Verifiable();

            // Act
            ModelMetadata.FromStringExpression("Object.Model", viewData, provider.Object);

            // Assert
            provider.Verify();
        }

        [Fact]
        public void FromStringExpressionNonNullItemFoundOnPropertyOfItemInViewData()
        {
            // Arrange
            Mock<ModelMetadataProvider> provider = new Mock<ModelMetadataProvider>();
            DummyModelContainer model = new DummyModelContainer { Model = new DummyContactModel() };
            ViewDataDictionary viewData = new ViewDataDictionary();
            viewData["Object"] = model;
            provider.Setup(p => p.GetMetadataForProperty(It.IsAny<Func<object>>(), It.IsAny<Type>(), It.IsAny<string>()))
                .Callback<Func<object>, Type, string>((accessor, type, propertyName) =>
                {
                    Assert.Same(model.Model, accessor());
                    Assert.Equal(typeof(DummyModelContainer), type);
                    Assert.Equal("Model", propertyName);
                })
                .Returns(() => null)
                .Verifiable();

            // Act
            ModelMetadata.FromStringExpression("Object.Model", viewData, provider.Object);

            // Assert
            provider.Verify();
        }

        [Fact]
        public void FromStringExpressionWithNullModelButValidModelMetadataShouldReturnProperPropertyMetadata()
        {
            // Arrange
            ViewDataDictionary viewData = new ViewDataDictionary();
            viewData.ModelMetadata = ModelMetadataProviders.Current.GetMetadataForType(null, typeof(DummyContactModel));

            // Act
            ModelMetadata result = ModelMetadata.FromStringExpression("NullableIntValue", viewData);

            // Assert
            Assert.Null(result.Model);
            Assert.Equal(typeof(Nullable<int>), result.ModelType);
            Assert.Equal("NullableIntValue", result.PropertyName);
            Assert.Equal(typeof(DummyContactModel), result.ContainerType);
        }

        [Fact]
        public void FromStringExpressionValueInModelProperty()
        {
            // Arrange
            DummyContactModel model = new DummyContactModel { FirstName = "John" };
            ViewDataDictionary viewData = new ViewDataDictionary(model);

            // Act
            ModelMetadata metadata = ModelMetadata.FromStringExpression("FirstName", viewData);

            // Assert
            Assert.Equal("John", metadata.Model);
        }

        [Fact]
        public void FromStringExpressionValueInViewDataOverridesValueFromModelProperty()
        {
            // Arrange
            DummyContactModel model = new DummyContactModel { FirstName = "John" };
            ViewDataDictionary viewData = new ViewDataDictionary(model);
            viewData["FirstName"] = "Jim";

            // Act
            ModelMetadata metadata = ModelMetadata.FromStringExpression("FirstName", viewData);

            // Assert
            Assert.Equal("Jim", metadata.Model);
        }

        // FromLambdaExpression()

        [Fact]
        public void FromLambdaExpressionGuardClauseTests()
        {
            // Null expression throws
            Assert.ThrowsArgumentNull(
                () => ModelMetadata.FromLambdaExpression<string, object>(null, new ViewDataDictionary<string>()),
                "expression");

            // Null view data throws
            Assert.ThrowsArgumentNull(
                () => ModelMetadata.FromLambdaExpression<string, object>(m => m, null),
                "viewData");

            // Unsupported expression type throws
            Assert.Throws<InvalidOperationException>(
                () => ModelMetadata.FromLambdaExpression<string, object>(m => new Object(), new ViewDataDictionary<string>()),
                "Templates can be used only with field access, property access, single-dimension array index, or single-parameter custom indexer expressions.");
        }

        [Fact]
        public void FromLambdaExpressionModelIdentityExpressionReturnsExistingModelMetadata()
        {
            // Arrange
            Mock<ModelMetadataProvider> provider = new Mock<ModelMetadataProvider>();
            ModelMetadata metadata = new ModelMetadata(provider.Object, null, null, typeof(object), null);
            ViewDataDictionary<object> viewData = new ViewDataDictionary<object>();
            viewData.ModelMetadata = metadata;

            // Act
            ModelMetadata result = ModelMetadata.FromLambdaExpression<object, object>(m => m, viewData, provider.Object);

            // Assert
            Assert.Same(metadata, result);
        }

        [Fact]
        public void FromLambdaExpressionPropertyExpressionFromParameter()
        {
            // Arrange
            Mock<ModelMetadataProvider> provider = new Mock<ModelMetadataProvider>();
            DummyContactModel model = new DummyContactModel { FirstName = "Test" };
            ViewDataDictionary<DummyContactModel> viewData = new ViewDataDictionary<DummyContactModel>(model);
            provider.Setup(p => p.GetMetadataForProperty(It.IsAny<Func<object>>(), It.IsAny<Type>(), It.IsAny<string>()))
                .Callback<Func<object>, Type, string>((accessor, type, propertyName) =>
                {
                    Assert.Equal("Test", accessor());
                    Assert.Equal(typeof(DummyContactModel), type);
                    Assert.Equal("FirstName", propertyName);
                })
                .Returns(() => null)
                .Verifiable();

            // Act
            ModelMetadata.FromLambdaExpression<DummyContactModel, string>(m => m.FirstName, viewData, provider.Object);

            // Assert
            provider.Verify();
        }

        [Fact]
        public void FromLambdaExpressionPropertyExpressionFromClosureValue()
        {
            // Arrange
            Mock<ModelMetadataProvider> provider = new Mock<ModelMetadataProvider>();
            DummyContactModel model = new DummyContactModel { FirstName = "Test" };
            ViewDataDictionary<object> viewData = new ViewDataDictionary<object>();
            provider.Setup(p => p.GetMetadataForProperty(It.IsAny<Func<object>>(), It.IsAny<Type>(), It.IsAny<string>()))
                .Callback<Func<object>, Type, string>((accessor, type, propertyName) =>
                {
                    Assert.Equal("Test", accessor());
                    Assert.Equal(typeof(DummyContactModel), type);
                    Assert.Equal("FirstName", propertyName);
                })
                .Returns(() => null)
                .Verifiable();

            // Act
            ModelMetadata.FromLambdaExpression<object, string>(m => model.FirstName, viewData, provider.Object);

            // Assert
            provider.Verify();
        }

        [Fact]
        public void FromLambdaExpressionFieldExpressionFromParameter()
        {
            // Arrange
            Mock<ModelMetadataProvider> provider = new Mock<ModelMetadataProvider>();
            DummyContactModel model = new DummyContactModel { IntField = 42 };
            ViewDataDictionary<DummyContactModel> viewData = new ViewDataDictionary<DummyContactModel>(model);
            provider.Setup(p => p.GetMetadataForType(It.IsAny<Func<object>>(), It.IsAny<Type>()))
                .Callback<Func<object>, Type>((accessor, type) =>
                {
                    Assert.Equal(42, accessor());
                    Assert.Equal(typeof(int), type);
                })
                .Returns(() => null)
                .Verifiable();

            // Act
            ModelMetadata.FromLambdaExpression<DummyContactModel, int>(m => m.IntField, viewData, provider.Object);

            // Assert
            provider.Verify();
        }

        [Fact]
        public void FromLambdaExpressionFieldExpressionFromFieldOfClosureValue()
        {
            // Arrange
            Mock<ModelMetadataProvider> provider = new Mock<ModelMetadataProvider>();
            DummyContactModel model = new DummyContactModel { IntField = 42 };
            ViewDataDictionary<object> viewData = new ViewDataDictionary<object>();
            provider.Setup(p => p.GetMetadataForType(It.IsAny<Func<object>>(), It.IsAny<Type>()))
                .Callback<Func<object>, Type>((accessor, type) =>
                {
                    Assert.Equal(42, accessor());
                    Assert.Equal(typeof(int), type);
                })
                .Returns(() => null)
                .Verifiable();

            // Act
            ModelMetadata.FromLambdaExpression<object, int>(m => model.IntField, viewData, provider.Object);

            // Assert
            provider.Verify();
        }

        [Fact]
        public void FromLambdaExpressionFieldExpressionFromClosureValue()
        {
            // Arrange
            Mock<ModelMetadataProvider> provider = new Mock<ModelMetadataProvider>();
            DummyContactModel model = new DummyContactModel();
            ViewDataDictionary<object> viewData = new ViewDataDictionary<object>();
            provider.Setup(p => p.GetMetadataForType(It.IsAny<Func<object>>(), It.IsAny<Type>()))
                .Callback<Func<object>, Type>((accessor, type) =>
                {
                    Assert.Same(model, accessor());
                    Assert.Equal(typeof(DummyContactModel), type);
                })
                .Returns(() => null)
                .Verifiable();

            // Act
            ModelMetadata.FromLambdaExpression<object, DummyContactModel>(m => model, viewData, provider.Object);

            // Assert
            provider.Verify();
        }

        [Fact]
        public void FromLambdaExpressionSingleParameterClassIndexer()
        {
            // Arrange
            Mock<ModelMetadataProvider> provider = new Mock<ModelMetadataProvider>();
            DummyContactModel model = new DummyContactModel();
            ViewDataDictionary<DummyContactModel> viewData = new ViewDataDictionary<DummyContactModel>(model);
            provider.Setup(p => p.GetMetadataForType(It.IsAny<Func<object>>(), It.IsAny<Type>()))
                .Callback<Func<object>, Type>((accessor, type) =>
                {
                    Assert.Equal("Indexed into 42", accessor());
                    Assert.Equal(typeof(string), type);
                })
                .Returns(() => null)
                .Verifiable();

            // Act
            ModelMetadata.FromLambdaExpression<DummyContactModel, string>(m => m[42], viewData, provider.Object);

            // Assert
            provider.Verify();
        }

        [Fact]
        public void FromLambdaExpressionSingleDimensionArrayIndex()
        {
            // Arrange
            Mock<ModelMetadataProvider> provider = new Mock<ModelMetadataProvider>();
            DummyContactModel model = new DummyContactModel { Array = new[] { 4, 8, 15, 16, 23, 42 } };
            ViewDataDictionary<DummyContactModel> viewData = new ViewDataDictionary<DummyContactModel>(model);
            provider.Setup(p => p.GetMetadataForType(It.IsAny<Func<object>>(), It.IsAny<Type>()))
                .Callback<Func<object>, Type>((accessor, type) =>
                {
                    Assert.Equal(16, accessor());
                    Assert.Equal(typeof(int), type);
                })
                .Returns(() => null)
                .Verifiable();

            // Act
            ModelMetadata.FromLambdaExpression<DummyContactModel, int>(m => m.Array[3], viewData, provider.Object);

            // Assert
            provider.Verify();
        }

        [Fact]
        public void FromLambdaExpressionNullReferenceExceptionsInPropertyExpressionPreserveAllExpressionInformation()
        {
            // Arrange
            Mock<ModelMetadataProvider> provider = new Mock<ModelMetadataProvider>();
            ViewDataDictionary<DummyContactModel> viewData = new ViewDataDictionary<DummyContactModel>();
            provider.Setup(p => p.GetMetadataForProperty(It.IsAny<Func<object>>(), It.IsAny<Type>(), It.IsAny<string>()))
                .Callback<Func<object>, Type, string>((accessor, type, propertyName) =>
                {
                    Assert.Null(accessor());
                    Assert.Equal(typeof(DummyContactModel), type);
                    Assert.Equal("FirstName", propertyName);
                })
                .Returns(() => null)
                .Verifiable();

            // Act
            ModelMetadata.FromLambdaExpression<DummyContactModel, string>(m => m.FirstName, viewData, provider.Object);

            // Assert
            provider.Verify();
        }

        [Fact]
        public void FromLambdaExpressionSetsContainerTypeToDerivedMostType()
        { // Dev10 Bug #868619
            // Arrange
            Mock<ModelMetadataProvider> provider = new Mock<ModelMetadataProvider>();
            ViewDataDictionary<DerivedModel> viewData = new ViewDataDictionary<DerivedModel>();
            provider.Setup(p => p.GetMetadataForProperty(It.IsAny<Func<object>>(), It.IsAny<Type>(), It.IsAny<string>()))
                .Callback<Func<object>, Type, string>((accessor, type, propertyName) =>
                {
                    Assert.Null(accessor());
                    Assert.Equal(typeof(DerivedModel), type);
                    Assert.Equal("MyProperty", propertyName);
                })
                .Returns(() => null)
                .Verifiable();

            // Act
            ModelMetadata.FromLambdaExpression<DerivedModel, string>(m => m.MyProperty, viewData, provider.Object);

            // Assert
            provider.Verify();
        }

        private class BaseModel
        {
            public virtual string MyProperty { get; set; }
        }

        private class DerivedModel : BaseModel
        {
            [Required]
            public override string MyProperty
            {
                get { return base.MyProperty; }
                set { base.MyProperty = value; }
            }
        }

        // GetDisplayName()

        [Fact]
        public void ReturnsDisplayNameWhenSet()
        {
            // Arrange
            Mock<ModelMetadataProvider> provider = new Mock<ModelMetadataProvider>();
            ModelMetadata metadata = new ModelMetadata(provider.Object, null, null, typeof(object), "PropertyName") { DisplayName = "Display Name" };

            // Act
            string result = metadata.GetDisplayName();

            // Assert
            Assert.Equal("Display Name", result);
        }

        [Fact]
        public void ReturnsPropertyNameWhenSetAndDisplayNameIsNull()
        {
            // Arrange
            Mock<ModelMetadataProvider> provider = new Mock<ModelMetadataProvider>();
            ModelMetadata metadata = new ModelMetadata(provider.Object, null, null, typeof(object), "PropertyName");

            // Act
            string result = metadata.GetDisplayName();

            // Assert
            Assert.Equal("PropertyName", result);
        }

        [Fact]
        public void ReturnsTypeNameWhenPropertyNameAndDisplayNameAreNull()
        {
            // Arrange
            Mock<ModelMetadataProvider> provider = new Mock<ModelMetadataProvider>();
            ModelMetadata metadata = new ModelMetadata(provider.Object, null, null, typeof(object), null);

            // Act
            string result = metadata.GetDisplayName();

            // Assert
            Assert.Equal("Object", result);
        }

        // Helpers

        private class DummyContactModel
        {
            public int IntField = 0;
            public string FirstName { get; set; }
            public string LastName { get; set; }
            public Nullable<int> NullableIntValue { get; set; }
            public int[] Array { get; set; }

            public string this[int index]
            {
                get { return "Indexed into " + index; }
            }
        }

        private class DummyModelContainer
        {
            public DummyContactModel Model { get; set; }
        }
    }
}
