public void WithoutQualification_Unchanged(string assemblyName, string name)
{
var assembly = InsTypeFactory.ParseAssemblyName(assemblyName);
var newAssembly = assembly.WithoutQualification(name);
Assert.That(newAssembly, Is.SameAs(assembly));
}
public void Assembly_QualifiedName(string assemblyName, params string[] qualifications)
{
var assembly = InsTypeFactory.ParseAssemblyName(assemblyName);
Assert.That(assembly.Name, Is.EqualTo("Foo"));
Assert.That(assembly.Qualifications.Select(x => x.Name + "|" + x.Value), Is.EqualTo(qualifications));
}
public void Type_ComplexAssemblyLocation()
{
var expected =
@"Generic:
NamedType:
""Baz""
Assembly:
""Quux""
ArrayType:
NamedType:
""Foo.Bar""
Assembly:
""FooBar""
Qualification:
""Culture""
""neu""tr]al""
Qualification:
""Frob""
""bar]x""
Qualification:
""Version""
""3.14""
2
";
// Ensure we can correctly locate the start of the assembly dispite complex syntax along the way.
Assert.That(TreeRenderer.Format(InsTypeFactory.ParseTypeName("Baz[[Foo.Bar[,], FooBar, Culture=\"neu\\\"tr]al\", Frob=bar\\]x, Version=3.14]], Quux")), Is.EqualTo(expected));
}
public void GetProcessorArchitecture(string assemblyName, bool success, ProcessorArchitecture processorArchitecture)
{
var assembly = InsTypeFactory.ParseAssemblyName(assemblyName);
Assert.That(assembly.TryGetProcessorArchitecture(out var architecture), Is.EqualTo(success));
Assert.That(architecture, Is.EqualTo(processorArchitecture));
}
public string Assembly_UnqualifiedName(string assemblyName)
{
var assembly = InsTypeFactory.ParseAssemblyName(assemblyName);
Assert.That(assembly.Qualifications, Is.Empty);
return(assembly.Name);
}
public void GetPublicKey_Invalid(string assemblyName)
{
var assembly = InsTypeFactory.ParseAssemblyName(assemblyName);
Assert.That(
() => assembly.TryGetPublicKey(out _),
Throws.Exception.TypeOf <FormatException>()
.With.Message.EqualTo("PublicKey qualification was provided, but was in an unrecognised format."));
}
public void Type_Unqualified()
{
var expected =
@"NamedType:
""Foo.Bar""
";
Assert.That(TreeRenderer.Format(InsTypeFactory.ParseTypeName("Foo.Bar")), Is.EqualTo(expected));
}
public string?TryGetQualification(string name)
{
var assembly = InsTypeFactory.ParseAssemblyName("Foo, Bar=A, Baz=B, Quux=C");
if (!assembly.TryGetQualification(name, out var result))
{
return(null);
}
return(result ?? "<null>");
}
public void Type_ByRef()
{
var expected =
@"ByRef:
NamedType:
""Foo.Bar""
Assembly:
""FooBar""
";
Assert.That(TreeRenderer.Format(InsTypeFactory.ParseTypeName("Foo.Bar&, FooBar")), Is.EqualTo(expected));
}
public void Type_Nested()
{
var expected =
@"NamedType:
""Baz""
NamedType:
""Foo.Bar""
Assembly:
""FooBar""
";
Assert.That(TreeRenderer.Format(InsTypeFactory.ParseTypeName("Foo.Bar+Baz, FooBar")), Is.EqualTo(expected));
}
public void Type_PointerPointer()
{
var expected =
@"Pointer:
Pointer:
NamedType:
""Foo.Bar""
Assembly:
""FooBar""
";
Assert.That(TreeRenderer.Format(InsTypeFactory.ParseTypeName("Foo.Bar**, FooBar")), Is.EqualTo(expected));
}
public string?Assembly_Invalid(string assemblyName)
{
try
{
InsTypeFactory.ParseAssemblyName(assemblyName);
Assert.Fail("Expected to throw an InvalidTypeNameException.");
return(null);
}
catch (InvalidTypeNameException ex)
{
return(ex.Message);
}
}
public void Type_Array2()
{
var expected =
@"ArrayType:
NamedType:
""Foo.Bar""
Assembly:
""FooBar""
2
";
Assert.That(TreeRenderer.Format(InsTypeFactory.ParseTypeName("Foo.Bar[,], FooBar")), Is.EqualTo(expected));
}
public void Type_GenericWithUnquolifiedArg1()
{
var expected =
@"Generic:
NamedType:
""Foo.Bar`1""
Assembly:
""FooBar""
NamedType:
""Baz""
";
Assert.That(TreeRenderer.Format(InsTypeFactory.ParseTypeName("Foo.Bar`1[Baz], FooBar")), Is.EqualTo(expected));
}
public void GetPublicKey(string assemblyName, bool success, byte[] token)
{
var assembly = InsTypeFactory.ParseAssemblyName(assemblyName);
if (success)
{
Assert.That(assembly.TryGetPublicKey(out var value), Is.True);
Assert.That(value, Is.EqualTo(token));
}
else
{
Assert.That(assembly.TryGetPublicKey(out var value), Is.False);
Assert.That(value, Is.Null);
}
}
public void GetVersion(string assemblyName, string expectedVersion)
{
var assembly = InsTypeFactory.ParseAssemblyName(assemblyName);
if (expectedVersion == null)
{
Assert.That(assembly.TryGetVersion(out var version), Is.False);
Assert.That(version, Is.Null);
}
else
{
Assert.That(assembly.TryGetVersion(out var version), Is.True);
Assert.That(version, Is.EqualTo(Version.Parse(expectedVersion)));
}
}
public void Type_ArrayOfGeneric()
{
var expected =
@"SZArrayType:
Generic:
NamedType:
""Foo.Bar`1""
Assembly:
""FooBar""
NamedType:
""Baz""
";
Assert.That(TreeRenderer.Format(InsTypeFactory.ParseTypeName("Foo.Bar`1[Baz][], FooBar")), Is.EqualTo(expected));
}
public void Type_FullyQualified()
{
var expected =
@"NamedType:
""Foo.Bar.Baz""
Assembly:
""FooBar""
Qualification:
""Culture""
""neutral""
Qualification:
""Version""
""3.14""
";
Assert.That(TreeRenderer.Format(InsTypeFactory.ParseTypeName("Foo.Bar.Baz, FooBar, Culture=neutral, Version=3.14")), Is.EqualTo(expected));
}
public string WithVersion(string assemblyName, string version)
{
return(InsFormatter.Format(
InsTypeFactory.ParseAssemblyName(assemblyName)
.WithVersion(Version.Parse(version))));
}
public string WithPublicKey(string assemblyName, byte[] publicKey)
{
return(InsFormatter.Format(
InsTypeFactory.ParseAssemblyName(assemblyName)
.WithPublicKey(publicKey)));
}
public string TryGetProcessorArchitecture(string assemblyName, ProcessorArchitecture processorArchitecture)
{
return(InsFormatter.Format(
InsTypeFactory.ParseAssemblyName(assemblyName)
.WithProcessorArchitecture(processorArchitecture)));
}
public string WithoutQualification(string assemblyName, string name)
{
return(InsFormatter.Format(
InsTypeFactory.ParseAssemblyName(assemblyName)
.WithoutQualification(name)));
}
