public void TestGeneric_FromBaseWithInterface()
{
ICustomAttribute[] attributes = AttributeUtility.GetCustomAttributes <ICustomAttribute> (BaseMemberWithSingleAttribute, true);
Assert.That(attributes.Length, Is.EqualTo(1));
Assert.That(attributes[0], Is.Not.Null);
}
public void Test_FromProtectedOverrideWithAttribute()
{
InheritedAttribute[] attributes = AttributeUtility.GetCustomAttributes <InheritedAttribute> (DerivedProtectedMember, true);
Assert.That(attributes.Length, Is.EqualTo(1));
Assert.That(attributes[0], Is.Not.Null);
}
public void GetCustomAttributes_Unfiltered_Properties()
{
PerformMeasurement(
_properties,
items =>
{
var counter = 0;
for (int i = 0; i < items.Length; ++i)
{
try
{
counter += AttributeUtility.GetCustomAttributes(items[i], typeof(Attribute), true).Length;
}
catch (AmbiguousMatchException)
{
}
}
return(counter);
},
items =>
{
var counter = 0;
for (int i = 0; i < items.Length; ++i)
{
try
{
counter += Attribute.GetCustomAttributes(items[i], true).Length;
}
catch (AmbiguousMatchException)
{
}
}
return(counter);
});
}
public void Filtering_WithDerivedAttributeType()
{
object[] attributes = AttributeUtility.GetCustomAttributes(typeof(BaseClassWithAttribute), typeof(DerivedInheritedAttribute), false);
Assert.That(attributes, Is.EquivalentTo(new object[] {
new DerivedInheritedAttribute("BaseClass")
}));
}
public void Test_ReturnsNewInstance()
{
var attribute1 = AttributeUtility.GetCustomAttributes(BaseMemberWithSingleAttribute, typeof(InheritedAttribute), false).Single();
var attribute2 = AttributeUtility.GetCustomAttributes(BaseMemberWithSingleAttribute, typeof(InheritedAttribute), false).Single();
Assert.That(attribute1, Is.Not.SameAs(attribute2));
}
public void Test_FromOverrideHidingBaseAttribute()
{
var attributes = AttributeUtility.GetCustomAttributes <InheritedNotMultipleAttribute> (DerivedMemberHidingAttribute, true);
Assert.That(attributes.Length, Is.EqualTo(1));
Assert.That(attributes[0].Context, Is.EqualTo("Derived"));
}
public void Test_ReturnsNewInstanceForType()
{
var attribute1 = AttributeUtility.GetCustomAttributes(typeof(SampleClass), typeof(InheritedAttribute), false).Single();
var attribute2 = AttributeUtility.GetCustomAttributes(typeof(SampleClass), typeof(InheritedAttribute), false).Single();
Assert.That(attribute1, Is.Not.SameAs(attribute2));
}
public void Test_FromOverrideWithInterfaceAndMultiple()
{
ICustomAttribute[] attributes = AttributeUtility.GetCustomAttributes <ICustomAttribute> (DerivedMemberWithMultipleAttribute, true);
Assert.That(attributes.Length, Is.EqualTo(2));
Assert.That(attributes[0], Is.Not.Null);
Assert.That(attributes[1], Is.Not.Null);
}
public void Test_FromBaseWithInterface()
{
object[] attributes = AttributeUtility.GetCustomAttributes(BaseMemberWithSingleAttribute, typeof(ICustomAttribute), true);
Assert.That(attributes.Length, Is.EqualTo(1));
Assert.That(attributes[0], Is.Not.Null);
Assert.IsInstanceOf(typeof(ICustomAttribute), attributes[0]);
}
public void DerivedClass_BaseAttributesAreSuppressed_InheritedTrue()
{
object[] attributes = AttributeUtility.GetCustomAttributes(typeof(DerivedWithAttributesAndSuppressed), typeof(Attribute), true);
Assert.That(attributes, Is.EquivalentTo(new object[] {
new BaseInheritedAttribute("DerivedWithAttributesAndSuppressed"),
new DerivedInheritedAttribute("DerivedWithAttributesAndSuppressed")
}));
}
public void DerivedDerivedClass_NothingSuppressed_InheritedFalse()
{
object[] attributes = AttributeUtility.GetCustomAttributes(typeof(DerivedDerivedWithAttributesForSuppressed), typeof(Attribute), false);
Assert.That(attributes, Is.EquivalentTo(new object[] {
new BaseInheritedAttribute("DerivedDerivedWithAttributesForSuppressed"),
new DerivedInheritedAttribute("DerivedDerivedWithAttributesForSuppressed")
}));
}
public void GetCustomAttributes_WithMemberInfo_DelegatesToTypeVersion()
{
object[] attributes = AttributeUtility.GetCustomAttributes((MemberInfo)typeof(DerivedWithAttributesAndSuppressed), typeof(Attribute), true);
Assert.That(attributes, Is.EquivalentTo(new object[] {
new BaseInheritedAttribute("DerivedWithAttributesAndSuppressed"),
new DerivedInheritedAttribute("DerivedWithAttributesAndSuppressed")
}));
}
public void GetCustomAttributes()
{
var type = typeof(DateTime);
var adapter = TypeAdapter.Create(type);
Assert.That(
adapter.GetCustomAttributes <SerializableAttribute> (true),
Is.EqualTo(AttributeUtility.GetCustomAttributes <SerializableAttribute> (type, true)));
}
public void MixinAttribute_IsAlsoSuppressed()
{
using (MixinConfiguration.BuildNew().ForClass <DerivedWithAttributesAndSuppressed> ().AddMixin <MixinAddingInheritedAttribute> ().EnterScope())
{
Type type = TypeFactory.GetConcreteType(typeof(DerivedWithAttributesAndSuppressed));
Assert.That(AttributeUtility.GetCustomAttributes(type, typeof(Attribute), true),
Has.No.Member(new BaseInheritedAttribute("MixinAddingInheritedAttribute")));
}
}
public void Filtering_WithInterfaceType()
{
object[] attributes = AttributeUtility.GetCustomAttributes(typeof(BaseClassWithAttribute), typeof(ICustomAttribute), false);
Assert.That(attributes, Is.EquivalentTo(new object[] {
new BaseInheritedAttribute("BaseClass"),
new DerivedInheritedAttribute("BaseClass"),
new InheritedNotMultipleAttribute("BaseClass"),
}));
}
private Type GetStorageGroupType()
{
var storageGroupAttribute = AttributeUtility.GetCustomAttributes <StorageGroupAttribute> (Type, true).FirstOrDefault();
if (storageGroupAttribute != null)
{
return(storageGroupAttribute.GetType());
}
return(null);
}
public void MixinSuppressingNonInheritedAttributeOnTargetClass()
{
using (MixinConfiguration.BuildNew().ForClass <ClassWithNonInheritedAttribute> ().AddMixin <MixinSuppressingNonInheritedAttribute> ().EnterScope())
{
Type type = TypeFactory.GetConcreteType(typeof(ClassWithNonInheritedAttribute));
Assert.That(AttributeUtility.GetCustomAttributes(type, typeof(Attribute), true),
Has.No.Member(new BaseNonInheritedAttribute("ClassWithNonInheritedAttribute")));
}
}
public IResourceManager CreateResourceManager(Type type)
{
ArgumentUtility.CheckNotNull("type", type);
var resourceAttributes = AttributeUtility.GetCustomAttributes <IResourcesAttribute> (type, false);
var assembly = type.Assembly;
var resourceManagers = resourceAttributes.Select(resourcesAttribute => GetResourceManagerFromCache(assembly, resourcesAttribute));
return(ResourceManagerWrapper.CreateWrapperSet(resourceManagers));
}
public void Test_NoGetter()
{
var propertyInfo = typeof(DerivedSampleClass).GetProperty("PropertyWithoutGetter");
object[] attributes = AttributeUtility.GetCustomAttributes(propertyInfo, typeof(InheritedAttribute), true);
Assert.That(attributes.Length, Is.EqualTo(1));
Assert.That(attributes[0], Is.Not.Null);
Assert.IsInstanceOf(typeof(InheritedAttribute), attributes[0]);
}
public void Test_FromOverrideWithBaseOverloads()
{
var propertyInfo = typeof(DerivedSampleClass).GetProperty("Item", new[] { typeof(int) });
object[] attributes = AttributeUtility.GetCustomAttributes(propertyInfo, typeof(InheritedAttribute), true);
Assert.That(attributes.Length, Is.EqualTo(1));
Assert.That(attributes[0], Is.Not.Null);
Assert.IsInstanceOf(typeof(InheritedAttribute), attributes[0]);
}
public void DerivedClass_InheritedFalse()
{
object[] attributes = AttributeUtility.GetCustomAttributes(typeof(DerivedClassWithAttribute), typeof(Attribute), false);
Assert.That(attributes, Is.EquivalentTo(new object[] {
new BaseInheritedAttribute("DerivedClass"),
new DerivedInheritedAttribute("DerivedClass"),
new BaseNonInheritedAttribute("DerivedClass"),
new DerivedNonInheritedAttribute("DerivedClass"),
new InheritedNotMultipleAttribute("DerivedClass"),
}));
}
public void GetEnumerationValueFilter_FromAttributeProvider_IntegrationTestWithNullablePropertyType()
{
var provider = new EnumValueFilterProvider <DisableEnumValuesAttribute> (
GetPropertyInformation("DisabledFromNullablePropertyType"),
t => AttributeUtility.GetCustomAttributes <DisableEnumValuesAttribute> (t, true));
var actual = provider.GetEnumerationValueFilter();
Assert.That(actual, Is.TypeOf(typeof(ConstantEnumerationValueFilter)));
Assert.That(((ConstantEnumerationValueFilter)actual).DisabledEnumValues, Is.EquivalentTo(new[] { TestEnum.Value5 }));
}
protected override IEnumerable <MultiLingualNameAttribute> GetCustomAttributes(Enum value)
{
ArgumentUtility.CheckNotNull("value", value);
var field = value.GetType().GetField(value.ToString(), BindingFlags.Static | BindingFlags.Public);
if (field == null)
{
return(Enumerable.Empty <MultiLingualNameAttribute>());
}
return(AttributeUtility.GetCustomAttributes <MultiLingualNameAttribute> (field, false));
}
public void MixinSuppressingAttribute()
{
using (MixinConfiguration.BuildNew().ForClass <BaseWithAttributesForSuppressed> ().AddMixin <MixinAddingSuppressAttribute> ().EnterScope())
{
Type type = TypeFactory.GetConcreteType(typeof(BaseWithAttributesForSuppressed));
Assert.That(type.GetCustomAttributes(true), Has.Member(new BaseInheritedAttribute("BaseWithAttributesForSuppressed")));
Assert.That(type.GetCustomAttributes(true), Has.Member(new BaseInheritedAttribute("MixinAddingSuppressAttribute")));
Assert.That(AttributeUtility.GetCustomAttributes(type, typeof(Attribute), true),
Has.No.Member(new BaseInheritedAttribute("BaseWithAttributesForSuppressed")));
Assert.That(AttributeUtility.GetCustomAttributes(type, typeof(Attribute), true),
Has.Member(new BaseInheritedAttribute("MixinAddingSuppressAttribute")));
}
}
/// <inheritdoc />
public object[] GetCustomAttributes(Type attributeType)
{
ArgumentUtility.CheckNotNull("attributeType", attributeType);
var extensionTypes = (from info in GetValueInfos()
select info.DefiningMethod.DeclaringType).Distinct();
var attributes = from extensionType in extensionTypes
from attribute in AttributeUtility.GetCustomAttributes(extensionType, attributeType, false)
select attribute;
var list = attributes.ToList();
var array = (object[])Array.CreateInstance(attributeType, list.Count);
list.CopyTo(array);
return(array);
}
/// <exception cref="InvalidOperationException">
/// The enum type has an UndefinedEnumValueAttribute with a value that does not match the enum's type.
/// <para>- or -</para>
/// <para>The property is nullable and the property's type defines an UndefinedEnumValueAttribute</para>
/// </exception>
public EnumerationProperty(Parameters parameters)
: base(parameters)
{
if (AttributeUtility.IsDefined <FlagsAttribute> (parameters.UnderlyingType, false))
{
throw new InvalidOperationException(
string.Format(
"The property '{0}' defined on type '{1}' is a flags-enum, which is not supported.",
Identifier,
PropertyInfo.DeclaringType));
}
_undefinedValue = GetUndefinedValue();
var filterProvider = new EnumValueFilterProvider <DisableEnumValuesAttribute> (
PropertyInfo,
t => AttributeUtility.GetCustomAttributes <DisableEnumValuesAttribute> (t, true));
_enumerationValueFilter = filterProvider.GetEnumerationValueFilter();
}
private XmlAttributeOverrides CreateAttributeOverrides(Type concreteType)
{
XmlAttributeOverrides attributeOverrides = new XmlAttributeOverrides();
foreach (MemberInfo memberInfo in concreteType.FindMembers(
MemberTypes.Field | MemberTypes.Property,
BindingFlags.Instance | BindingFlags.Public,
delegate { return(true); },
null))
{
XmlAttributes attributes = new XmlAttributes();
foreach (XmlElementAttribute attribute in AttributeUtility.GetCustomAttributes <XmlElementAttribute> (memberInfo, true))
{
attributes.XmlElements.Add(attribute);
}
attributes.XmlAttribute = AttributeUtility.GetCustomAttribute <XmlAttributeAttribute> (memberInfo, true);
attributes.XmlIgnore = attributes.XmlAttribute == null && attributes.XmlElements.Count == 0;
attributeOverrides.Add(concreteType, memberInfo.Name, attributes);
}
return(attributeOverrides);
}
public void GetCustomAttributes_Filtered_Types()
{
PerformMeasurement(
_types,
items =>
{
var counter = 0;
for (int i = 0; i < items.Length; ++i)
{
counter += AttributeUtility.GetCustomAttributes(items[i], typeof(SerializableAttribute), true).Length;
}
return(counter);
},
items =>
{
var counter = 0;
for (int i = 0; i < items.Length; ++i)
{
counter += Attribute.GetCustomAttributes(items[i], typeof(SerializableAttribute), true).Length;
}
return(counter);
});
}
public void Test_FromBaseWithInvalidType()
{
AttributeUtility.GetCustomAttributes(BaseMemberWithSingleAttribute, typeof(object), true);
}
public void TestGeneric_FromBaseWithInvalidType()
{
AttributeUtility.GetCustomAttributes <object> (BaseMemberWithSingleAttribute, true);
}