private static object CreateInstance(BuildXLContext context, Type type, bool booleanDefault)
{
string path = A("x", "path");
type = GetNonNullableType(type);
if (type == typeof(bool))
{
return(booleanDefault);
}
if (type == typeof(double))
{
return((double)0.23423);
}
if (type == typeof(byte))
{
return((byte)123);
}
if (type == typeof(sbyte))
{
return((sbyte)123);
}
if (type == typeof(short))
{
return((short)123);
}
if (type == typeof(ushort))
{
return((ushort)123);
}
if (type == typeof(int))
{
return(123);
}
if (type == typeof(uint))
{
return((uint)123);
}
if (type == typeof(long))
{
return((long)123);
}
if (type == typeof(ulong))
{
return((ulong)123);
}
if (type == typeof(string))
{
return("nonDefaultString");
}
if (type == typeof(ModuleId))
{
return(new ModuleId(123));
}
if (type == typeof(LocationData))
{
return(new LocationData(AbsolutePath.Create(context.PathTable, path), 12, 23));
}
if (type == typeof(AbsolutePath))
{
return(AbsolutePath.Create(context.PathTable, path));
}
if (type == typeof(RelativePath))
{
string relativePath = R("rel1", "dir1", "path");
return(RelativePath.Create(context.StringTable, relativePath));
}
if (type == typeof(FileArtifact))
{
return(FileArtifact.CreateSourceFile(AbsolutePath.Create(context.PathTable, path)));
}
if (type == typeof(PathAtom))
{
return(PathAtom.Create(context.StringTable, "atom"));
}
if (type == typeof(global::BuildXL.Utilities.LineInfo))
{
return(new global::BuildXL.Utilities.LineInfo(1, 1));
}
if (type.GetTypeInfo().IsEnum)
{
bool first = true;
foreach (var value in Enum.GetValues(type))
{
if (!first)
{
return(value);
}
first = false;
}
XAssert.Fail($"Enum {type.FullName} doesn't have more than one value, so can't pick the second one.");
}
if (type.GetTypeInfo().IsGenericType)
{
var generic = type.GetGenericTypeDefinition();
if (generic == typeof(IReadOnlyList <>))
{
// Treat IReadOnlyList as if it was List
type = typeof(List <>).MakeGenericType(type.GenericTypeArguments[0]);
generic = type.GetGenericTypeDefinition();
}
if (generic == typeof(List <>))
{
var newList = (IList)Activator.CreateInstance(type);
newList.Add(CreateInstance(context, type.GenericTypeArguments[0], booleanDefault));
return(newList);
}
if (generic == typeof(IReadOnlyDictionary <,>))
{
// Treat IReadOnlyList as if it was List
type = typeof(Dictionary <,>).MakeGenericType(type.GenericTypeArguments[0], type.GenericTypeArguments[1]);
generic = type.GetGenericTypeDefinition();
}
if (generic == typeof(Dictionary <,>))
{
var newDictionary = (IDictionary)Activator.CreateInstance(type);
newDictionary.Add(
CreateInstance(context, type.GenericTypeArguments[0], booleanDefault),
CreateInstance(context, type.GenericTypeArguments[1], booleanDefault));
return(newDictionary);
}
}
if (type.GetTypeInfo().IsInterface)
{
// Treat interfaces as if it was the mutable class
type = ConfigurationConverter.FindImplementationType(
type,
ObjectLiteral.Create(new List <Binding>(), default(LineInfo), AbsolutePath.Invalid),
// Return a SourceResolver to instantiate
() => "SourceResolver");
}
if (type.GetTypeInfo().IsClass)
{
var instance = Activator.CreateInstance(type);
PopulateObject(context, type, instance, booleanDefault);
return(instance);
}
XAssert.Fail($"Don't know how to create objects for this type: {type.FullName}.");
return(null);
}
public static void ValidateEqual(BuildXLContext context, Type type, object expected, object actual, string objPath, Remapper remapper)
{
type = GetNonNullableType(type);
if (type == typeof(bool))
{
XAssert.AreEqual((bool)expected, (bool)actual, $"{nameof(Boolean)} values don't match for objPath: {objPath}");
return;
}
if (type == typeof(int) || type == typeof(short) || type == typeof(sbyte) || type == typeof(long))
{
XAssert.AreEqual(
Convert.ToInt64(expected),
Convert.ToInt64(actual),
$"Numeric values don't match for objPath: {objPath}");
return;
}
if (type == typeof(uint) || type == typeof(ushort) || type == typeof(byte) || type == typeof(ulong))
{
XAssert.AreEqual(
Convert.ToUInt64(expected),
Convert.ToUInt64(actual),
$"Numeric values don't match for objPath: {objPath}");
return;
}
if (type == typeof(double))
{
XAssert.AreEqual(
Convert.ToDouble(expected),
Convert.ToDouble(actual),
$"Numeric values don't match for objPath: {objPath}");
return;
}
if (type == typeof(string))
{
XAssert.AreEqual((string)expected, (string)actual, $"{nameof(String)} values don't match for objPath: {objPath}");
return;
}
if (type == typeof(ModuleId))
{
XAssert.AreEqual(
(ModuleId)expected,
(ModuleId)actual,
$"{nameof(ModuleId)} id values don't match for objPath: {objPath}");
return;
}
if (type == typeof(LocationData))
{
AssertEqualLocationData(context, objPath, remapper, (LocationData)expected, (LocationData)actual);
return;
}
if (type == typeof(RelativePath))
{
AssertEqualRelativePaths(context, objPath, remapper, (RelativePath)expected, (RelativePath)actual);
return;
}
if (type == typeof(AbsolutePath))
{
AssertEqualAbsolutePaths(context, objPath, remapper, (AbsolutePath)expected, (AbsolutePath)actual);
return;
}
if (type == typeof(FileArtifact))
{
AssertEqualFileArtifacts(context, objPath, remapper, (FileArtifact)expected, (FileArtifact)actual);
return;
}
if (type == typeof(PathAtom))
{
AssertEqualPathAtoms(context, objPath, remapper, (PathAtom)expected, (PathAtom)actual);
return;
}
if (type == typeof(SymbolAtom))
{
XAssert.AreEqual((SymbolAtom)expected, (SymbolAtom)actual, $"{nameof(SymbolAtom)} values don't match for objPath: {objPath}");
return;
}
if (type == typeof(global::BuildXL.Utilities.LineInfo))
{
XAssert.AreEqual(
(global::BuildXL.Utilities.LineInfo)expected,
(global::BuildXL.Utilities.LineInfo)actual,
$"{nameof(global::BuildXL.Utilities.LineInfo)} values don't match for objPath: {objPath}");
return;
}
if (type == typeof(LineInfo))
{
XAssert.AreEqual(
(LineInfo)expected,
(LineInfo)actual,
$"{nameof(LineInfo)} values don't match for objPath: {objPath}");
return;
}
if (type.GetTypeInfo().IsEnum)
{
XAssert.AreEqual((Enum)expected, (Enum)actual, $"Enum values don't match for objPath: {objPath}");
return;
}
if (type.GetTypeInfo().IsGenericType)
{
var generic = type.GetGenericTypeDefinition();
if (generic == typeof(List <>) || generic == typeof(IReadOnlyList <>))
{
XAssert.IsTrue((expected == null) == (actual == null));
var expectedList = expected as IList;
var actualList = actual as IList;
XAssert.IsTrue(
(expectedList == null) == (actualList == null),
"One of the lists is null, the other isnt for objPath: {0}",
objPath);
if (expectedList != null)
{
XAssert.AreEqual(expectedList.Count, actualList.Count, $"Counts of lists don't match for objPath: {objPath}");
for (int i = 0; i < expectedList.Count; i++)
{
ValidateEqual(
context,
type.GenericTypeArguments[0],
expectedList[i],
actualList[i],
objPath + "[" + i.ToString(CultureInfo.InvariantCulture) + "]",
remapper);
}
}
return;
}
if (generic == typeof(Dictionary <,>) || generic == typeof(IReadOnlyDictionary <,>) || generic == typeof(ConcurrentDictionary <,>))
{
XAssert.IsTrue((expected == null) == (actual == null));
var expectedDictionary = expected as IDictionary;
var actualDictionary = actual as IDictionary;
XAssert.IsTrue(
(expectedDictionary == null) == (actualDictionary == null),
$"One of the dictionaries is null, the other isnt for objPath: {objPath}");
if (expectedDictionary != null)
{
XAssert.AreEqual(
expectedDictionary.Count,
expectedDictionary.Count,
$"Counts of dictionaries don't match for objPath: {objPath}");
foreach (var kv in expectedDictionary)
{
var key = kv.GetType().GetProperty("Key").GetValue(kv);
var value = kv.GetType().GetTypeInfo().GetProperty("Value").GetValue(kv);
var actualValue = actualDictionary[key];
ValidateEqual(context, type.GenericTypeArguments[1], value, actualValue, objPath + "[" + key + "]", remapper);
}
}
return;
}
}
if (type.GetTypeInfo().IsInterface)
{
var actualType = ConfigurationConverter.FindImplementationType(
type,
ObjectLiteral.Create(new List <Binding>(), default(LineInfo), AbsolutePath.Invalid),
// Note we only create a sourceresolver, so no need to fiddle, just compare with SourceResolver.
() => "SourceResolver");
ValidateEqualMembers(context, actualType, expected, actual, objPath, remapper);
return;
}
if (type.GetTypeInfo().IsClass)
{
ValidateEqualMembers(context, type, expected, actual, objPath, remapper);
return;
}
XAssert.Fail($"Don't know how to compare objects of this type '{type}' for objPath: {objPath}");
}