public ClassContent Create(Type type)
{
var lines = new List <string>();
var testCases = GetConstructorNullTestCaseSource(type);
if (!testCases.linesOfCode.Any())
{
return(ClassContent.NoContent);
}
var indent = new string(' ', 4);
var testCaseSource = $"Constructor_null_argument_testcases";
lines.Add($"private static IEnumerable<TestCaseData> {testCaseSource}()");
lines.Add("{");
lines.AddRange(testCases.linesOfCode.Select(line => $"{indent}{line}"));
lines.Add("}");
lines.Add(string.Empty);
lines.Add($"[TestCaseSource(nameof({testCaseSource}))]");
lines.Add($"public void Constructor_null_argument_test(TestDelegate testDelegate)");
lines.Add("{");
lines.Add($"{indent}Assert.Throws<ArgumentNullException>(testDelegate);");
lines.Add("}");
return(new ClassContent(lines.ToArray(), m_CSharpService.GetNameSpaces()));
}
public ClassContent Create(Type type)
{
var lines = new List <string>();
var classTypes = new[] { type };
var dependencyTypes = new List <Type>();
for (int i = 0; i < 4; i++)
{
classTypes = classTypes.SelectMany(GetSupportedDependencies)
.Distinct().ToArray();
dependencyTypes.AddRange(classTypes);
}
classTypes = dependencyTypes.Distinct().ToArray();
for (var i = 0; i < classTypes.Length; i++)
{
if (i > 0)
{
lines.Add(string.Empty);
}
var depType = classTypes[i];
var declaration = GetBuilderMethod(depType);
lines.AddRange(declaration);
}
return(new ClassContent(lines.ToArray(), m_CSharpService.GetNameSpaces()));
}
public ClassContent Create(Type type)
{
var csharpService = new CSharpService();
var testCode = GenerateTestCode(type, csharpService);
if (!testCode.Any())
{
return(ClassContent.NoContent);
}
return(new ClassContent(testCode, csharpService.GetNameSpaces()));
}
public ClassContent Create(Type type)
{
var cSharpWriter = new CSharpService();
var delegationReports = ReflectionUtils.GetMethodsThatPassthrough(type);
var safeCombinations = delegationReports
.Where(r => r.ctor.GetParameters()
.Select(p => p.ParameterType)
.All(cSharpWriter.NoCircularDependenciesOrAbstract))
.ToArray();
if (!safeCombinations.Any())
{
return(ClassContent.NoContent);
}
var linesOfCode = GenerateTestMethods(type, safeCombinations, cSharpWriter);
return(new ClassContent(linesOfCode, cSharpWriter.GetNameSpaces()));
}
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()));
}
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()));
}
public ClassContent Create(Type type)
{
var lines = new List <string>();
var methodTestCases = GetTestCaseSource(type, type.GetMethods);
var ctorTestCases = GetTestCaseSource(type, type.GetConstructors);
if (!methodTestCases.Union(ctorTestCases).Any())
{
return(ClassContent.NoContent);
}
if (methodTestCases.Any())
{
var testCaseSource = $"Invalid_argument_testcases";
lines.Add($"private static IEnumerable<TestCaseData> {testCaseSource}()");
lines.Add("{");
foreach (var line in methodTestCases)
{
lines.Add(new string(' ', 4) + line);
}
lines.Add("}");
lines.Add(string.Empty);
lines.Add($"[TestCaseSource(nameof({testCaseSource}))]");
lines.Add($"public void Method_invalid_arguments(TestDelegate testDelegate)");
lines.Add("{");
lines.Add(" Assert.Throws<ArgumentException>(testDelegate);");
lines.Add("}");
}
if (methodTestCases.Any() && ctorTestCases.Any())
{
lines.Add(string.Empty);
}
if (ctorTestCases.Any())
{
var testCaseSource = $"Constructor_invalid_argument_testcases";
lines.Add($"public static IEnumerable<TestCaseData> {testCaseSource}()");
lines.Add("{");
foreach (var line in ctorTestCases)
{
lines.Add(new string(' ', 4) + line);
}
lines.Add("}");
lines.Add(string.Empty);
lines.Add($"[TestCaseSource(nameof({testCaseSource}))]");
lines.Add($"public void Constructor_invalid_arguments(TestDelegate testDelegate)");
lines.Add("{");
lines.Add(" Assert.Throws<ArgumentException>(testDelegate);");
lines.Add("}");
}
return(new ClassContent(lines.ToArray(), m_CSharpService.GetNameSpaces()));
}
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()));
}