private IEnumerable <string> WriteTestMethod(Type typeUnderTest, ExceptionalCircumstance circumstance, CSharpService cSharpService) { var sanitisedExName = circumstance.ExceptionType.Split('.').Last(); var testMethodName = circumstance.OuterMethod.Name; var innerMethod = circumstance.InnerMethod; var innerDependency = circumstance.InnerMethod.DeclaringType; var ctor = typeUnderTest.GetConstructors() .FirstOrDefault(c => c.GetParameters() .Any(p => p.ParameterType == innerDependency)); if (ctor == null) { yield break; } var ctorParams = ctor.GetParameters(); var paramName = ctorParams.FirstOrDefault(p => p.ParameterType == innerDependency).Name; var dummyArgs = string.Join(",", innerMethod.GetParameters().Select(p => DummyValue(p, cSharpService))); yield return("[Test]"); yield return($"public void {testMethodName}_handles_{sanitisedExName}()"); yield return("{"); yield return($" var factory = new TestHarness();"); yield return($" factory.{StringUtils.ToUpperInitial(paramName)}"); yield return($" .Stub(x => x.{innerMethod.Name}({dummyArgs}))"); yield return($" .IgnoreArguments()"); yield return($" .Throw(new {circumstance.ExceptionType}());"); var identifier = cSharpService.GetIdentifier(typeUnderTest, VarScope.Local); yield return($" var {identifier} = factory.Create();"); yield return($" throw new NotImplementedException(\"Test placeholder not implemented.\");"); yield return("}"); }
private string[] ToMethodNullArgsTestCaseSourceImp(MethodInfo[] infos, Type type) { var lines = new List <string>(); if (!infos.Any()) { return(lines.ToArray()); } var parametersForVars = infos.Select(i => i.GetParameters()) .Where(g => g.Count(p => !p.ParameterType.IsValueType) > 1) .SelectMany(p => p) .ToArray(); var variablesNeeded = parametersForVars.Where(p => !p.IsOut).ToArray(); var outVariablesNeeded = parametersForVars.Where(p => p.IsOut).Except(variablesNeeded).ToArray(); var variableDeclarations = m_CSharpService.GetVariableDeclarationsForParameters(variablesNeeded, setToNull: false, nonDefault: false); var outVariableDeclarations = m_CSharpService.GetVariableDeclarationsForParameters(outVariablesNeeded, setToNull: true, nonDefault: false); lines.AddRange(variableDeclarations); lines.AddRange(outVariableDeclarations); if (variableDeclarations.Union(outVariableDeclarations).Any()) { lines.Add(string.Empty); } var instanceName = m_CSharpService.GetIdentifier(type, VarScope.Local); lines.AddRange(m_CSharpService.GetStubbedInstantiation(type)); lines.Add(string.Empty); bool testCasesExist = false; foreach (var info in infos) { var methodName = info.Name; var parameters = info.GetParameters(); var arguments = m_CSharpService.GetMethodArguments(info, true, false); for (var i = 0; i < parameters.Length; i++) { if (parameters[i].ParameterType.IsValueType) { continue; } if (m_CSharpService.HasParamKeyword(parameters[i])) { continue; } testCasesExist = true; var copyOfArguments = new List <string>(arguments) { [i] = "null" }; lines.Add($"yield return new TestCaseData(new TestDelegate(() => " + $"{instanceName}.{methodName}({string.Join(", ", copyOfArguments)})))" + $".SetName(\"{methodName} with null {parameters[i].Name}\");"); } } return(testCasesExist ? lines.ToArray() : new string[0]); }
public ClassContent Create(Type type) { var ctrs = type.GetConstructors(); if (ctrs.Length != 1) { return(ClassContent.NoContent); } var parameters = ctrs.Single().GetParameters(); if (!parameters.Any()) { return(ClassContent.NoContent); } var properties = type.GetProperties(); var pairs = properties.Select(p => (property: p, parameter: parameters.FirstOrDefault( para => para.Name.Equals(p.Name, InvariantCultureIgnoreCase)))) .Where(pair => pair.parameter != null).ToArray(); if (parameters.Length != pairs.Length) { return(ClassContent.NoContent); } var lines = new List <string>(); var verificationLines = new List <string>(); lines.Add("[Test]"); lines.Add("public void Parameter_round_trip_test()"); lines.Add("{"); var instanceName = m_CSharpService.GetIdentifier(type, VarScope.Local); foreach (var pair in pairs) { var varName = StringUtils.ToLowerInitial(pair.parameter.Name); var initial = pair.parameter.ParameterType == typeof(string) ? $"\"{pair.parameter.Name}\"" : m_CSharpService.GetInstantiation(pair.parameter.ParameterType, true); lines.Add($" var {varName} = {initial};"); verificationLines.Add($" Assert.AreEqual({varName}, {instanceName}.{pair.property.Name});"); } lines.Add(""); var instanceDeclr = $" var {instanceName} = new {m_CSharpService.GetNameForCSharp(type)}("; var instanceDeclrOffset = new string(' ', instanceDeclr.Length); var args = parameters.Select(p => p.Name).Select(StringUtils.ToLowerInitial).ToArray(); for (var i = 0; i < args.Length; i++) { var terminator = i == args.Length - 1 ? ");" : ","; lines.Add(i == 0 ? $"{instanceDeclr}{args[i]}{terminator}" : $"{instanceDeclrOffset}{args[i]}{terminator}"); } lines.Add(""); lines.AddRange(verificationLines); lines.Add("}"); return(new ClassContent(lines.ToArray(), m_CSharpService.GetNameSpaces())); }
private string[] GetBuilderMethod(Type type) { var lines = new List <string>(); var parameters = type.GetConstructors() .OrderByDescending(c => c.GetParameters().Length) .FirstOrDefault()? .GetParameters(); if (parameters == null || parameters.Length == 0) { return(new string[0]); } var arguments = parameters.Select(p => m_CSharpService.GetInstantiation(p.ParameterType)).ToArray(); // Thing(5) isn't obvious for what 5 does, so we add named parameters for bool and numbers. // int namedParameterStart = parameters.Length; for (var i = parameters.Length - 1; i >= 0; i--) { var pType = parameters[i].ParameterType; if (pType == typeof(bool) || NumericTypeHandler.IsHandled(type)) { namedParameterStart = i; } else { break; } } for (var i = 0; i < arguments.Length; i++) { var t = parameters[i].ParameterType; if (t == typeof(string)) { arguments[i] = $"\"{parameters[i].Name}\""; } if (i >= namedParameterStart) { arguments[i] = $"{parameters[i].Name}: {arguments[i]}"; } } var indent = new string(' ', 4); lines.Add($"private static {m_CSharpService.GetNameForCSharp(type)} Create{m_CSharpService.GetIdentifier(type, VarScope.Member)}()"); lines.Add($"{{"); lines.Add($"{indent}return new {m_CSharpService.GetNameForCSharp(type)}({string.Join(", ", arguments)});"); lines.Add($"}}"); return(lines.ToArray()); }
private string[] GetTestCaseSource(Type type, Func <BindingFlags, MethodBase[]> methodGetter) { var hasArrayAssignables = methodGetter(BindingFlags.Public | BindingFlags.Instance) .Where(t => t.IsConstructor || type.IsMethodTestable(t)) .Where(m => m.GetParameters() .Select(p => p.ParameterType) .Any(t => m_CSharpService.IsArrayAssignable(t) && !m_CSharpService.GetArrayElementType(t).IsValueType)) .ToArray(); var hasDateTimeParameter = methodGetter(BindingFlags.Public | BindingFlags.Instance) .Where(t => t.IsConstructor || type.IsMethodTestable(t)) .Where(m => m.GetParameters() .Select(p => p.ParameterType) .Any(t => t == typeof(DateTime) || t == typeof(DateTime?))) .ToArray(); var testableMethods = hasArrayAssignables.Concat(hasDateTimeParameter).Distinct().ToArray(); var lines = new List <string>(); if (!testableMethods.Any()) { return(new string[0]); } var isCtor = testableMethods.Any(m => m.IsConstructor); var parametersNeedingVariables = testableMethods.Select(i => i.GetParameters()) .SelectMany(p => p) .Where(m_CSharpService.ShouldUseVariableForParameter) .GroupBy(p => p.ParameterType).Select(g => g.First()) .ToArray(); var inParameters = parametersNeedingVariables.Where(p => !p.IsOut).ToArray(); var outParamters = parametersNeedingVariables.Where(p => p.IsOut).Except(inParameters).ToArray(); var variableDeclarations = m_CSharpService.GetVariableDeclarationsForParameters(inParameters, setToNull: false, nonDefault: false); var outVariableDeclarations = m_CSharpService.GetVariableDeclarationsForParameters(outParamters, setToNull: true, nonDefault: false); lines.AddRange(variableDeclarations); lines.AddRange(outVariableDeclarations); if (variableDeclarations.Union(outVariableDeclarations).Any()) { lines.Add(string.Empty); } var instanceName = m_CSharpService.GetIdentifier(type, VarScope.Local); if (!isCtor) { lines.AddRange(m_CSharpService.GetStubbedInstantiation(type)); lines.Add(string.Empty); } bool testCasesExist = false; foreach (var info in testableMethods) { var methodName = info.Name; var parameters = info.GetParameters(); var arguments = m_CSharpService.GetMethodArguments(info, true, false); for (var i = 0; i < parameters.Length; i++) { if (m_CSharpService.HasParamKeyword(parameters[i])) { continue; } var pType = parameters[i].ParameterType; var copyOfArguments = new List <string>(arguments); string testNameSuffix; if (m_CSharpService.IsArrayAssignable(pType)) { var arrayElementType = m_CSharpService.GetArrayElementType(pType); if (arrayElementType.IsValueType) { continue; } var instance = m_CSharpService.GetNameForCSharp(arrayElementType); copyOfArguments[i] = $"new {instance}[] {{ null }}"; testNameSuffix = "contains null"; } else if (pType == typeof(DateTime) || pType == typeof(DateTime?)) { copyOfArguments[i] = $"DateTime.MinValue"; testNameSuffix = "not UTC"; } else { continue; } testCasesExist = true; var invocation = isCtor ? $"new {m_CSharpService.GetNameForCSharp(type)}" : $"{instanceName}.{methodName}"; lines.Add($"yield return new TestCaseData(new TestDelegate(() => " + $"{invocation}({string.Join(", ", copyOfArguments)})))" + $".SetName(\"{methodName} with {parameters[i].Name} {testNameSuffix}\");"); } } return(testCasesExist ? lines.ToArray() : new string[0]); }