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]);
}