private static IEnumerable <MethodBase> SelectEmptyTestMethods(Type type) { var selectEmptyTestMethods = from testMethod in TypeInvestigationService.GetTestMethods(type, false) where !testMethod.IsAbstract && !TypeInvestigationService.IsExpectedExceptionTestMethod(testMethod) && GetIntermediateLanguageFromMethodInfoBase(testMethod).Count() <= 2 select testMethod; return(selectEmptyTestMethods); }
/// <summary> /// Get the description of the test out of the test method name. /// </summary> /// <param name="targetMethod"> The target test method. </param> /// <returns> The literal description of the test. </returns> private static string GetDescription(MethodBase targetMethod) { if (targetMethod == null || targetMethod.DeclaringType == null) { return(string.Empty); } var naturalLanguageConditionName = GetConditionName(targetMethod); var naturalLanguageAssertName = targetMethod.Name.Humanize(); return(string.Format("Test case for {0}:\n\t{1},\n\t\t{2}.\n\n", TypeInvestigationService.GetTestedClassTypeName(targetMethod.DeclaringType), naturalLanguageConditionName, naturalLanguageAssertName)); }
/// <summary> /// The provide aspects. /// </summary> /// <param name="targetElement"> The target element. </param> /// <returns> The System.Collections.Generic.IEnumerable`1[T -> PostSharp.Aspects.AspectInstance]. </returns> /// <remarks> /// This method is called at build time and should just provide other aspects. /// </remarks> public IEnumerable <AspectInstance> ProvideAspects(object targetElement) { var targetType = (Type)targetElement; if (targetType.IsGenericType) { // PostSharp doesn't manage to inject on generic types (generic type definitions?), so for now we ignore it. yield break; } if (!targetType.IsDefined(typeof(DescriptionAttribute), false)) { var contextDescription = GetNaturalLanguageContextName(targetType); var descriptionAttributeConstructorInfo = typeof(DescriptionAttribute).GetConstructor(new[] { typeof(string) }); var introduceDescriptionAspect = new CustomAttributeIntroductionAspect(new ObjectConstruction(descriptionAttributeConstructorInfo, contextDescription)); // Add the Description attribute to the type. yield return(new AspectInstance(targetType, introduceDescriptionAspect)); } var localTestMethods = TypeInvestigationService.GetAllTestMethods(targetType) .Where(m => m.DeclaringType == targetType); foreach (var targetMethod in localTestMethods) { var categoryAttributes = targetMethod.GetCustomAttributes(typeof(CategoryAttribute), false).Cast <CategoryAttribute>().ToArray(); var categoryName = string.Format("Specifications for {0}", TypeInvestigationService.GetTestedClassTypeName(targetMethod.DeclaringType)); if (!categoryAttributes.Any() || categoryAttributes.All(x => x.Name != categoryName)) { var categoryAttributeConstructorInfo = typeof(CategoryAttribute).GetConstructor(new[] { typeof(string) }); var introduceCategoryAspect = new CustomAttributeIntroductionAspect(new ObjectConstruction(categoryAttributeConstructorInfo, categoryName)); // Add the Category attribute to the type. yield return(new AspectInstance(targetMethod, introduceCategoryAspect)); } if (!targetMethod.IsDefined(typeof(DescriptionAttribute), false)) { var description = GetDescription(targetMethod); if (!string.IsNullOrEmpty(description)) { var descriptionAttributeConstructorInfo = typeof(DescriptionAttribute).GetConstructor(new[] { typeof(string) }); var introduceDescriptionAspect = new CustomAttributeIntroductionAspect(new ObjectConstruction(descriptionAttributeConstructorInfo, description)); // Add the Description attribute to the type. yield return(new AspectInstance(targetMethod, introduceDescriptionAspect)); } } } }
/// <summary> /// Checks whether the type is a candidate for the aspect to apply to it. /// </summary> /// <param name="type">the type to check if it needs the attribute.</param> /// <returns><c>true</c> if any of the <see cref="instanceLevelRules"/> attribute needs to be applied to the type; <c>false</c> otherwise.</returns> public override bool CompileTimeValidate(Type type) { if (!TypeInvestigationService.IsContextSpecification(type)) { return(false); } var validates = false; // ReSharper disable once LoopCanBeConvertedToQuery foreach (var rule in this.instanceLevelRules) { // do not break as some validators raise errors. validates = validates | rule.CompileTimeValidate(type); } return(validates); }
private static IEnumerable <MethodBase> SelectExceptionResilientTestMethods(Type type) { var testMethodsInContext = TypeInvestigationService.GetAllContextSpecificationTypes(type) .SelectMany(nestedType => TypeInvestigationService.GetTestMethods(nestedType, true)); var expectedExceptionTestMethodsInContext = TypeInvestigationService.GetTestMethods(type, true) .Concat(testMethodsInContext) .Where(TypeInvestigationService.IsExpectedExceptionTestMethod) .ToArray(); // If there is any test method marked with ExpectedExceptionAttribute, then all other act as if marked with ExceptionResilientAttribute if (expectedExceptionTestMethodsInContext.Any()) { var testMethods = TypeInvestigationService.GetTestMethods(type, false); return(testMethods.Except(expectedExceptionTestMethodsInContext).ToArray()); } return(Enumerable.Empty <MethodBase>()); }
private static IEnumerable <MethodBase> SelectTestMethods(Type type) { var testMethods = TypeInvestigationService.GetTestMethods(type, false); return(testMethods.Except(SelectExceptionResilientTestMethods(type))); }
/// <summary> /// Checks if the passed class contains any nested test fixture classes. /// </summary> /// <param name="type"> /// The type of the class to check. /// </param> /// <returns> /// <c>true</c> if the passed class contains any any nested test fixture classes, <c>false</c> otherwise. /// </returns> public override bool CompileTimeValidate(Type type) { // Use reflection to find <see cref="TestFixtureAttribute"/>, instead of binding to the NUnit type directly. // This prevents versioning issues with PostSharp when applying the aspect at compile-time. return(TypeInvestigationService.IsContextSpecification(type) && base.CompileTimeValidate(type)); }