private static void RunWithSuggestions(CoverageUtilityConfig config, Type type, object optionalInstance, MethodInfo method, ParameterInfo[] methodParamInfos, object[] methodParams) { var factory = config.InstanceFactory; var asserter = config.Asserter; // ZAS: If there are any suggestions on this method, let's test them out var testSuggestions = method.GetCustomAttributes <TestSuggestionAttribute>().ToArray(); for (int i = 0; i < testSuggestions.Length; i++) { var parameter = testSuggestions[i].Parameter; if (parameter == null) { //$$ report issue? continue; } for (int j = 0; j < methodParams.Length; j++) { if (methodParamInfos[j].Name == parameter) { methodParams[j] = testSuggestions[i].Value; } else { methodParams[j] = factory.InstantiateInstanceOf(methodParamInfos[j].ParameterType, goodValue: true); } } InvokeMethod(asserter, method, type, optionalInstance, methodParams); } }
public static object TestMethods(Type type, CoverageUtilityConfig config) { _ = type ?? throw new ArgumentNullException(nameof(type)); _ = config ?? throw new ArgumentNullException(nameof(config)); // ZAS: Ensure we have value concretes config.InstanceFactory = config.InstanceFactory ?? new CSharpInstanceFactory(); config.Asserter = config.Asserter ?? new NullAsserter(); object optionalInstance = null; var isStatic = type.IsAbstract && type.IsSealed; if (!isStatic) { optionalInstance = config.InstanceFactory.InstantiateInstanceOf(type, goodValue: true) ?? throw new InvalidOperationException($"Instance factory failed to instantiate type of {type.Name}") ; // ZAS: The type used to create the instance might be different than "type" // example: generic types type = optionalInstance.GetType(); } TestMethods(type, config, optionalInstance); return(optionalInstance); }
private static void RunWithGoodParameters(CoverageUtilityConfig config, Type type, object optionalInstance, MethodInfo method, ParameterInfo[] methodParamInfos, object[] methodParams) { var factory = config.InstanceFactory; var asserter = config.Asserter; // ZAS: Run a version with all good values for (int j = 0; j < methodParams.Length; j++) { methodParams[j] = factory.InstantiateInstanceOf(methodParamInfos[j].ParameterType, goodValue: true); } InvokeMethod(asserter, method, type, optionalInstance, methodParams); }
public static void TestAllTypesInAssembly(Assembly assembly, CoverageUtilityConfig config) { _ = assembly ?? throw new ArgumentNullException(nameof(assembly)); _ = config ?? throw new ArgumentNullException(nameof(config)); foreach (var type in assembly.GetTypes()) { // ZAS: We aren't interested in testing these types of objects if (type.IsAbstract || type.IsInterface || type.IsEnum) { continue; } TestMethods(type, config); } }
private static void RunWithBadParameters(CoverageUtilityConfig config, Type type, object optionalInstance, MethodInfo method, ParameterInfo[] methodParamInfos, object[] methodParams) { var factory = config.InstanceFactory; var asserter = config.Asserter; // ZAS: Now run with one value at a time as "bad" for (int i = 0; i < methodParams.Length; i++) { for (int j = 0; j < methodParams.Length; j++) { methodParams[j] = factory.InstantiateInstanceOf(methodParamInfos[j].ParameterType, i != j); } InvokeMethod(asserter, method, type, optionalInstance, methodParams); } }
public static void TestMethods(Type type, CoverageUtilityConfig config, object optionalInstance) { _ = type ?? throw new ArgumentNullException(nameof(type)); _ = config ?? throw new ArgumentNullException(nameof(config)); if (type.IsGenericTypeDefinition || type.IsInterface || type.IsEnum) { throw new System.InvalidOperationException($"Type {type.Name} can not be tested"); } // ZAS: Ensure we have value concretes config.InstanceFactory = config.InstanceFactory ?? new CSharpInstanceFactory(); config.Asserter = config.Asserter ?? new NullAsserter(); var isStatic = type.IsAbstract && type.IsSealed; if (isStatic) { optionalInstance = null; } try { BindingFlags flags = default; if (!isStatic) { flags = BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly; } else { flags = BindingFlags.Public | BindingFlags.Static | BindingFlags.DeclaredOnly; } var methods = type.GetMethods(flags); for (int i = 0; i < methods.Length; i++) { var method = methods[i]; if (method.IsGenericMethodDefinition) { var length = method.GetGenericArguments().Length; var parameters = new Type[length]; for (int ii = 0; ii < length; ii++) { parameters[ii] = typeof(object); } method = method.MakeGenericMethod(parameters); } var methodParamInfos = method.GetParameters(); var methodParams = new object[methodParamInfos.Length]; RunWithGoodParameters(config, type, optionalInstance, method, methodParamInfos, methodParams); RunWithBadParameters(config, type, optionalInstance, method, methodParamInfos, methodParams); RunWithSuggestions(config, type, optionalInstance, method, methodParamInfos, methodParams); } } catch (TargetInvocationException targetInvocationException) { throw targetInvocationException.InnerException; } finally { config.InstanceFactory.ClearInstances(); } }
public static void TestMethods <T>(CoverageUtilityConfig config, T optionalInstance) { _ = config ?? throw new ArgumentNullException(nameof(config)); TestMethods(typeof(T), config, optionalInstance); }
public static T TestMethods <T>(CoverageUtilityConfig config) { _ = config ?? throw new ArgumentNullException(nameof(config)); return((T)TestMethods(typeof(T), config)); }