/// <summary> /// Converts a type into a name string. /// </summary> /// <param name="type">The type to convert.</param> /// <returns>Name string of type.</returns> public static string ConvertToSimpleTypeName(_ITypeInfo type) { Guard.ArgumentNotNull(nameof(type), type); var baseTypeName = type.Name; var backTickIdx = baseTypeName.IndexOf('`'); if (backTickIdx >= 0) { baseTypeName = baseTypeName.Substring(0, backTickIdx); } var lastIndex = baseTypeName.LastIndexOf('.'); if (lastIndex >= 0) { baseTypeName = baseTypeName.Substring(lastIndex + 1); } if (!type.IsGenericType) { return(baseTypeName); } var genericTypes = type.GetGenericArguments().ToArray(); var simpleNames = new string[genericTypes.Length]; for (var idx = 0; idx < genericTypes.Length; idx++) { simpleNames[idx] = ConvertToSimpleTypeName(genericTypes[idx]); } return($"{baseTypeName}<{string.Join(", ", simpleNames)}>"); }
/// <summary> /// Initializes a new instance of the <see cref="Xunit2TypeInfo"/> class. /// </summary> /// <param name="v3TypeInfo">The v3 type info to wrap.</param> public Xunit2TypeInfo(_ITypeInfo v3TypeInfo) { V3TypeInfo = Guard.ArgumentNotNull(nameof(v3TypeInfo), v3TypeInfo); Assembly = new Xunit2AssemblyInfo(V3TypeInfo.Assembly); BaseType = V3TypeInfo.BaseType == null ? null : new Xunit2TypeInfo(V3TypeInfo.BaseType); Interfaces = V3TypeInfo.Interfaces.Select(i => new Xunit2TypeInfo(i)).ToList(); }
/// <summary> /// Gets all the custom attributes for the given type. /// </summary> /// <param name="typeInfo">The type</param> /// <param name="attributeType">The type of the attribute</param> /// <returns>The matching attributes that decorate the type</returns> public static IEnumerable <_IAttributeInfo> GetCustomAttributes(this _ITypeInfo typeInfo, Type attributeType) { Guard.ArgumentNotNull(nameof(typeInfo), typeInfo); Guard.ArgumentNotNull(nameof(attributeType), attributeType); Guard.NotNull("Attribute type cannot be a generic type parameter", attributeType.AssemblyQualifiedName); return(typeInfo.GetCustomAttributes(attributeType.AssemblyQualifiedName)); }
/// <summary> /// Gets all the custom attributes for the given type. /// </summary> /// <param name="typeInfo">The type</param> /// <param name="attributeType">The type of the attribute</param> /// <returns>The matching attributes that decorate the type</returns> public static IReadOnlyCollection <_IAttributeInfo> GetCustomAttributes(this _ITypeInfo typeInfo, Type attributeType) { Guard.ArgumentNotNull(typeInfo); Guard.ArgumentNotNull(attributeType); Guard.NotNull("Attribute type cannot be a generic type parameter", attributeType.AssemblyQualifiedName); return(typeInfo.GetCustomAttributes(attributeType.AssemblyQualifiedName)); }
/// <summary> /// Initializes a new instance of the <see cref="TestClass"/> class. /// </summary> /// <param name="testCollection">The test collection the class belongs to</param> /// <param name="class">The test class</param> /// <param name="uniqueID">The unique ID for the test class (only used to override default behavior in testing scenarios)</param> public TestClass( _ITestCollection testCollection, _ITypeInfo @class, string?uniqueID = null) { this.@class = Guard.ArgumentNotNull(@class); this.testCollection = Guard.ArgumentNotNull(testCollection); this.uniqueID = uniqueID ?? UniqueIDGenerator.ForTestClass(TestCollection.UniqueID, Class.Name); }
/// <summary> /// Converts an <see cref="_ITypeInfo"/> into a <see cref="Type"/>, if possible (for example, this /// will not work when the test class is based on source code rather than binaries). /// </summary> /// <param name="typeInfo">The type to convert</param> /// <returns>The runtime type, if available, <c>null</c>, otherwise</returns> public static Type?ToRuntimeType(this _ITypeInfo typeInfo) { if (typeInfo is _IReflectionTypeInfo reflectionTypeInfo) { return(reflectionTypeInfo.Type); } return(SerializationHelper.GetType(typeInfo.Assembly.Name, typeInfo.Name)); }
/// <inheritdoc/> public _ITestCollection Get(_ITypeInfo testClass) { Guard.ArgumentNotNull(nameof(testClass), testClass); var collectionAttribute = testClass.GetCustomAttributes(typeof(CollectionAttribute)).SingleOrDefault(); if (collectionAttribute == null) { return(defaultCollection); } var collectionName = collectionAttribute.GetConstructorArguments().Cast <string>().Single(); return(testCollections.GetOrAdd(collectionName, CreateTestCollection)); }
/// <summary> /// Used for de-serialization. /// </summary> protected TestClass( SerializationInfo info, StreamingContext context) { testCollection = Guard.NotNull("Could not retrieve TestCollection from serialization", info.GetValue <_ITestCollection>("TestCollection")); uniqueID = Guard.NotNull("Could not retrieve UniqueID from serialization", info.GetValue <string>("UniqueID")); var assemblyName = Guard.NotNull("Could not retrieve ClassAssemblyName from serialization", info.GetValue <string>("ClassAssemblyName")); var typeName = Guard.NotNull("Could not retrieve ClassTypeName from serialization", info.GetValue <string>("ClassTypeName")); var type = SerializationHelper.GetType(assemblyName, typeName); if (type == null) { throw new InvalidOperationException($"Failed to deserialize type '{typeName}' in assembly '{assemblyName}'"); } @class = Reflector.Wrap(type); }
protected sealed override bool IsValidTestClass(_ITypeInfo type) { return(base.IsValidTestClass(type)); }
public new _ITestClass CreateTestClass(_ITypeInfo @class) { return(base.CreateTestClass(@class)); }
public _ITestCollection Get(_ITypeInfo testClass) { throw new NotImplementedException(); }
public _ITestCollection Get(_ITypeInfo _) => throw new NotImplementedException();
protected override ValueTask <_ITestClass> CreateTestClass(_ITypeInfo @class) =>
/// <inheritdoc/> protected internal override _ITestClass CreateTestClass(_ITypeInfo @class) => new TestClass(TestCollectionFactory.Get(@class), @class);
protected sealed override bool IsValidTestClass(_ITypeInfo type) => base.IsValidTestClass(type);
public new ValueTask <_ITestClass> CreateTestClass(_ITypeInfo @class) => base.CreateTestClass(@class);