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))); }