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)
{
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)
{
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()));
}
private string DummyValue(ParameterInfo arg, CSharpService cSharpService)
{
return(!arg.ParameterType.IsValueType || arg.ParameterType.IsArray
? "null"
: cSharpService.GetInstantiation(arg.ParameterType, nonDefault: false));
}