public static void ResolveEventMultipleCalls() { using (TypeLoader tl = new TypeLoader()) { int resolveHandlerCallCount = 0; Assembly basesAssembly = tl.LoadFromByteArray(TestData.s_BaseClassesImage); tl.Resolving += delegate(TypeLoader sender, AssemblyName name) { resolveHandlerCallCount++; return(basesAssembly); }; Assembly derived = tl.LoadFromByteArray(TestData.s_DerivedClassWithVariationsOnFooImage); int expectedCount = 1; foreach (string typeName in new string[] { "Derived1", "Derived3", "Derived4", "Derived5", "Derived6" }) { Type t = derived.GetType(typeName, throwOnError: true); Type bt = t.BaseType; Assert.Equal(basesAssembly, bt.Assembly); Assert.Equal(expectedCount++, resolveHandlerCallCount); } } }
public static void CrossAssemblyTypeRefToNestedType() { using (TypeLoader tl = new TypeLoader()) { Assembly a = tl.LoadFromByteArray(TestData.s_AssemblyWithNestedTypeImage); Assembly n = tl.LoadFromByteArray(TestData.s_AssemblyWithTypeRefToNestedTypeImage); Type nt = n.GetType("N", throwOnError: true); Type bt = nt.BaseType; Type expected = a.GetType("Outer+Inner+ReallyInner", throwOnError: true); Assert.Equal(expected, bt); } }
public static void GetAssemblies_SnapshotIsAtomic() { using (TypeLoader tl = new TypeLoader()) { Assembly a1 = tl.LoadFromByteArray(TestData.s_SimpleAssemblyImage); IEnumerable <Assembly> loadedAssembliesSnapshot = tl.GetAssemblies(); Assembly a2 = tl.LoadFromByteArray(TestData.s_SimpleNameOnlyImage); Assembly[] loadedAssemblies = loadedAssembliesSnapshot.ToArray(); Assert.Equal(1, loadedAssemblies.Length); Assert.Equal(a1, loadedAssemblies[0]); } }
public static void AssemblyGetForwardedTypes1() { using (TypeLoader tl = new TypeLoader()) { Assembly upper = tl.LoadFromByteArray(TestData.s_UpperImage); Assembly middle = tl.LoadFromByteArray(TestData.s_MiddleImage); Assembly lower = tl.LoadFromByteArray(TestData.s_LowerImage); Type[] types = upper.GetForwardedTypesThunk().OrderBy(t => t.FullName).ToArray(); string[] fullNames = types.Select(t => t.FullName).ToArray(); string[] expected = { "Middle2", "Upper2", "Upper3", "Upper3+Upper3a" }; Assert.Equal <string>(expected, fullNames); } }
public static void GetAssemblies() { using (TypeLoader tl = new TypeLoader()) { Assembly[] loadedAssemblies = tl.GetAssemblies().ToArray(); Assert.Equal(0, loadedAssemblies.Length); Assembly a1 = tl.LoadFromByteArray(TestData.s_SimpleAssemblyImage); Assembly a2 = tl.LoadFromByteArray(TestData.s_SimpleNameOnlyImage); loadedAssemblies = tl.GetAssemblies().ToArray(); Assert.Equal(2, loadedAssemblies.Length); Assert.Contains <Assembly>(a1, loadedAssemblies); Assert.Contains <Assembly>(a2, loadedAssemblies); } }
public static void ModuleResolveEvent() { using (TypeLoader tl = new TypeLoader()) { Module moduleReturnedFromEventHandler = null; Assembly a = tl.LoadFromByteArray(TestData.s_MultiModuleDllImage); a.ModuleResolve += delegate(object sender, ResolveEventArgs e) { Assert.Same(a, sender); Assert.Null(moduleReturnedFromEventHandler); // We're not doing anything to cause this to trigger twice! Assert.Equal("Bob.netmodule", e.Name); moduleReturnedFromEventHandler = a.LoadModule("Bob.netmodule", TestData.s_JoeNetModuleImage); return(moduleReturnedFromEventHandler); }; Module m = a.GetModule("Bob.netmodule"); Assert.NotNull(m); Assert.Equal(moduleReturnedFromEventHandler, m); // Make sure the event doesn't get raised twice. For a single-threaded case like this, that's a reasonable assumption. Module m1 = a.GetModule("Bob.netmodule"); } }
public static void AssemblyWithEmbeddedResources() { using (TypeLoader tl = new TypeLoader()) { Assembly a = tl.LoadFromByteArray(TestData.s_AssemblyWithEmbeddedResourcesImage); string[] names = a.GetManifestResourceNames().OrderBy(s => s).ToArray(); Assert.Equal <string>(new string[] { "MyRes1", "MyRes2", "MyRes3" }, names); foreach (string name in names) { ManifestResourceInfo mri = a.GetManifestResourceInfo(name); Assert.Equal(ResourceLocation.Embedded | ResourceLocation.ContainedInManifestFile, mri.ResourceLocation); Assert.Null(mri.FileName); Assert.Null(mri.ReferencedAssembly); } using (Stream s = a.GetManifestResourceStream("MyRes1")) { byte[] res = s.ToArray(); Assert.Equal <byte>(TestData.s_MyRes1, res); } using (Stream s = a.GetManifestResourceStream("MyRes2")) { byte[] res = s.ToArray(); Assert.Equal <byte>(TestData.s_MyRes2, res); } using (Stream s = a.GetManifestResourceStream("MyRes3")) { byte[] res = s.ToArray(); Assert.Equal <byte>(TestData.s_MyRes3, res); } } }
public static void ResolveEventReturnsSomething() { using (TypeLoader tl = new TypeLoader()) { bool resolveHandlerCalled = false; Assembly resolveEventHandlerResult = null; tl.Resolving += delegate(TypeLoader sender, AssemblyName name) { Assert.Same(tl, sender); Assert.Equal(name.Name, "Foo"); resolveHandlerCalled = true; resolveEventHandlerResult = sender.LoadFromByteArray(TestData.s_BaseClassesImage); return(resolveEventHandlerResult); }; Assembly derived = tl.LoadFromByteArray(TestData.s_DerivedClassWithVariationsOnFooImage); Type t = derived.GetType("Derived1", throwOnError: true); Type bt = t.BaseType; Assembly a = bt.Assembly; Assert.True(resolveHandlerCalled); Assert.Equal(a, resolveEventHandlerResult); } }
public static void LoadFromByteArrayNull() { using (TypeLoader tl = new TypeLoader()) { Assert.Throws <ArgumentNullException>(() => tl.LoadFromByteArray(null)); } }
public static void AssemblyName_GetName_SimpleNameOnly() { using (TypeLoader tl = new TypeLoader()) { Assembly a = tl.LoadFromByteArray(TestData.s_SimpleNameOnlyImage); AssemblyName an = a.GetName(copiedName: false); Assert.Equal("SimpleNameOnly", an.Name); Assert.Equal(AssemblyNameFlags.PublicKey, an.Flags); Version v = an.Version; Assert.NotNull(v); Assert.Equal(0, v.Major); Assert.Equal(0, v.Minor); Assert.Equal(0, v.Build); Assert.Equal(0, v.Revision); string cultureName = an.CultureName; Assert.Equal(string.Empty, cultureName); byte[] publicKey = an.GetPublicKey(); Assert.Equal(0, publicKey.Length); Assert.Equal(AssemblyContentType.Default, an.ContentType); Assert.Equal(AssemblyHashAlgorithm.SHA1, an.HashAlgorithm); Assembly aAgain = tl.LoadFromAssemblyName(an); Assert.Equal(a, aAgain); } }
public unsafe static void TestCustomModifiers1() { using (TypeLoader tl = new TypeLoader("mscorlib")) { tl.Resolving += delegate(TypeLoader sender, AssemblyName name) { if (name.Name == "mscorlib") { return(tl.LoadFromStream(TestUtils.CreateStreamForCoreAssembly())); } return(null); }; Assembly a = tl.LoadFromByteArray(TestData.s_CustomModifiersImage); Type t = a.GetType("N", throwOnError: true); Type reqA = a.GetType("ReqA", throwOnError: true); Type reqB = a.GetType("ReqB", throwOnError: true); Type reqC = a.GetType("ReqC", throwOnError: true); Type optA = a.GetType("OptA", throwOnError: true); Type optB = a.GetType("OptB", throwOnError: true); Type optC = a.GetType("OptC", throwOnError: true); MethodInfo m = t.GetMethod("MyMethod"); ParameterInfo p = m.GetParameters()[0]; Type[] req = p.GetRequiredCustomModifiers(); Type[] opt = p.GetOptionalCustomModifiers(); Assert.Equal <Type>(new Type[] { reqA, reqB, reqC }, req); Assert.Equal <Type>(new Type[] { optA, optB, optC }, opt); TestUtils.AssertNewObjectReturnedEachTime(() => p.GetRequiredCustomModifiers()); TestUtils.AssertNewObjectReturnedEachTime(() => p.GetOptionalCustomModifiers()); } }
public static void ResolveEventFromReferencedAssembliesUsingFullPublicKeyReference() { // Ecma-335 allows an assembly reference to specify a full public key rather than the token. Ensure that those references // still hand out usable AssemblyNames to resolve handlers. using (TypeLoader tl = new TypeLoader()) { AssemblyName assemblyNameReceivedByHandler = null; tl.Resolving += delegate(TypeLoader sender, AssemblyName name) { assemblyNameReceivedByHandler = name; return(null); }; Assembly a = tl.LoadFromByteArray(TestData.s_AssemblyRefUsingFullPublicKeyImage); Type t = a.GetType("C", throwOnError: true); // We expect this next to call to throw since it asks the TypeLoader to resolve [mscorlib]System.Object and our // resolve handler doesn't return anything for that. Assert.Throws <FileNotFoundException>(() => t.BaseType); // But it did get called with a request to resolve "mscorlib" and we got the correct PKT calculated from the PK. // Note that the original PK is not made available (which follows prior precedent with these apis.) It's not like // anyone binds with the full PK... Assert.NotNull(assemblyNameReceivedByHandler); byte[] expectedPkt = "b77a5c561934e089".HexToByteArray(); byte[] actualPkt = assemblyNameReceivedByHandler.GetPublicKeyToken(); Assert.Equal <byte>(expectedPkt, actualPkt); } }
public static void GetLoadModules1() { using (TypeLoader tl = new TypeLoader()) { Assembly a = tl.LoadFromByteArray(TestData.s_MultiModuleDllImage); { Module[] loadedModules = a.GetLoadedModules(getResourceModules: true); Assert.Equal(1, loadedModules.Length); Assert.Equal(a.ManifestModule, loadedModules[0]); } { Module[] loadedModules = a.GetLoadedModules(getResourceModules: false); Assert.Equal(1, loadedModules.Length); Assert.Equal(a.ManifestModule, loadedModules[0]); } Module m1 = a.LoadModule("Bob.netmodule", TestData.s_JoeNetModuleImage); { Module[] loadedModules = a.GetLoadedModules(getResourceModules: true); Assert.Equal(2, loadedModules.Length); Assert.Contains <Module>(a.ManifestModule, loadedModules); Assert.Contains <Module>(m1, loadedModules); } { Module[] loadedModules = a.GetLoadedModules(getResourceModules: false); Assert.Equal(2, loadedModules.Length); Assert.Contains <Module>(a.ManifestModule, loadedModules); Assert.Contains <Module>(m1, loadedModules); } } }
public static void ResolveEventNoUnnecessaryCalls() { // In a single-threaded scenario at least, TypeLoaders shouldn't ask the event to bind the same name twice. using (TypeLoader tl = new TypeLoader()) { int resolveHandlerCallCount = 0; Assembly resolveEventHandlerResult = null; tl.Resolving += delegate(TypeLoader sender, AssemblyName name) { if (name.Name == "Foo") { resolveHandlerCallCount++; resolveEventHandlerResult = sender.LoadFromByteArray(TestData.s_BaseClassesImage); return(resolveEventHandlerResult); } return(null); }; Assembly derived = tl.LoadFromByteArray(TestData.s_DerivedClassWithVariationsOnFooImage); Type t1 = derived.GetType("Derived1", throwOnError: true); Type bt1 = t1.BaseType; Type t2 = derived.GetType("Derived2", throwOnError: true); Type bt2 = t2.BaseType; Assert.Equal(1, resolveHandlerCallCount); Assert.Equal(resolveEventHandlerResult, bt1.Assembly); Assert.Equal(resolveEventHandlerResult, bt2.Assembly); } }
public static void LoadModule_CannotLoadModuleNotInManifest() { using (TypeLoader tl = new TypeLoader()) { Assembly a = tl.LoadFromByteArray(TestData.s_MultiModuleDllImage); Assert.Throws <ArgumentException>(() => a.LoadModule("NotInManifest.dll", TestData.s_JoeNetModuleImage)); } }
public static void LoadMultiModuleFromByteArray_GetModule() { using (TypeLoader tl = new TypeLoader()) { Assembly a = tl.LoadFromByteArray(TestData.s_MultiModuleDllImage); Assert.Throws <FileNotFoundException>(() => a.GetModule("Bob.netmodule")); } }
public static void AssemblyIsDynamic() { using (TypeLoader tl = new TypeLoader()) { Assembly a = tl.LoadFromByteArray(TestData.s_SimpleAssemblyImage); Assert.False(a.IsDynamic); } }
public static void AssemblyHostContext() { using (TypeLoader tl = new TypeLoader()) { Assembly a = tl.LoadFromByteArray(TestData.s_SimpleAssemblyImage); Assert.Equal(0L, a.HostContext); // This property is meaningless for TypeLoaders and always returns 0. } }
public static void AssemblyGlobalAssemblyCache() { using (TypeLoader tl = new TypeLoader()) { Assembly a = tl.LoadFromByteArray(TestData.s_SimpleAssemblyImage); Assert.False(a.GlobalAssemblyCache); // This property is meaningless for TypeLoaders and always returns false. } }
public static void AssemblyReflectionOnly() { using (TypeLoader tl = new TypeLoader()) { Assembly a = tl.LoadFromByteArray(TestData.s_SimpleAssemblyImage); Assert.True(a.ReflectionOnly); } }
public static void ModuleIsResource() { using (TypeLoader tl = new TypeLoader()) { Assembly a = tl.LoadFromByteArray(TestData.s_SimpleAssemblyImage); Module m = a.ManifestModule; Assert.False(m.IsResource()); } }
public static void AssemblyMetadataVersion2_0() { using (TypeLoader tl = new TypeLoader()) { Assembly a = tl.LoadFromByteArray(TestData.s_NetFx20AssemblyImage); string metadataVersion = a.ImageRuntimeVersion; Assert.Equal("v2.0.50727", metadataVersion); } }
public static void AssemblyMetadataVersion4_0() { using (TypeLoader tl = new TypeLoader()) { Assembly a = tl.LoadFromByteArray(TestData.s_SimpleAssemblyImage); string metadataVersion = a.ImageRuntimeVersion; Assert.Equal("v4.0.30319", metadataVersion); } }
public static void AssemblyLocationMemory() { using (TypeLoader tl = new TypeLoader()) { Assembly a = tl.LoadFromByteArray(TestData.s_SimpleAssemblyImage); string location = a.Location; Assert.Equal(string.Empty, location); } }
public static void ExtraDisposesIgnored() { TypeLoader tl = new TypeLoader(); tl.LoadFromByteArray(TestData.s_SimpleAssemblyImage); tl.Dispose(); tl.Dispose(); tl.Dispose(); }
public static void AssemblyGetForwardedTypes2() { using (TypeLoader tl = new TypeLoader()) { Assembly upper = tl.LoadFromByteArray(TestData.s_UpperImage); Assembly middle = tl.LoadFromByteArray(TestData.s_MiddleImage); ReflectionTypeLoadException re = Assert.Throws <ReflectionTypeLoadException>(() => upper.GetForwardedTypesThunk()); Assert.Equal(3, re.Types.Length); Assert.Equal(3, re.LoaderExceptions.Length); Assert.Equal(2, re.Types.Count((t) => t == null)); Assert.Contains <Type>(middle.GetType("Upper2", throwOnError: true), re.Types); Assert.Equal(1, re.LoaderExceptions.Count((t) => t == null)); Assert.True(re.LoaderExceptions.All((t) => t == null || t is FileNotFoundException)); } }
public static void AssemblyFullName() { using (TypeLoader tl = new TypeLoader()) { Assembly a = tl.LoadFromByteArray(TestData.s_SimpleAssemblyImage); string fullName = a.FullName; Assert.Equal(TestData.s_SimpleAssemblyName, fullName); } }
public static void AssemblyEntryPoint2() { using (TypeLoader tl = new TypeLoader()) { Assembly a = tl.LoadFromByteArray(TestData.s_SimpleAssemblyImage); MethodInfo m = a.EntryPoint; Assert.Null(m); } }
public static void ModuleGetNameFromByteArray() { using (TypeLoader tl = new TypeLoader()) { Assembly a = tl.LoadFromByteArray(TestData.s_SimpleAssemblyImage); Module m = a.ManifestModule; Assert.Equal(string.Empty, m.Name); } }
public static void LoadModule_Null() { using (TypeLoader tl = new TypeLoader()) { Assembly a = tl.LoadFromByteArray(TestData.s_MultiModuleDllImage); Assert.Throws <ArgumentNullException>(() => a.LoadModule(null, TestData.s_JoeNetModuleImage)); Assert.Throws <ArgumentNullException>(() => a.LoadModule("Bob.netmodule", null)); } }