static void ClassNotRegistered(bool builtInComDisabled) { Console.WriteLine($"Running {nameof(ClassNotRegistered)}..."); Action action = () => { var CLSID_NotRegistered = new Guid("328FF83E-3F6C-4BE9-A742-752562032925"); // Random GUID var cxt = new ComActivationContext() { ClassId = CLSID_NotRegistered, InterfaceId = typeof(IClassFactory).GUID, AssemblyPath = @"C:\foo.dll" }; ComActivator.GetClassFactoryForType(cxt); }; if (!builtInComDisabled) { COMException e = Assert.Throws <COMException>(action, "Class should not be found"); const int CLASS_E_CLASSNOTAVAILABLE = unchecked ((int)0x80040111); Assert.AreEqual(CLASS_E_CLASSNOTAVAILABLE, e.HResult, "Unexpected HRESULT"); } else { Assert.Throws <NotSupportedException>(action, "Built-in COM has been disabled via a feature switch"); } }
// Generates a log message. If its switch (or a parent switch) allows the // level for the message, it is "broadcast" to all of the log // devices. // public static void LogMessage(LoggingLevels level, LogSwitch logswitch, String message) { if (logswitch == null) { throw new ArgumentNullException("LogSwitch"); } if (level < 0) { throw new ArgumentOutOfRangeException(nameof(level), SR.ArgumentOutOfRange_NeedNonNegNum); } Contract.EndContractBlock(); // Is logging for this level for this switch enabled? if (logswitch.CheckLevel(level) == true) { // Send message for logging // first send it to the debugger Debugger.Log((int)level, logswitch.strName, message); // Send to the console device if (m_fConsoleDeviceEnabled) { Console.Write(message); } } }
static int Main(string[] doNotUse) { try { bool builtInComDisabled = false; var comConfig = AppContext.GetData("System.Runtime.InteropServices.BuiltInComInterop.IsSupported"); if (comConfig != null && !bool.Parse(comConfig.ToString())) { builtInComDisabled = true; } Console.WriteLine($"Built-in COM Disabled?: {builtInComDisabled}"); InvalidInterfaceRequest(); ClassNotRegistered(builtInComDisabled); NonrootedAssemblyPath(builtInComDisabled); ValidateAssemblyIsolation(builtInComDisabled); if (!builtInComDisabled) { // We don't test this scenario with builtInComDisabled since it is covered by ValidateAssemblyIsolation() above ValidateUserDefinedRegistrationCallbacks(); } } catch (Exception e) { Console.WriteLine($"Test Failure: {e}"); return(101); } return(100); }
static void Main(string[] args) { if (!CreatePipe(out SafeFileHandle readPipeHandle, out SafeFileHandle writePipeHandle, IntPtr.Zero, 0)) { Console.WriteLine(string.Format("CreatePipe failed: {0:X8}", Marshal.GetLastWin32Error())); return; } FileStream fs = new FileStream(readPipeHandle, FileAccess.Read, 4096, false); byte[] buffer = new byte[1]; CancellationTokenSource cts = new CancellationTokenSource(); Task <int> asyncRead = fs.ReadAsync(buffer, 0, 1, cts.Token); Thread.Sleep(1000); cts.Cancel(); Task.WaitAny(asyncRead); Console.WriteLine($"Status: {asyncRead.Status}"); Console.WriteLine($"Exception: {asyncRead.Exception}"); try { Console.WriteLine($"bytes read: {asyncRead.Result}"); } catch (Exception e) { Console.WriteLine($"asyncRead.Result threw {e}"); } }
static int Main(string[] doNotUse) { try { InvalidInterfaceRequest(); ClassNotRegistered(); } catch (Exception e) { Console.WriteLine($"Test Failure: {e}"); return(101); } return(100); }
public static int Main() { try { Assert.Throws <PlatformNotSupportedException>(() => CustomMarshalersNative.Unsupported(typeof(object))); Assert.Throws <PlatformNotSupportedException>(() => CustomMarshalersNative.Unsupported((IReflect)typeof(object))); } catch (System.Exception e) { Console.WriteLine(e.ToString()); return(101); } return(100); }
static void InvalidInterfaceRequest() { Console.WriteLine($"Running {nameof(InvalidInterfaceRequest)}..."); Assert.Throws <NotSupportedException>( () => { var notIClassFactory = new Guid("ED53F949-63E4-43B5-A13D-5655478AADD5"); var cxt = new ComActivationContext() { InterfaceId = notIClassFactory }; ComActivator.GetClassFactoryForType(cxt); }); }
static void NonrootedAssemblyPath() { Console.WriteLine($"Running {nameof(NonrootedAssemblyPath)}..."); ArgumentException e = Assert.Throws <ArgumentException>( () => { var cxt = new ComActivationContext() { InterfaceId = typeof(IClassFactory).GUID, AssemblyPath = "foo.dll" }; ComActivator.GetClassFactoryForType(cxt); }, "Non-root assembly path should not be valid"); }
static int Main(string[] doNotUse) { try { InvalidInterfaceRequest(); ClassNotRegistered(); NonrootedAssemblyPath(); ValidateAssemblyIsolation(); } catch (Exception e) { Console.WriteLine($"Test Failure: {e}"); return(101); } return(100); }
static void ClassNotRegistered() { Console.WriteLine($"Running {nameof(ClassNotRegistered)}..."); COMException e = Assert.Throws <COMException>( () => { var CLSID_NotRegistered = new Guid("328FF83E-3F6C-4BE9-A742-752562032925"); // Random GUID var cxt = new ComActivationContext() { ClassId = CLSID_NotRegistered, InterfaceId = typeof(IClassFactory).GUID, AssemblyPath = @"C:\foo.dll" }; ComActivator.GetClassFactoryForType(cxt); }, "Class should not be found"); const int CLASS_E_CLASSNOTAVAILABLE = unchecked ((int)0x80040111); Assert.AreEqual(CLASS_E_CLASSNOTAVAILABLE, e.HResult, "Unexpected HRESULT"); }
static void NonrootedAssemblyPath(bool builtInComDisabled) { Console.WriteLine($"Running {nameof(NonrootedAssemblyPath)}..."); Action action = () => { var cxt = new ComActivationContext() { InterfaceId = typeof(IClassFactory).GUID, AssemblyPath = "foo.dll" }; ComActivator.GetClassFactoryForType(cxt); }; if (!builtInComDisabled) { Assert.Throws <ArgumentException>(action, "Non-root assembly path should not be valid"); } else { Assert.Throws <NotSupportedException>(action, "Built-in COM has been disabled via a feature switch"); } }
static void NonrootedAssemblyPath(bool builtInComDisabled) { Console.WriteLine($"Running {nameof(NonrootedAssemblyPath)}..."); Action action = () => { var cxt = new ComActivationContext() { InterfaceId = typeof(IClassFactory).GUID, AssemblyPath = "foo.dll" }; ComActivator.GetClassFactoryForType(cxt); }; if (!builtInComDisabled) { Assert.Throws <ArgumentException>(action); } else { Assert.Throws <NotSupportedException>(action); } }
unsafe static int Main(string[] args) { // Disable running on Windows 7 until IJW activation work is complete. if (Environment.OSVersion.Platform != PlatformID.Win32NT || (Environment.OSVersion.Version.Major == 6 && Environment.OSVersion.Version.Minor == 1)) { return(100); } try { HostPolicyMock.Initialize(Environment.CurrentDirectory, null); Console.WriteLine("Verify that we can load an IJW assembly from native code."); string ijwModulePath = Path.Combine(Environment.CurrentDirectory, "IjwNativeCallingManagedDll.dll"); IntPtr ijwNativeHandle = NativeLibrary.Load(ijwModulePath); using (HostPolicyMock.Mock_corehost_resolve_component_dependencies( 0, ijwModulePath, string.Empty, string.Empty)) fixed(char *path = ijwModulePath) { InMemoryAssemblyLoader.LoadInMemoryAssembly(ijwNativeHandle, (IntPtr)path); } NativeEntryPointDelegate nativeEntryPoint = Marshal.GetDelegateForFunctionPointer <NativeEntryPointDelegate>(NativeLibrary.GetExport(ijwNativeHandle, "NativeEntryPoint")); Assert.AreEqual(100, nativeEntryPoint()); Console.WriteLine("Test calls from managed to native to managed when an IJW assembly was first loaded via native."); Assembly ijwAssemblyManaged = Assembly.Load("IjwNativeCallingManagedDll"); Type testType = ijwAssemblyManaged.GetType("TestClass"); object testInstance = Activator.CreateInstance(testType); MethodInfo testMethod = testType.GetMethod("ManagedEntryPoint"); Assert.AreEqual(100, (int)testMethod.Invoke(testInstance, null)); MethodInfo changeReturnedValueMethod = testType.GetMethod("ChangeReturnedValue"); MethodInfo getReturnValueMethod = testType.GetMethod("GetReturnValue"); int newValue = 42; changeReturnedValueMethod.Invoke(null, new object[] { newValue }); Assert.AreEqual(newValue, (int)getReturnValueMethod.Invoke(null, null)); // Native images are only loaded into memory once. As a result, the stubs in the vtfixup table // will always point to JIT stubs that exist in the first ALC that the module was loaded into. // As a result, if an IJW module is loaded into two different ALCs, or if the module is // first loaded via a native call and then loaded via the managed loader, the call stack can change ALCs when // jumping from managed->native->managed code within the IJW module. Assert.AreEqual(100, (int)testMethod.Invoke(testInstance, null)); return(100); } catch (Exception ex) { Console.WriteLine(ex.ToString()); return(101); } }
static void ValidateAssemblyIsolation() { Console.WriteLine($"Running {nameof(ValidateAssemblyIsolation)}..."); string assemblySubPath = Path.Combine(Environment.CurrentDirectory, "Servers"); string assemblyAPath = Path.Combine(assemblySubPath, "AssemblyA.dll"); string assemblyBPath = Path.Combine(assemblySubPath, "AssemblyB.dll"); string assemblyCPath = Path.Combine(assemblySubPath, "AssemblyC.dll"); string assemblyPaths = $"{assemblyAPath}{Path.PathSeparator}{assemblyBPath}{Path.PathSeparator}{assemblyCPath}"; HostPolicyMock.Initialize(Environment.CurrentDirectory, null); var CLSID_NotUsed = Guid.Empty; // During this phase of activation the GUID is not used. Guid iid = typeof(IGetTypeFromC).GUID; Type typeCFromAssemblyA; Type typeCFromAssemblyB; using (HostPolicyMock.Mock_corehost_resolve_component_dependencies( 0, assemblyPaths, string.Empty, string.Empty)) { var cxt = new ComActivationContext() { ClassId = CLSID_NotUsed, InterfaceId = typeof(IClassFactory).GUID, AssemblyPath = assemblyAPath, AssemblyName = "AssemblyA", TypeName = "ClassFromA" }; var factory = (IClassFactory)ComActivator.GetClassFactoryForType(cxt); object svr; factory.CreateInstance(null, ref iid, out svr); typeCFromAssemblyA = (Type)((IGetTypeFromC)svr).GetTypeFromC(); } using (HostPolicyMock.Mock_corehost_resolve_component_dependencies( 0, assemblyPaths, string.Empty, string.Empty)) { var cxt = new ComActivationContext() { ClassId = CLSID_NotUsed, InterfaceId = typeof(IClassFactory).GUID, AssemblyPath = assemblyBPath, AssemblyName = "AssemblyB", TypeName = "ClassFromB" }; var factory = (IClassFactory)ComActivator.GetClassFactoryForType(cxt); object svr; factory.CreateInstance(null, ref iid, out svr); typeCFromAssemblyB = (Type)((IGetTypeFromC)svr).GetTypeFromC(); } Assert.AreNotEqual(typeCFromAssemblyA, typeCFromAssemblyB, "Types should be from different AssemblyLoadContexts"); }
static void ValidateUserDefinedRegistrationCallbacks() { Console.WriteLine($"Running {nameof(ValidateUserDefinedRegistrationCallbacks)}..."); string assemblySubPath = Path.Combine(Environment.CurrentDirectory, "Servers"); string assemblyAPath = Path.Combine(assemblySubPath, "AssemblyA.dll"); string assemblyBPath = Path.Combine(assemblySubPath, "AssemblyB.dll"); string assemblyCPath = Path.Combine(assemblySubPath, "AssemblyC.dll"); string assemblyPaths = $"{assemblyAPath}{Path.PathSeparator}{assemblyBPath}{Path.PathSeparator}{assemblyCPath}"; HostPolicyMock.Initialize(Environment.CurrentDirectory, null); var CLSID_NotUsed = Guid.Empty; // During this phase of activation the GUID is not used. Guid iid = typeof(IValidateRegistrationCallbacks).GUID; using (HostPolicyMock.Mock_corehost_resolve_component_dependencies( 0, assemblyPaths, string.Empty, string.Empty)) { foreach (string typename in new[] { "ValidRegistrationTypeCallbacks", "ValidRegistrationStringCallbacks" }) { Console.WriteLine($"Validating {typename}..."); var cxt = new ComActivationContext() { ClassId = CLSID_NotUsed, InterfaceId = typeof(IClassFactory).GUID, AssemblyPath = assemblyAPath, AssemblyName = "AssemblyA", TypeName = typename }; var factory = (IClassFactory)ComActivator.GetClassFactoryForType(cxt); object svr; factory.CreateInstance(null, ref iid, out svr); var inst = (IValidateRegistrationCallbacks)svr; Assert.IsFalse(inst.DidRegister()); Assert.IsFalse(inst.DidUnregister()); cxt.InterfaceId = Guid.Empty; ComActivator.ClassRegistrationScenarioForType(cxt, register: true); ComActivator.ClassRegistrationScenarioForType(cxt, register: false); Assert.IsTrue(inst.DidRegister()); Assert.IsTrue(inst.DidUnregister()); } } using (HostPolicyMock.Mock_corehost_resolve_component_dependencies( 0, assemblyPaths, string.Empty, string.Empty)) { foreach (string typename in new[] { "NoRegistrationCallbacks", "InvalidArgRegistrationCallbacks", "InvalidInstanceRegistrationCallbacks", "MultipleRegistrationCallbacks" }) { Console.WriteLine($"Validating {typename}..."); var cxt = new ComActivationContext() { ClassId = CLSID_NotUsed, InterfaceId = typeof(IClassFactory).GUID, AssemblyPath = assemblyAPath, AssemblyName = "AssemblyA", TypeName = typename }; var factory = (IClassFactory)ComActivator.GetClassFactoryForType(cxt); object svr; factory.CreateInstance(null, ref iid, out svr); var inst = (IValidateRegistrationCallbacks)svr; cxt.InterfaceId = Guid.Empty; bool exceptionThrown = false; try { ComActivator.ClassRegistrationScenarioForType(cxt, register: true); } catch { exceptionThrown = true; } Assert.IsTrue(exceptionThrown || !inst.DidRegister()); exceptionThrown = false; try { ComActivator.ClassRegistrationScenarioForType(cxt, register: false); } catch { exceptionThrown = true; } Assert.IsTrue(exceptionThrown || !inst.DidUnregister()); } } }
static void ValidateAssemblyIsolation(bool builtInComDisabled) { Console.WriteLine($"Running {nameof(ValidateAssemblyIsolation)}..."); string assemblySubPath = Path.Combine(Environment.CurrentDirectory, "Servers"); string assemblyAPath = Path.Combine(assemblySubPath, "AssemblyA.dll"); string assemblyBPath = Path.Combine(assemblySubPath, "AssemblyB.dll"); string assemblyCPath = Path.Combine(assemblySubPath, "AssemblyC.dll"); string assemblyPaths = $"{assemblyAPath}{Path.PathSeparator}{assemblyBPath}{Path.PathSeparator}{assemblyCPath}"; HostPolicyMock.Initialize(Environment.CurrentDirectory, null); var CLSID_NotUsed = Guid.Empty; // During this phase of activation the GUID is not used. Guid iid = typeof(IGetTypeFromC).GUID; Type typeCFromAssemblyA; Type typeCFromAssemblyB; using (HostPolicyMock.Mock_corehost_resolve_component_dependencies( 0, assemblyPaths, string.Empty, string.Empty)) { var cxt = new ComActivationContext() { ClassId = CLSID_NotUsed, InterfaceId = typeof(IClassFactory).GUID, AssemblyPath = assemblyAPath, AssemblyName = "AssemblyA", TypeName = "ClassFromA" }; if (builtInComDisabled) { Assert.Throws <NotSupportedException>( () => ComActivator.GetClassFactoryForType(cxt), "Built-in COM has been disabled via a feature switch"); return; } var factory = (IClassFactory)ComActivator.GetClassFactoryForType(cxt); IntPtr svrRaw; factory.CreateInstance(null, ref iid, out svrRaw); var svr = (IGetTypeFromC)Marshal.GetObjectForIUnknown(svrRaw); Marshal.Release(svrRaw); typeCFromAssemblyA = (Type)svr.GetTypeFromC(); } using (HostPolicyMock.Mock_corehost_resolve_component_dependencies( 0, assemblyPaths, string.Empty, string.Empty)) { var cxt = new ComActivationContext() { ClassId = CLSID_NotUsed, InterfaceId = typeof(IClassFactory).GUID, AssemblyPath = assemblyBPath, AssemblyName = "AssemblyB", TypeName = "ClassFromB" }; var factory = (IClassFactory)ComActivator.GetClassFactoryForType(cxt); IntPtr svrRaw; factory.CreateInstance(null, ref iid, out svrRaw); var svr = (IGetTypeFromC)Marshal.GetObjectForIUnknown(svrRaw); Marshal.Release(svrRaw); typeCFromAssemblyB = (Type)svr.GetTypeFromC(); } Assert.AreNotEqual(typeCFromAssemblyA, typeCFromAssemblyB, "Types should be from different AssemblyLoadContexts"); }