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()); }
public ClassContent Create(Type type) { if (!type.IsSubclassOf(typeof(Exception))) { return(ClassContent.NoContent); } var className = m_CSharpService.GetNameForCSharp(type); var lines = new List <string>(); lines.AddRange(GetLines(c_DefaultMessage, className)); lines.Add(string.Empty); lines.AddRange(GetLines(c_MessagePassDown, className)); lines.Add(string.Empty); lines.AddRange(GetLines(c_RoundTripTest, className)); return(new ClassContent(lines.ToArray(), new[] { "System.IO", "System.Runtime.Serialization.Formatters.Binary" }.Concat(m_CSharpService.GetNameSpaces()).ToArray())); }
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(p => p.Length > 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.GetNameForCSharp(type); 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[] 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]); }
public ClassContent Create(Type type) { if (type == null) { throw new ArgumentNullException(nameof(type)); } var lines = new List <string>(); var ctor = type.GetConstructors().FirstOrDefault() ?? type.GetConstructors(BindingFlags.Instance | BindingFlags.NonPublic) .FirstOrDefault(); if (ctor == null) { return(ClassContent.NoContent); } var parameters = ctor.GetParameters(); var interfaces = parameters.Where(p => p.ParameterType.IsInterface).ToArray(); // Don't bother creating a factory unless there are dependencies if (interfaces.Length < 1) { return(ClassContent.NoContent); } var typeName = m_CSharpService.GetNameForCSharp(type); var indent = new string(' ', 4); lines.Add("private class TestHarness"); lines.Add("{"); // Mocked interface dependencies foreach (var parameter in interfaces.OrderBy(IsSystemNamespace)) { if (IsSystemNamespace(parameter)) { lines.Add(indent + GetPublicField(parameter)); } else { lines.Add(indent + GetPublicFieldInterfaceMock(parameter)); } } if (interfaces.Any()) { lines.Add(string.Empty); } var args = parameters.Select(p => { if (p.ParameterType.IsInterface) { return(StringUtils.ToUpperInitial(p.Name)); } return(m_CSharpService.GetInstantiation(p.ParameterType)); }).ToArray(); // Create lines.Add($"{indent}public {typeName} Create()"); lines.Add($"{indent}{{"); var declarationStart = $"{indent}{indent}return new {typeName}("; var declarationStartOffset = new string(' ', declarationStart.Length); for (var i = 0; i < args.Length; i++) { var terminator = i == args.Length - 1 ? ");" : ","; lines.Add(i == 0 ? $"{declarationStart}{args[i]}{terminator}" : $"{declarationStartOffset}{args[i]}{terminator}"); } lines.Add($"{indent}}}"); lines.Add(string.Empty); // Verify all lines.Add($"{indent}public void VerifyAllExpectations()"); lines.Add($"{indent}{{"); foreach (var i in interfaces.Except(interfaces.Where(IsSystemNamespace))) { if (!i.ParameterType.IsInterface) { continue; } lines.Add($"{indent}{indent}{StringUtils.ToUpperInitial(i.Name)}.VerifyAllExpectations();"); } lines.Add($"{indent}}}"); lines.Add("}"); return(new ClassContent(lines.ToArray(), m_CSharpService.GetNameSpaces() .Union(new[] { "Rhino.Mocks", "static Rhino.Mocks.MockRepository" }) .ToArray())); }