public unsafe void TestDefinitionHashCodes()
{
var wr = new Writer.MetadataWriter();
wr.ScopeDefinitions.Add(BuildSimpleTestDefinitionData());
var ms = new MemoryStream();
wr.Write(ms);
fixed(byte *pBuffer = ms.ToArray())
{
var rd = new Reader.MetadataReader((IntPtr)pBuffer, (int)ms.Length);
Reader.ScopeDefinitionHandle scopeHandle = rd.ScopeDefinitions.Single();
Reader.ScopeDefinition systemRuntimeScope = scopeHandle.GetScopeDefinition(rd);
// Validate root type hash code
Reader.NamespaceDefinition rootNamespace = systemRuntimeScope.RootNamespaceDefinition.GetNamespaceDefinition(rd);
Reader.TypeDefinitionHandle moduleTypeHandle = rootNamespace.TypeDefinitions.Single();
Assert.Equal(TypeHashingAlgorithms.ComputeNameHashCode("<Module>"), MetadataTypeHashingAlgorithms.ComputeHashCode(moduleTypeHandle, rd));
// Validate namespace type hashcode
Reader.NamespaceDefinition systemNamespace = rootNamespace.NamespaceDefinitions.Single().GetNamespaceDefinition(rd);
Reader.TypeDefinitionHandle objectTypeHandle = systemNamespace.TypeDefinitions.Single();
int objectHashCode = TypeHashingAlgorithms.ComputeNameHashCode("System.Object");
Assert.Equal(objectHashCode, MetadataTypeHashingAlgorithms.ComputeHashCode(objectTypeHandle, rd));
// Validate nested type hashcode
Reader.TypeDefinitionHandle nestedTypeHandle = objectTypeHandle.GetTypeDefinition(rd).NestedTypes.Single();
int nestedHashCode = TypeHashingAlgorithms.ComputeNestedTypeHashCode(objectHashCode, TypeHashingAlgorithms.ComputeNameHashCode("Nested"));
Assert.Equal(nestedHashCode, MetadataTypeHashingAlgorithms.ComputeHashCode(nestedTypeHandle, rd));
// Validate really nested type hashcode
Reader.TypeDefinitionHandle reallyNestedTypeHandle = nestedTypeHandle.GetTypeDefinition(rd).NestedTypes.Single();
int reallyNestedHashCode = TypeHashingAlgorithms.ComputeNestedTypeHashCode(nestedHashCode, TypeHashingAlgorithms.ComputeNameHashCode("ReallyNested"));
Assert.Equal(reallyNestedHashCode, MetadataTypeHashingAlgorithms.ComputeHashCode(reallyNestedTypeHandle, rd));
}
}
public unsafe static void TestCommonTailOptimization()
{
var wr = new Writer.MetadataWriter();
wr.ScopeDefinitions.Add(BuildSimpleTestData());
var ms = new MemoryStream();
wr.Write(ms);
fixed(byte *pBuffer = ms.ToArray())
{
var rd = new Reader.MetadataReader((IntPtr)pBuffer, (int)ms.Length);
Reader.ScopeDefinitionHandle scopeHandle = rd.ScopeDefinitions.Single();
Reader.ScopeDefinition systemRuntimeScope = scopeHandle.GetScopeDefinition(rd);
Reader.NamespaceDefinition rootNamespace = systemRuntimeScope.RootNamespaceDefinition.GetNamespaceDefinition(rd);
Reader.NamespaceDefinition systemNamespace =
rootNamespace.NamespaceDefinitions.Single(
ns => ns.GetNamespaceDefinition(rd).Name.StringEquals("System", rd)
).GetNamespaceDefinition(rd);
// This validates the common tail optimization.
// Since both System.Object and System.String define a default constructor and the
// records are structurally equivalent, there should only be one metadata record
// representing a default .ctor in the blob.
Reader.TypeDefinition objectType = systemNamespace.TypeDefinitions.Single(
t => t.GetTypeDefinition(rd).Name.StringEquals("Object", rd)
).GetTypeDefinition(rd);
Reader.TypeDefinition stringType = systemNamespace.TypeDefinitions.Single(
t => t.GetTypeDefinition(rd).Name.StringEquals("String", rd)
).GetTypeDefinition(rd);
Reader.MethodHandle objectCtor = objectType.Methods.Single();
Reader.MethodHandle stringCtor = stringType.Methods.Single();
Assert.True(objectCtor.Equals(stringCtor));
}
}
public static unsafe void TestCommonTailOptimization()
{
var wr = new Writer.MetadataWriter();
wr.ScopeDefinitions.Add(BuildSimpleTestData());
var ms = new MemoryStream();
wr.Write(ms);
fixed (byte* pBuffer = ms.ToArray())
{
var rd = new Reader.MetadataReader((IntPtr)pBuffer, (int)ms.Length);
Reader.ScopeDefinitionHandle scopeHandle = rd.ScopeDefinitions.Single();
Reader.ScopeDefinition systemRuntimeScope = scopeHandle.GetScopeDefinition(rd);
Reader.NamespaceDefinition rootNamespace = systemRuntimeScope.RootNamespaceDefinition.GetNamespaceDefinition(rd);
Reader.NamespaceDefinition systemNamespace =
rootNamespace.NamespaceDefinitions.Single(
ns => ns.GetNamespaceDefinition(rd).Name.StringEquals("System", rd)
).GetNamespaceDefinition(rd);
// This validates the common tail optimization.
// Since both System.Object and System.String define a default constructor and the
// records are structurally equivalent, there should only be one metadata record
// representing a default .ctor in the blob.
Reader.TypeDefinition objectType = systemNamespace.TypeDefinitions.Single(
t => t.GetTypeDefinition(rd).Name.StringEquals("Object", rd)
).GetTypeDefinition(rd);
Reader.TypeDefinition stringType = systemNamespace.TypeDefinitions.Single(
t => t.GetTypeDefinition(rd).Name.StringEquals("String", rd)
).GetTypeDefinition(rd);
Reader.MethodHandle objectCtor = objectType.Methods.Single();
Reader.MethodHandle stringCtor = stringType.Methods.Single();
Assert.True(objectCtor.Equals(stringCtor));
}
}
public unsafe void TestDefinitionHashCodes()
{
var wr = new Writer.MetadataWriter();
wr.ScopeDefinitions.Add(BuildSimpleTestDefinitionData());
var ms = new MemoryStream();
wr.Write(ms);
fixed (byte* pBuffer = ms.ToArray())
{
var rd = new Reader.MetadataReader((IntPtr)pBuffer, (int)ms.Length);
Reader.ScopeDefinitionHandle scopeHandle = rd.ScopeDefinitions.Single();
Reader.ScopeDefinition systemRuntimeScope = scopeHandle.GetScopeDefinition(rd);
// Validate root type hash code
Reader.NamespaceDefinition rootNamespace = systemRuntimeScope.RootNamespaceDefinition.GetNamespaceDefinition(rd);
Reader.TypeDefinitionHandle moduleTypeHandle = rootNamespace.TypeDefinitions.Single();
Assert.Equal(TypeHashingAlgorithms.ComputeNameHashCode("<Module>"), MetadataTypeHashingAlgorithms.ComputeHashCode(moduleTypeHandle, rd));
// Validate namespace type hashcode
Reader.NamespaceDefinition systemNamespace = rootNamespace.NamespaceDefinitions.Single().GetNamespaceDefinition(rd);
Reader.TypeDefinitionHandle objectTypeHandle = systemNamespace.TypeDefinitions.Single();
int objectHashCode = TypeHashingAlgorithms.ComputeNameHashCode("System.Object");
Assert.Equal(objectHashCode, MetadataTypeHashingAlgorithms.ComputeHashCode(objectTypeHandle, rd));
// Validate nested type hashcode
Reader.TypeDefinitionHandle nestedTypeHandle = objectTypeHandle.GetTypeDefinition(rd).NestedTypes.Single();
int nestedHashCode = TypeHashingAlgorithms.ComputeNestedTypeHashCode(objectHashCode, TypeHashingAlgorithms.ComputeNameHashCode("Nested"));
Assert.Equal(nestedHashCode, MetadataTypeHashingAlgorithms.ComputeHashCode(nestedTypeHandle, rd));
// Validate really nested type hashcode
Reader.TypeDefinitionHandle reallyNestedTypeHandle = nestedTypeHandle.GetTypeDefinition(rd).NestedTypes.Single();
int reallyNestedHashCode = TypeHashingAlgorithms.ComputeNestedTypeHashCode(nestedHashCode, TypeHashingAlgorithms.ComputeNameHashCode("ReallyNested"));
Assert.Equal(reallyNestedHashCode, MetadataTypeHashingAlgorithms.ComputeHashCode(reallyNestedTypeHandle, rd));
}
}
public unsafe static void TestSimpleRoundTripping()
{
var wr = new Writer.MetadataWriter();
wr.ScopeDefinitions.Add(BuildSimpleTestData());
var ms = new MemoryStream();
wr.Write(ms);
fixed (byte* pBuffer = ms.ToArray())
{
var rd = new Reader.MetadataReader((IntPtr)pBuffer, (int)ms.Length);
// Validate the System.Runtime scope
Reader.ScopeDefinitionHandle scopeHandle = rd.ScopeDefinitions.Single();
Reader.ScopeDefinition systemRuntimeScope = scopeHandle.GetScopeDefinition(rd);
Assert.Equal(4, systemRuntimeScope.MajorVersion);
Assert.Equal("System.Runtime", systemRuntimeScope.Name.GetConstantStringValue(rd).Value);
// Validate the root namespace and <Module> type
Reader.NamespaceDefinition rootNamespace = systemRuntimeScope.RootNamespaceDefinition.GetNamespaceDefinition(rd);
Assert.Equal(1, rootNamespace.TypeDefinitions.Count());
Reader.TypeDefinition moduleType = rootNamespace.TypeDefinitions.Single().GetTypeDefinition(rd);
Assert.Equal("<Module>", moduleType.Name.GetConstantStringValue(rd).Value);
Assert.Equal(1, rootNamespace.NamespaceDefinitions.Count());
// Validate the System namespace
Reader.NamespaceDefinition systemNamespace = rootNamespace.NamespaceDefinitions.Single().GetNamespaceDefinition(rd);
Assert.Equal(4, systemNamespace.TypeDefinitions.Count());
foreach (var typeHandle in systemNamespace.TypeDefinitions)
{
Reader.TypeDefinition type = typeHandle.GetTypeDefinition(rd);
string typeName = type.Name.GetConstantStringValue(rd).Value;
string baseTypeName = null;
if (!type.BaseType.IsNull(rd))
{
baseTypeName = type.BaseType.ToTypeDefinitionHandle(rd).GetTypeDefinition(rd).Name.GetConstantStringValue(rd).Value;
}
switch (typeName)
{
case "Object":
Assert.Null(baseTypeName);
Assert.Equal(1, type.Methods.Count());
break;
case "Void":
Assert.Equal("ValueType", baseTypeName);
Assert.Equal(0, type.Methods.Count());
break;
case "String":
Assert.Equal("Object", baseTypeName);
Assert.Equal(1, type.Methods.Count());
break;
case "ValueType":
Assert.Equal("Object", baseTypeName);
Assert.Equal(0, type.Methods.Count());
break;
default:
throw new NotImplementedException();
}
}
}
}
public unsafe static void TestSimpleRoundTripping()
{
var wr = new Writer.MetadataWriter();
wr.ScopeDefinitions.Add(BuildSimpleTestData());
var ms = new MemoryStream();
wr.Write(ms);
fixed(byte *pBuffer = ms.ToArray())
{
var rd = new Reader.MetadataReader((IntPtr)pBuffer, (int)ms.Length);
// Validate the System.Runtime scope
Reader.ScopeDefinitionHandle scopeHandle = rd.ScopeDefinitions.Single();
Reader.ScopeDefinition systemRuntimeScope = scopeHandle.GetScopeDefinition(rd);
Assert.Equal(4, systemRuntimeScope.MajorVersion);
Assert.Equal("System.Runtime", systemRuntimeScope.Name.GetConstantStringValue(rd).Value);
// Validate the root namespace and <Module> type
Reader.NamespaceDefinition rootNamespace = systemRuntimeScope.RootNamespaceDefinition.GetNamespaceDefinition(rd);
Assert.Equal(1, rootNamespace.TypeDefinitions.Count());
Reader.TypeDefinition moduleType = rootNamespace.TypeDefinitions.Single().GetTypeDefinition(rd);
Assert.Equal("<Module>", moduleType.Name.GetConstantStringValue(rd).Value);
Assert.Equal(1, rootNamespace.NamespaceDefinitions.Count());
// Validate the System namespace
Reader.NamespaceDefinition systemNamespace = rootNamespace.NamespaceDefinitions.Single().GetNamespaceDefinition(rd);
Assert.Equal(4, systemNamespace.TypeDefinitions.Count());
foreach (var typeHandle in systemNamespace.TypeDefinitions)
{
Reader.TypeDefinition type = typeHandle.GetTypeDefinition(rd);
string typeName = type.Name.GetConstantStringValue(rd).Value;
string baseTypeName = null;
if (!type.BaseType.IsNull(rd))
{
baseTypeName = type.BaseType.ToTypeDefinitionHandle(rd).GetTypeDefinition(rd).Name.GetConstantStringValue(rd).Value;
}
switch (typeName)
{
case "Object":
Assert.Null(baseTypeName);
Assert.Equal(1, type.Methods.Count());
break;
case "Void":
Assert.Equal("ValueType", baseTypeName);
Assert.Equal(0, type.Methods.Count());
break;
case "String":
Assert.Equal("Object", baseTypeName);
Assert.Equal(1, type.Methods.Count());
break;
case "ValueType":
Assert.Equal("Object", baseTypeName);
Assert.Equal(0, type.Methods.Count());
break;
default:
throw new NotImplementedException();
}
}
}
}
public unsafe void TestReferenceHashCodes()
{
var wr = new Writer.MetadataWriter();
var systemRuntimeScopeRecord = new Writer.ScopeReference
{
Name = (Writer.ConstantStringValue) "System.Runtime",
MajorVersion = 4,
};
var rootNamespaceRecord = new Writer.NamespaceReference
{
Name = null,
ParentScopeOrNamespace = systemRuntimeScopeRecord,
};
var fooTypeRecord = new Writer.TypeReference
{
ParentNamespaceOrType = rootNamespaceRecord,
TypeName = (Writer.ConstantStringValue) "Foo",
};
var nestedTypeRecord = new Writer.TypeReference
{
ParentNamespaceOrType = fooTypeRecord,
TypeName = (Writer.ConstantStringValue) "Nested",
};
var reallyNestedTypeRecord = new Writer.TypeReference
{
ParentNamespaceOrType = nestedTypeRecord,
TypeName = (Writer.ConstantStringValue) "ReallyNested",
};
var systemNamespaceRecord = new Writer.NamespaceReference
{
Name = (Writer.ConstantStringValue) "System",
ParentScopeOrNamespace = rootNamespaceRecord,
};
var objectTypeRecord = new Writer.TypeReference
{
ParentNamespaceOrType = systemNamespaceRecord,
TypeName = (Writer.ConstantStringValue) "Object",
};
wr.AdditionalRootRecords.Add(objectTypeRecord);
wr.AdditionalRootRecords.Add(fooTypeRecord);
wr.AdditionalRootRecords.Add(nestedTypeRecord);
wr.AdditionalRootRecords.Add(reallyNestedTypeRecord);
var ms = new MemoryStream();
wr.Write(ms);
fixed(byte *pBuffer = ms.ToArray())
{
var rd = new Reader.MetadataReader((IntPtr)pBuffer, (int)ms.Length);
var fooTypeHandle = new Reader.TypeReferenceHandle(wr.GetRecordHandle(fooTypeRecord));
var fooTypeHashCode = TypeHashingAlgorithms.ComputeNameHashCode("Foo");
Assert.Equal(fooTypeHashCode, MetadataTypeHashingAlgorithms.ComputeHashCode(fooTypeHandle, rd));
var objectTypeHandle = new Reader.TypeReferenceHandle(wr.GetRecordHandle(objectTypeRecord));
Assert.Equal(TypeHashingAlgorithms.ComputeNameHashCode("System.Object"), MetadataTypeHashingAlgorithms.ComputeHashCode(objectTypeHandle, rd));
var nestedTypeHandle = new Reader.TypeReferenceHandle(wr.GetRecordHandle(nestedTypeRecord));
var nestedTypeHashCode = TypeHashingAlgorithms.ComputeNestedTypeHashCode(fooTypeHashCode, TypeHashingAlgorithms.ComputeNameHashCode("Nested"));
Assert.Equal(nestedTypeHashCode, MetadataTypeHashingAlgorithms.ComputeHashCode(nestedTypeHandle, rd));
var reallyNestedTypeHandle = new Reader.TypeReferenceHandle(wr.GetRecordHandle(reallyNestedTypeRecord));
var reallyNestedTypeHashCode = TypeHashingAlgorithms.ComputeNestedTypeHashCode(nestedTypeHashCode, TypeHashingAlgorithms.ComputeNameHashCode("ReallyNested"));
Assert.Equal(reallyNestedTypeHashCode, MetadataTypeHashingAlgorithms.ComputeHashCode(reallyNestedTypeHandle, rd));
}
}
public unsafe void TestReferenceHashCodes()
{
var wr = new Writer.MetadataWriter();
var systemRuntimeScopeRecord = new Writer.ScopeReference
{
Name = (Writer.ConstantStringValue)"System.Runtime",
MajorVersion = 4,
};
var rootNamespaceRecord = new Writer.NamespaceReference
{
Name = null,
ParentScopeOrNamespace = systemRuntimeScopeRecord,
};
var fooTypeRecord = new Writer.TypeReference
{
ParentNamespaceOrType = rootNamespaceRecord,
TypeName = (Writer.ConstantStringValue)"Foo",
};
var nestedTypeRecord = new Writer.TypeReference
{
ParentNamespaceOrType = fooTypeRecord,
TypeName = (Writer.ConstantStringValue)"Nested",
};
var reallyNestedTypeRecord = new Writer.TypeReference
{
ParentNamespaceOrType = nestedTypeRecord,
TypeName = (Writer.ConstantStringValue)"ReallyNested",
};
var systemNamespaceRecord = new Writer.NamespaceReference
{
Name = (Writer.ConstantStringValue)"System",
ParentScopeOrNamespace = rootNamespaceRecord,
};
var objectTypeRecord = new Writer.TypeReference
{
ParentNamespaceOrType = systemNamespaceRecord,
TypeName = (Writer.ConstantStringValue)"Object",
};
wr.AdditionalRootRecords.Add(objectTypeRecord);
wr.AdditionalRootRecords.Add(fooTypeRecord);
wr.AdditionalRootRecords.Add(nestedTypeRecord);
wr.AdditionalRootRecords.Add(reallyNestedTypeRecord);
var ms = new MemoryStream();
wr.Write(ms);
fixed (byte* pBuffer = ms.ToArray())
{
var rd = new Reader.MetadataReader((IntPtr)pBuffer, (int)ms.Length);
var fooTypeHandle = new Reader.TypeReferenceHandle(wr.GetRecordHandle(fooTypeRecord));
var fooTypeHashCode = TypeHashingAlgorithms.ComputeNameHashCode("Foo");
Assert.Equal(fooTypeHashCode, MetadataTypeHashingAlgorithms.ComputeHashCode(fooTypeHandle, rd));
var objectTypeHandle = new Reader.TypeReferenceHandle(wr.GetRecordHandle(objectTypeRecord));
Assert.Equal(TypeHashingAlgorithms.ComputeNameHashCode("System.Object"), MetadataTypeHashingAlgorithms.ComputeHashCode(objectTypeHandle, rd));
var nestedTypeHandle = new Reader.TypeReferenceHandle(wr.GetRecordHandle(nestedTypeRecord));
var nestedTypeHashCode = TypeHashingAlgorithms.ComputeNestedTypeHashCode(fooTypeHashCode, TypeHashingAlgorithms.ComputeNameHashCode("Nested"));
Assert.Equal(nestedTypeHashCode , MetadataTypeHashingAlgorithms.ComputeHashCode(nestedTypeHandle, rd));
var reallyNestedTypeHandle = new Reader.TypeReferenceHandle(wr.GetRecordHandle(reallyNestedTypeRecord));
var reallyNestedTypeHashCode = TypeHashingAlgorithms.ComputeNestedTypeHashCode(nestedTypeHashCode, TypeHashingAlgorithms.ComputeNameHashCode("ReallyNested"));
Assert.Equal(reallyNestedTypeHashCode, MetadataTypeHashingAlgorithms.ComputeHashCode(reallyNestedTypeHandle, rd));
}
}
