public void CreateWithInterface() { var obj = TypeBasedExportDefinition.CreateDefinition("A", typeof(IEnumerable <>)); Assert.AreEqual("A", obj.ContractName); Assert.AreEqual(TypeIdentity.CreateDefinition(typeof(IEnumerable <>)), obj.DeclaringType); }
public void CreateWithClass() { var obj = TypeBasedExportDefinition.CreateDefinition("A", typeof(List <int>)); Assert.AreEqual("A", obj.ContractName); Assert.AreEqual(TypeIdentity.CreateDefinition(typeof(List <int>)), obj.DeclaringType); }
public void EqualsWithUnequalObjects() { var first = TypeIdentity.CreateDefinition(typeof(string)); object second = TypeIdentity.CreateDefinition(typeof(object)); Assert.IsFalse(first.Equals(second)); }
public void RoundtripSerialize() { var original = TypeIdentity.CreateDefinition(typeof(string)); var copy = AssertExtensions.RoundTripSerialize(original); Assert.AreEqual(original, copy); }
public void CreateWithNestedClass() { var type = typeof(Nested <,>); var obj = TypeBasedExportDefinition.CreateDefinition("A", type); Assert.AreEqual("A", obj.ContractName); Assert.AreEqual(TypeIdentity.CreateDefinition(typeof(Nested <,>)), obj.DeclaringType); }
public void CreateWithClass() { var obj = ParameterDefinition.CreateDefinition(ParameterFromInt()); var parameter = ParameterFromInt(); Assert.AreEqual(parameter.Name, obj.Name); Assert.AreEqual(TypeIdentity.CreateDefinition(parameter.ParameterType), obj.Identity); }
public void Create() { var obj = MethodBasedExportDefinition.CreateDefinition("B", GetMethodForInt()); Assert.AreEqual("B", obj.ContractName); Assert.AreEqual(TypeIdentity.CreateDefinition(typeof(int)), obj.DeclaringType); Assert.AreEqual(MethodDefinition.CreateDefinition(GetMethodForInt()), obj.Method); }
public void CreateWithClass() { var obj = TypeIdentity.CreateDefinition(typeof(List <int>)); Assert.AreEqual(typeof(List <int>).Name, obj.Name); Assert.AreEqual(typeof(List <int>).Namespace, obj.Namespace); Assert.AreEqual(typeof(List <int>).FullName, obj.FullName); Assert.AreEqual(typeof(List <int>).Assembly.GetName().Name, obj.Assembly.Name); }
public void CreateWithInterface() { var obj = TypeIdentity.CreateDefinition(typeof(IEnumerable <>)); Assert.AreEqual(typeof(IEnumerable <>).Name, obj.Name); Assert.AreEqual(typeof(IEnumerable <>).Namespace, obj.Namespace); Assert.AreEqual(typeof(IEnumerable <>).FullName, obj.FullName); Assert.AreEqual(typeof(IEnumerable <>).Assembly.GetName().Name, obj.Assembly.Name); }
public void CreateWithClass() { var obj = PropertyBasedExportDefinition.CreateDefinition("A", GetPropertyForString()); var property = GetPropertyForString(); Assert.AreEqual("A", obj.ContractName); Assert.AreEqual(TypeIdentity.CreateDefinition(property.DeclaringType), obj.DeclaringType); Assert.AreEqual(PropertyDefinition.CreateDefinition(GetPropertyForString()), obj.Property); }
public void CreateWithClass() { var obj = PropertyDefinition.CreateDefinition(GetPropertyForString()); var property = GetPropertyForString(); Assert.AreEqual(property.Name, obj.PropertyName); Assert.AreEqual(TypeIdentity.CreateDefinition(property.PropertyType), obj.PropertyType); Assert.AreEqual(TypeIdentity.CreateDefinition(property.DeclaringType), obj.DeclaringType); }
public void CreateWithClass() { var obj = ConstructorDefinition.CreateDefinition(GetConstructorForString()); var constructor = GetConstructorForString(); Assert.That( obj.Parameters, Is.EquivalentTo(constructor.GetParameters().Select(p => ParameterDefinition.CreateDefinition(p)))); Assert.AreEqual(TypeIdentity.CreateDefinition(constructor.DeclaringType), obj.DeclaringType); }
public void CreateWithNestedClass() { var type = typeof(Nested <,>); var obj = TypeIdentity.CreateDefinition(type); Assert.AreEqual(type.Name, obj.Name); Assert.AreEqual(type.Namespace, obj.Namespace); Assert.AreEqual(type.FullName, obj.FullName); Assert.AreEqual(type.Assembly.GetName().Name, obj.Assembly.Name); }
public void CreateWithInterface() { var obj = TypeDefinition.CreateDefinition(typeof(IEnumerable <>), TypeIdentity.CreateDefinition); Assert.AreEqual(typeof(IEnumerable <>).FullName, obj.Identity.FullName); Assert.AreEqual(typeof(IEnumerable <>).IsClass, obj.IsClass); Assert.AreEqual(typeof(IEnumerable <>).IsInterface, obj.IsInterface); Assert.IsNull(obj.BaseType); Assert.That(obj.BaseInterfaces, Is.EquivalentTo(new[] { TypeIdentity.CreateDefinition(typeof(IEnumerable)) })); }
public void CreateWithClass() { var obj = MethodDefinition.CreateDefinition(GetMethodForInt()); var method = GetMethodForInt(); Assert.AreEqual(method.Name, obj.MethodName); Assert.AreEqual(TypeIdentity.CreateDefinition(method.ReturnType), obj.ReturnType); Assert.That( obj.Parameters, Is.EquivalentTo(method.GetParameters().Select(p => ParameterDefinition.CreateDefinition(p)))); Assert.AreEqual(TypeIdentity.CreateDefinition(method.DeclaringType), obj.DeclaringType); }
public void RoundtripSerialize() { var original = ConstructorBasedImportDefinition.CreateDefinition( "A", TypeIdentity.CreateDefinition(typeof(char[])), ImportCardinality.ExactlyOne, CreationPolicy.NonShared, GetConstructorForString().GetParameters().First()); var copy = AssertExtensions.RoundTripSerialize(original); Assert.AreEqual(original, copy); }
public void RoundtripSerialize() { var original = PropertyBasedImportDefinition.CreateDefinition( "A", TypeIdentity.CreateDefinition(typeof(int)), ImportCardinality.ExactlyOne, true, CreationPolicy.NonShared, typeof(string).GetProperty("Length")); var copy = AssertExtensions.RoundTripSerialize(original); Assert.AreEqual(original, copy); }
/// <summary> /// Creates a new instance of the <see cref="ConstructorBasedImportDefinition"/> class /// based on the given <see cref="ParameterInfo"/>. /// </summary> /// <param name="contractName">The contract name that is used to identify the current import.</param> /// <param name="requiredTypeIdentity">The type identity of the export type expected.</param> /// <param name="cardinality"> /// One of the enumeration values that indicates the cardinality of the export object required by the import definition. /// </param> /// <param name="creationPolicy"> /// A value that indicates that the importer requires a specific creation policy for the exports used to satisfy this import. /// </param> /// <param name="parameter">The method for which the current object stores the serialized data.</param> /// <returns>The serialized definition for the given parameter.</returns> /// <exception cref="ArgumentNullException"> /// Thrown if <paramref name="parameter"/> is <see langword="null" />. /// </exception> public static ConstructorBasedImportDefinition CreateDefinition( string contractName, TypeIdentity requiredTypeIdentity, ImportCardinality cardinality, CreationPolicy creationPolicy, ParameterInfo parameter) { return(CreateDefinition( contractName, requiredTypeIdentity, cardinality, creationPolicy, parameter, t => TypeIdentity.CreateDefinition(t))); }
public static PropertyBasedImportDefinition CreateDefinition( string contractName, TypeIdentity requiredTypeIdentity, ImportCardinality cardinality, bool isRecomposable, CreationPolicy creationPolicy, PropertyInfo property) { return(CreateDefinition( contractName, requiredTypeIdentity, cardinality, isRecomposable, creationPolicy, property, t => TypeIdentity.CreateDefinition(t))); }
public void Create() { var obj = ConstructorBasedImportDefinition.CreateDefinition( "A", TypeIdentity.CreateDefinition(typeof(char[])), ImportCardinality.ExactlyOne, CreationPolicy.NonShared, GetConstructorForString().GetParameters().First()); var constructor = GetConstructorForString(); var parameter = constructor.GetParameters().First(); Assert.AreEqual("A", obj.ContractName); Assert.AreEqual(TypeIdentity.CreateDefinition(typeof(char[])), obj.RequiredTypeIdentity); Assert.AreEqual(ImportCardinality.ExactlyOne, obj.Cardinality); Assert.IsFalse(obj.IsRecomposable); Assert.IsTrue(obj.IsPrerequisite); Assert.AreEqual(ConstructorDefinition.CreateDefinition(constructor), obj.Constructor); Assert.AreEqual(TypeIdentity.CreateDefinition(typeof(string)), obj.DeclaringType); Assert.AreEqual(ParameterDefinition.CreateDefinition(parameter), obj.Parameter); }
public void CreateWithClass() { var obj = PropertyBasedImportDefinition.CreateDefinition( "A", TypeIdentity.CreateDefinition(typeof(int)), ImportCardinality.ExactlyOne, true, CreationPolicy.NonShared, typeof(string).GetProperty("Length")); var property = GetPropertyForString(); Assert.AreEqual("A", obj.ContractName); Assert.AreEqual(TypeIdentity.CreateDefinition(typeof(int)), obj.RequiredTypeIdentity); Assert.AreEqual(ImportCardinality.ExactlyOne, obj.Cardinality); Assert.IsTrue(obj.IsRecomposable); Assert.IsFalse(obj.IsPrerequisite); Assert.AreEqual(CreationPolicy.NonShared, obj.RequiredCreationPolicy); Assert.AreEqual(TypeIdentity.CreateDefinition(property.DeclaringType), obj.DeclaringType); Assert.AreEqual(PropertyDefinition.CreateDefinition(property), obj.Property); }
protected override PropertyBasedImportDefinition Copy(PropertyBasedImportDefinition original) { if (original.ContractName.Equals("A")) { return(PropertyBasedImportDefinition.CreateDefinition( "A", TypeIdentity.CreateDefinition(typeof(int)), ImportCardinality.ExactlyOne, true, CreationPolicy.NonShared, typeof(string).GetProperty("Length"))); } return(PropertyBasedImportDefinition.CreateDefinition( "B", TypeIdentity.CreateDefinition(typeof(int)), ImportCardinality.ExactlyOne, true, CreationPolicy.NonShared, typeof(Version).GetProperty("Build"))); }
/// <summary> /// Creates a new instance of the <see cref="TypeDefinition"/> class based on the given <see cref="Type"/>. /// </summary> /// <param name="type">The type for which a serialized definition needs to be created.</param> /// <param name="identityGenerator">The function that creates type identities.</param> /// <returns>The serialized definition for the given type.</returns> /// <exception cref="ArgumentNullException"> /// Thrown if <paramref name="type"/> is <see langword="null" />. /// </exception> /// <exception cref="ArgumentNullException"> /// Thrown if <paramref name="identityGenerator"/> is <see langword="null" />. /// </exception> public static TypeDefinition CreateDefinition(Type type, Func <Type, TypeIdentity> identityGenerator) { { Lokad.Enforce.Argument(() => type); Lokad.Enforce.Argument(() => identityGenerator); } // Note that the following call may lead to a StackOverflow if the identityGenerator function // isn't smart enough to verify if we're in the process of generating a TypeDefinition for a given // type. e.g. if we're handling System.Boolean we also have to process System.IComparable<System.Boolean> // which could lead to an infinite loop. var identity = TypeIdentity.CreateDefinition(type, identityGenerator); // Generic types that don't have a base generic type have themselves as their own generic type definition! // e.g. the generic type definition for IEnumerable<T> is ... IEnumerable<T>. So we only assign a // generic type definition to a type that isn't one itself. return(new TypeDefinition( identity, type.BaseType != null ? identityGenerator(type.BaseType) : null, type.GetInterfaces().Select(i => identityGenerator(i)).ToArray(), identity.IsGenericType && type != type.GetGenericTypeDefinition() ? identityGenerator(type.GetGenericTypeDefinition()) : null, type.IsClass, type.IsInterface)); }
public void CreateWithClass() { var obj = TypeDefinition.CreateDefinition(typeof(List <int>), TypeIdentity.CreateDefinition); Assert.AreEqual(typeof(List <int>).FullName, obj.Identity.FullName); Assert.AreEqual(typeof(List <int>).IsClass, obj.IsClass); Assert.AreEqual(typeof(List <int>).IsInterface, obj.IsInterface); Assert.AreEqual(typeof(List <int>).BaseType.FullName, obj.BaseType.FullName); var interfaces = new[] { TypeIdentity.CreateDefinition(typeof(IList <int>)), TypeIdentity.CreateDefinition(typeof(ICollection <int>)), TypeIdentity.CreateDefinition(typeof(IEnumerable <int>)), TypeIdentity.CreateDefinition(typeof(IReadOnlyCollection <int>)), TypeIdentity.CreateDefinition(typeof(IReadOnlyList <int>)), TypeIdentity.CreateDefinition(typeof(IList)), TypeIdentity.CreateDefinition(typeof(ICollection)), TypeIdentity.CreateDefinition(typeof(IEnumerable)), }; Assert.That(obj.BaseInterfaces, Is.EquivalentTo(interfaces)); }
/// <summary> /// Creates a new instance of the <see cref="MethodBasedScheduleConditionDefinition"/> class /// based on the given <see cref="MethodInfo"/>. /// </summary> /// <param name="contractName">The contract name that is used to identity the current condition.</param> /// <param name="method">The method for which a serialized definition needs to be created.</param> /// <returns>The serialized definition for the given method.</returns> /// <exception cref="ArgumentNullException"> /// Thrown if <paramref name="method"/> is <see langword="null" />. /// </exception> public static MethodBasedScheduleConditionDefinition CreateDefinition(string contractName, MethodInfo method) { return(CreateDefinition(contractName, method, t => TypeIdentity.CreateDefinition(t))); }
/// <summary> /// Creates a new instance of the <see cref="MethodDefinition"/> class based on the given <see cref="PropertyInfo"/>. /// </summary> /// <param name="property">The property for which a serialized definition needs to be created.</param> /// <returns>The serialized definition for the given property.</returns> /// <exception cref="ArgumentNullException"> /// Thrown if <paramref name="property"/> is <see langword="null" />. /// </exception> public static PropertyDefinition CreateDefinition(PropertyInfo property) { return(CreateDefinition(property, t => TypeIdentity.CreateDefinition(t))); }
/// <summary> /// Creates a new instance of the <see cref="MethodDefinition"/> class based on the given <see cref="MethodInfo"/>. /// </summary> /// <param name="method">The method for which a serialized definition needs to be created.</param> /// <returns>The serialized definition for the given method.</returns> /// <exception cref="ArgumentNullException"> /// Thrown if <paramref name="method"/> is <see langword="null" />. /// </exception> public static MethodDefinition CreateDefinition(MethodInfo method) { return(CreateDefinition(method, t => TypeIdentity.CreateDefinition(t))); }
/// <summary> /// Creates a new instance of the <see cref="ConstructorDefinition"/> class based on the given <see cref="ConstructorInfo"/>. /// </summary> /// <param name="constructor">The constructor for which a serialized definition needs to be created.</param> /// <returns>The serialized definition for the given constructor.</returns> /// <exception cref="ArgumentNullException"> /// Thrown if <paramref name="constructor"/> is <see langword="null" />. /// </exception> public static ConstructorDefinition CreateDefinition(ConstructorInfo constructor) { return(CreateDefinition(constructor, t => TypeIdentity.CreateDefinition(t))); }
/// <summary> /// Creates a new instance of the <see cref="TypeBasedExportDefinition"/> class /// based on the given <see cref="Type"/>. /// </summary> /// <param name="contractName">The contract name that is used to identify the current export.</param> /// <param name="declaringType">The method for which the current object stores the serialized data.</param> /// <returns>The serialized definition for the given type.</returns> /// <exception cref="ArgumentNullException"> /// Thrown if <paramref name="declaringType"/> is <see langword="null" />. /// </exception> public static TypeBasedExportDefinition CreateDefinition(string contractName, Type declaringType) { return(CreateDefinition(contractName, declaringType, t => TypeIdentity.CreateDefinition(t))); }
/// <summary> /// Creates a new instance of the <see cref="PropertyBasedExportDefinition"/> class based on the given <see cref="PropertyInfo"/>. /// </summary> /// <param name="contractName">The contract name that is used to identify the current export.</param> /// <param name="property">The property for which a serialized definition needs to be created.</param> /// <returns>The serialized definition for the given property.</returns> /// <exception cref="ArgumentNullException"> /// Thrown if <paramref name="property"/> is <see langword="null" />. /// </exception> public static PropertyBasedExportDefinition CreateDefinition(string contractName, PropertyInfo property) { return(CreateDefinition(contractName, property, t => TypeIdentity.CreateDefinition(t))); }