public void RequestForEnumTypeReturnsResultAsString(
Type enumType, int requestCount, string expectedResult)
{
// Arrange
var enumDataTypeAttribute = new EnumDataTypeAttribute(enumType);
var providedAttribute = new ProvidedAttribute(enumDataTypeAttribute, true);
var request = new FakeMemberInfo(providedAttribute);
var dummyContext = new DelegatingSpecimenContext();
var sut = new EnumDataTypeAttributeRelay
{
RequestMemberTypeResolver = new DelegatingRequestMemberTypeResolver
{
OnTryGetMemberType = _ => typeof(string)
}
};
// Act
var result = Enumerable
.Repeat <Func <object> >(() => sut.Create(request, dummyContext), requestCount)
.Select(f => f()).ToArray().Last();
// Assert
Assert.Equal(expectedResult, result);
}
public void CanCorrectlyInterleaveDifferentEnumTypes(Type enumType, string expectedResult)
{
// Arrange
var enumDataTypeAttribute = new EnumDataTypeAttribute(enumType);
var providedAttribute = new ProvidedAttribute(enumDataTypeAttribute, true);
var request = new FakeMemberInfo(providedAttribute);
var dummyContext = new DelegatingSpecimenContext();
var sut = new EnumDataTypeAttributeRelay
{
RequestMemberTypeResolver = new DelegatingRequestMemberTypeResolver
{
OnTryGetMemberType = _ => typeof(string)
}
};
var triStateEnumDataTypeAttribute = new EnumDataTypeAttribute(typeof(TriState));
var triStateProvidedAttribute = new ProvidedAttribute(triStateEnumDataTypeAttribute, true);
var dayOfWeekEnumDataTypeAttribute = new EnumDataTypeAttribute(typeof(DayOfWeek));
var dayOfWeekProvidedAttribute = new ProvidedAttribute(dayOfWeekEnumDataTypeAttribute, true);
sut.Create(new FakeMemberInfo(triStateProvidedAttribute), dummyContext);
sut.Create(new FakeMemberInfo(triStateProvidedAttribute), dummyContext);
sut.Create(new FakeMemberInfo(dayOfWeekProvidedAttribute), dummyContext);
// Act
var result = sut.Create(request, dummyContext);
// Assert
Assert.Equal(expectedResult, result);
}
private DataTypeRegistration BuildEnumRegistration(Type type)
{
_locks.TakeOrWait(type);
DataTypeRegistration dataTypeRegistration;
if (_register.TryGetRegistration(type, out dataTypeRegistration))
{
_locks.Release(type);
return(dataTypeRegistration);
}
var attr = type.GetCodeFirstAttribute <DataTypeAttribute>();
if (attr == null)
{
attr = new EnumDataTypeAttribute();
attr.Initialise(type);
}
dataTypeRegistration = new DataTypeRegistration()
{
ClrType = type,
ConverterType = attr.ConverterType,
PropertyEditorAlias = attr.PropertyEditorAlias,
DataTypeInstanceName = attr.Name,
UmbracoDatabaseType = attr.DbType,
CodeFirstControlled = true
};
_registerController.Register(type, dataTypeRegistration);
_locks.Release(type);
return(dataTypeRegistration);
}
public static void Ctor(Type enumType)
{
var attribute = new EnumDataTypeAttribute(enumType);
Assert.Equal(DataType.Custom, attribute.DataType);
Assert.Equal("Enumeration", attribute.CustomDataType);
Assert.Equal(enumType, attribute.EnumType);
}
public static void Ctor(Type enumType)
{
var attribute = new EnumDataTypeAttribute(enumType);
Assert.Equal(DataType.Custom, attribute.DataType);
Assert.Equal("Enumeration", attribute.CustomDataType);
Assert.Equal(enumType, attribute.EnumType);
}
public void Constructor()
{
var attr = new EnumDataTypeAttribute(typeof(string));
Assert.AreEqual(DataType.Custom, attr.DataType, "#A1-1");
Assert.AreEqual(typeof(string), attr.EnumType, "#A1-2");
attr = new EnumDataTypeAttribute(typeof(TestEnum));
Assert.AreEqual(DataType.Custom, attr.DataType, "#B1-1");
Assert.AreEqual(typeof(TestEnum), attr.EnumType, "#B1-2");
attr = new EnumDataTypeAttribute(null);
Assert.AreEqual(DataType.Custom, attr.DataType, "#C1-1");
Assert.AreEqual(null, attr.EnumType, "#C1-2");
}
public static EnumDataTypeAttribute CreateEnumDataTypeAttribute(this XElement annotation)
{
const string NAME = "EnumDataType";
string name = annotation.Attribute(SchemaVocab.Name).Value;
if (name != NAME)
{
throw new ArgumentException(string.Format(SchemaMessages.ExpectedBut, NAME, name));
}
string enumType = annotation.GetArgumentValue("EnumType");
Type type = GetType(enumType);
EnumDataTypeAttribute attribute = new EnumDataTypeAttribute(type);
FillValidationAttribute(attribute, annotation);
return(attribute);
}
public void ReturnsNoSpecimenWhenEnumGeneratorReturnsNoSpecimen(Type enumType)
{
// Arrange
var enumDataTypeAttribute = new EnumDataTypeAttribute(enumType);
var providedAttribute = new ProvidedAttribute(enumDataTypeAttribute, true);
var request = new FakeMemberInfo(providedAttribute);
var enumGenerator = new DelegatingSpecimenBuilder
{
OnCreate = (_, _) => new NoSpecimen()
};
var sut = new EnumDataTypeAttributeRelay(enumGenerator);
// Act
var actual = sut.Create(request, null);
// Assert
Assert.IsType <NoSpecimen>(actual);
}
public void RequestForEnumWithNoValuesThrows()
{
// Arrange
var enumDataTypeAttribute = new EnumDataTypeAttribute(typeof(EmptyEnum));
var providedAttribute = new ProvidedAttribute(enumDataTypeAttribute, true);
var request = new FakeMemberInfo(providedAttribute);
var dummyContext = new DelegatingSpecimenContext();
var sut = new EnumDataTypeAttributeRelay
{
RequestMemberTypeResolver = new DelegatingRequestMemberTypeResolver
{
OnTryGetMemberType = _ => typeof(string)
}
};
// Act & assert
Assert.Throws <ObjectCreationException>(() => sut.Create(request, dummyContext));
}
public void ReturnsNoSpecimenWhenResolverReturnsNoSpecimen(Type enumType)
{
// Arrange
var enumDataTypeAttribute = new EnumDataTypeAttribute(enumType);
var providedAttribute = new ProvidedAttribute(enumDataTypeAttribute, true);
var request = new FakeMemberInfo(providedAttribute);
var sut = new EnumDataTypeAttributeRelay
{
RequestMemberTypeResolver = new DelegatingRequestMemberTypeResolver
{
OnTryGetMemberType = _ => null
}
};
// Act
var actual = sut.Create(request, null);
// Assert
Assert.IsType <NoSpecimen>(actual);
}
public void RequestReturnsExpectedResultForEnumMemberType(Type enumType, Type memberType, object expectedResult)
{
// Arrange
var enumDataTypeAttribute = new EnumDataTypeAttribute(enumType);
var providedAttribute = new ProvidedAttribute(enumDataTypeAttribute, true);
var request = new FakeMemberInfo(providedAttribute);
var dummyContext = new DelegatingSpecimenContext();
var sut = new EnumDataTypeAttributeRelay
{
RequestMemberTypeResolver = new DelegatingRequestMemberTypeResolver
{
OnTryGetMemberType = _ => memberType
}
};
// Act
var actual = sut.Create(request, dummyContext);
// Assert
Assert.Equal(expectedResult, actual);
}
public void ReturnsNoSpecimenResultForCustomClassMemberType(Type enumType, Type memberType)
{
// Arrange
var enumDataTypeAttribute = new EnumDataTypeAttribute(enumType);
var providedAttribute = new ProvidedAttribute(enumDataTypeAttribute, true);
var request = new FakeMemberInfo(providedAttribute);
var dummyContext = new DelegatingSpecimenContext();
var sut = new EnumDataTypeAttributeRelay
{
RequestMemberTypeResolver = new DelegatingRequestMemberTypeResolver
{
OnTryGetMemberType = _ => memberType
}
};
// Act
var actual = sut.Create(request, dummyContext);
// Assert
Assert.IsType <NoSpecimen>(actual);
}
private static void AddEnumFacet(EnumDataTypeAttribute attribute, ISpecification holder, Type typeOfEnum)
{
if (attribute != null)
{
FacetUtils.AddFacet(Create(attribute, holder));
return;
}
Type typeOrNulledType = TypeUtils.GetNulledType(typeOfEnum);
if (TypeUtils.IsEnum(typeOrNulledType))
{
FacetUtils.AddFacet(new EnumFacet(holder, typeOrNulledType));
return;
}
if (CollectionUtils.IsGenericOfEnum(typeOfEnum))
{
Type enumInstanceType = typeOfEnum.GetGenericArguments().First();
FacetUtils.AddFacet(new EnumFacet(holder, enumInstanceType));
}
}
public void RequestReturnsCorrectTypeForDifferentMemberTypes(
Type enumType, Type memberType)
{
// Arrange
var enumDataTypeAttribute = new EnumDataTypeAttribute(enumType);
var providedAttribute = new ProvidedAttribute(enumDataTypeAttribute, true);
var request = new FakeMemberInfo(providedAttribute);
var dummyContext = new DelegatingSpecimenContext();
var sut = new EnumDataTypeAttributeRelay
{
RequestMemberTypeResolver = new DelegatingRequestMemberTypeResolver
{
OnTryGetMemberType = _ => memberType
}
};
// Act
var result = sut.Create(request, dummyContext);
// Assert
Assert.IsType(memberType, result);
}
public static void AddEnumValidation(ExcelWorksheet workSheet, string address, string errorTitle,
string promptTitle, EnumDataTypeAttribute enumDataType)
{
//var enumDataType = cfg.GetCustomAttributes(typeof(EnumDataTypeAttribute), true).Cast<EnumDataTypeAttribute>().FirstOrDefault();
if (enumDataType != null)
{
var validation = workSheet.DataValidations.AddListValidation(address);
validation.ErrorTitle = $"Enum Validation";
validation.ErrorStyle = ExcelDataValidationWarningStyle.stop;
validation.PromptTitle = $"Select item from the list";
validation.ShowInputMessage = true;
validation.ShowErrorMessage = true;
List <string> values = new List <string>();
foreach (var v in Enum.GetValues(enumDataType.EnumType))
{
validation.Formula.Values.Add(v.ToString());
values.Add(v.ToString());
}
string value = String.Join(",", values);
validation.Error = $"Please select data from a list: {value}";
validation.Prompt = $"Please select data from a list: {value}";
}
}
public static void Validate_InvalidEnumType_ThrowsInvalidOperationException(Type enumType)
{
var attribute = new EnumDataTypeAttribute(enumType);
Assert.Throws<InvalidOperationException>(() => attribute.Validate("AnyValue", new ValidationContext(new object())));
}
/// <summary>
/// Verify whether is enum data
/// </summary>
/// <param name="value">Value</param>
/// <param name="enumType">enum type</param>
/// <returns>Return whether the verification has passed</returns>
public static bool IsEnumData(this object value, Type enumType)
{
var enumDataAttribute = new EnumDataTypeAttribute(enumType);
return(enumDataAttribute.IsValid(value));
}
private static IEnumFacet Create(EnumDataTypeAttribute attribute, ISpecification holder) => attribute is null ? null : new EnumFacet(holder, attribute.EnumType);
public NomenclatureDataTypeValidator(Type nomenclatureType)
: base("", "0006-000016", false)
{
endt = new EnumDataTypeAttribute(nomenclatureType);
this._nomenclatureName = nomenclatureType.GetDisplayString();
}
/// <summary>
/// コンストラクタ。
/// </summary>
/// <param name="enumType">列挙。</param>
/// <param name="enums">許可される値の一覧。</param>
public EnumContainsAttribute(Type enumType, params object[] enums)
{
_enumDataType = new EnumDataTypeAttribute(enumType);
Enums = enums;
}
public static void Validate_InvalidEnumType_ThrowsInvalidOperationException(Type enumType)
{
var attribute = new EnumDataTypeAttribute(enumType);
Assert.Throws <InvalidOperationException>(() => attribute.Validate("AnyValue", new ValidationContext(new object())));
}
private void IsValidHelper <T>(bool expected, object value)
{
EnumDataTypeAttribute attribute = new EnumDataTypeAttribute(typeof(T));
Assert.AreEqual(expected, attribute.IsValid(value), "Value = {0} ; Type = {1}", value, value.GetType());
}
/// <summary>
/// Create new instance.
/// </summary>
public ArrayEnumDataTypeAttribute(Type enumType)
{
validator = new EnumDataTypeAttribute(enumType);
EnumType = enumType;
}
/// <summary>
/// コンストラクタ
/// </summary>
public CheckEnumDataTypeAttribute(Type enumType) : base()
{
this.SetupErrorMessageResource();
Attr = new EnumDataTypeAttribute(enumType);
}
public ValidEnumAttribute(Type enumType) : base("Enumeration")
{
this.enumType = enumType;
enumValidator = (enumType == null) ? null : new EnumDataTypeAttribute(enumType);
ErrorMessage = CoreMessages.OpenApi.RequestMalFormatted;
}
private static IEnumFacet Create(EnumDataTypeAttribute attribute, ISpecification holder)
{
return(attribute == null ? null : new EnumFacet(holder, attribute.EnumType));
}
public void EnumDataTypeAttribute_Null()
{
EnumDataTypeAttribute target = new EnumDataTypeAttribute(null);
ExceptionHelper.ExpectInvalidOperationException(delegate() { target.IsValid("any value"); }, Resources.DataAnnotationsResources.EnumDataTypeAttribute_TypeCannotBeNull);
}
public void IsValid()
{
var attr = new EnumDataTypeAttribute(typeof(string));
try {
attr.IsValid(null);
Assert.Fail("#A1-1");
} catch (InvalidOperationException) {
// success
}
try {
attr.IsValid("stuff");
Assert.Fail("#A1-2");
} catch (InvalidOperationException) {
// success
}
attr = new EnumDataTypeAttribute(typeof(TestEnum));
Assert.IsTrue(attr.IsValid(null), "#A2-1");
Assert.IsTrue(attr.IsValid(1), "#A2-2");
Assert.IsFalse(attr.IsValid(0), "#A2-3");
Assert.IsTrue(attr.IsValid(TestEnum.Two), "#A2-4");
Assert.IsFalse(attr.IsValid(AnotherEnum.Five), "#A2-5");
Assert.IsFalse(attr.IsValid("stuff"), "#A2-5");
AnotherEnum val = AnotherEnum.Six;
Assert.IsFalse(attr.IsValid(val), "#A2-6");
Assert.IsTrue(attr.IsValid(String.Empty), "#A2-7");
Assert.IsTrue(attr.IsValid("Three"), "#A2-8");
Assert.IsFalse(attr.IsValid("Four"), "#A2-9");
Assert.IsFalse(attr.IsValid(true), "#A2-10");
Assert.IsFalse(attr.IsValid(' '), "#A2-11");
Assert.IsFalse(attr.IsValid(0.12F), "#A2-12");
Assert.IsTrue(attr.IsValid((short)1), "#A2-13");
Assert.IsFalse(attr.IsValid(12.3M), "#A2-14");
Assert.IsFalse(attr.IsValid(12.3D), "#A2-15");
Assert.IsTrue(attr.IsValid((long)1), "#A2-16");
attr = new EnumDataTypeAttribute(typeof(AnotherEnum));
Assert.IsTrue(attr.IsValid(null), "#A3-1");
Assert.IsTrue(attr.IsValid(4), "#A3-2");
Assert.IsFalse(attr.IsValid(0), "#A3-3");
Assert.IsTrue(attr.IsValid(AnotherEnum.Five), "#A3-4");
Assert.IsFalse(attr.IsValid(TestEnum.One), "#A3-5");
Assert.IsFalse(attr.IsValid("stuff"), "#A3-5");
val = AnotherEnum.Four;
Assert.IsTrue(attr.IsValid(val), "#A3-6");
Assert.IsTrue(attr.IsValid(String.Empty), "#A3-7");
Assert.IsTrue(attr.IsValid("Four"), "#A3-8");
Assert.IsFalse(attr.IsValid("Three"), "#A3-9");
Assert.IsTrue(attr.IsValid(12), "#A3-10");
Assert.IsTrue(attr.IsValid("Five, Six"), "#A3-11");
Assert.IsFalse(attr.IsValid(true), "#A3-12");
Assert.IsFalse(attr.IsValid(' '), "#A3-13");
Assert.IsFalse(attr.IsValid(0.12), "#A3-14");
}
public void EnumDataTypeAttribute_NotEnum()
{
EnumDataTypeAttribute target = new EnumDataTypeAttribute(typeof(string));
ExceptionHelper.ExpectInvalidOperationException(delegate() { target.IsValid("any value"); }, String.Format(CultureInfo.CurrentCulture, Resources.DataAnnotationsResources.EnumDataTypeAttribute_TypeNeedsToBeAnEnum, typeof(string).FullName));
}
