public static void RunTest() { var testHandle = new TestSafeHandle(initialValue); Assert.True(SafeHandleNative.SafeHandleByValue(testHandle, initialValue)); Assert.False(testHandle.IsClosed); Assert.True(SafeHandleNative.SafeHandleByRef(ref testHandle, initialValue, newValue)); Assert.False(testHandle.IsClosed); testHandle = null; SafeHandleNative.SafeHandleOut(out testHandle, initialValue); Assert.False(testHandle.IsClosed); testHandle = SafeHandleNative.SafeHandleReturn(newValue); Assert.False(testHandle.IsClosed); testHandle = SafeHandleNative.SafeHandleReturn_Swapped(newValue); Assert.False(testHandle.IsClosed); var str = new SafeHandleNative.StructWithHandle { handle = new TestSafeHandle(initialValue) }; SafeHandleNative.StructWithSafeHandleByValue(str, initialValue); Assert.False(str.handle.IsClosed); SafeHandleNative.StructWithSafeHandleByRef(ref str, initialValue, initialValue); Assert.False(str.handle.IsClosed); }
public static void RunTest() { // Test that our SafeHandle-derived object has its underlying handle set after a P/Invoke // even if there's an exception during the unmarshal phase. IntPtr value = (IntPtr)123; TestSafeHandle h = new TestSafeHandle(); Assert.Throws <InvalidOperationException>(() => SafeHandleNative.GetHandleAndCookie(value, out h, out var cookie)); Assert.AreEqual(value, h.DangerousGetHandle()); }
public static void RunTest() { var testHandle = new TestSafeHandle(initialValue); Assert.True(SafeHandleNative.SafeHandleByValue(testHandle, initialValue)); Assert.True(SafeHandleNative.SafeHandleByRef(ref testHandle, initialValue, newValue)); Assert.Equal(newValue, testHandle.DangerousGetHandle()); AbstractDerivedSafeHandle abstrHandle = new AbstractDerivedSafeHandleImplementation(initialValue); Assert.True(SafeHandleNative.SafeHandleInByRef(abstrHandle, initialValue)); Assert.Throws <MarshalDirectiveException>(() => SafeHandleNative.SafeHandleByRef(ref abstrHandle, initialValue, newValue)); NoDefaultConstructorSafeHandle noDefaultCtorHandle = new NoDefaultConstructorSafeHandle(initialValue); Assert.Throws <MissingMethodException>(() => SafeHandleNative.SafeHandleByRef(ref noDefaultCtorHandle, initialValue, newValue)); testHandle = null; SafeHandleNative.SafeHandleOut(out testHandle, initialValue); Assert.Equal(initialValue, testHandle.DangerousGetHandle()); testHandle = SafeHandleNative.SafeHandleReturn(newValue); Assert.Equal(newValue, testHandle.DangerousGetHandle()); Assert.Throws <MarshalDirectiveException>(() => SafeHandleNative.SafeHandleReturn_AbstractDerived(initialValue)); Assert.Throws <MissingMethodException>(() => SafeHandleNative.SafeHandleReturn_NoDefaultConstructor(initialValue)); var abstractDerivedImplementationHandle = SafeHandleNative.SafeHandleReturn_AbstractDerivedImplementation(initialValue); Assert.Equal(initialValue, abstractDerivedImplementationHandle.DangerousGetHandle()); testHandle = SafeHandleNative.SafeHandleReturn_Swapped(newValue); Assert.Equal(newValue, testHandle.DangerousGetHandle()); Assert.Throws <MarshalDirectiveException>(() => SafeHandleNative.SafeHandleReturn_Swapped_AbstractDerived(initialValue)); Assert.Throws <MissingMethodException>(() => SafeHandleNative.SafeHandleReturn_Swapped_NoDefaultConstructor(initialValue)); var str = new SafeHandleNative.StructWithHandle { handle = new TestSafeHandle(initialValue) }; Assert.True(SafeHandleNative.StructWithSafeHandleByValue(str, initialValue)); Assert.True(SafeHandleNative.StructWithSafeHandleByRef(ref str, initialValue, initialValue)); // Cannot change the value of a SafeHandle-derived field in a struct when marshalling byref. Assert.Throws <NotSupportedException>(() => SafeHandleNative.StructWithSafeHandleByRef(ref str, initialValue, newValue)); // Cannot create a SafeHandle-derived field value. Assert.Throws <NotSupportedException>(() => SafeHandleNative.StructWithSafeHandleOut(out var defaultOutStruct, initialValue)); }
public static void RunTest() { // Test that our SafeHandle-derived object has its underlying handle set after a P/Invoke // even if there's an exception during the unmarshal phase. IntPtr value = (IntPtr)123; TestSafeHandle h = new TestSafeHandle(); Assert.Throws <InvalidOperationException>(() => SafeHandleNative.GetHandleAndCookie(out _, value, out h)); Assert.AreEqual(value, h.DangerousGetHandle()); // Try again, this time triggering unmarshal failure with an array. value = (IntPtr)456; h = new TestSafeHandle(); Assert.Throws <OverflowException>(() => SafeHandleNative.GetHandleAndArray(out _, out _, value, out h)); Assert.AreEqual(value, h.DangerousGetHandle()); }
public static void RunTest() { if (TestLibrary.Utilities.IsWindows) { // The interface marshaller is only available when COM interop is // enabled. The interface marshaller is what initiates the COM // interop system which is what subsequently defines defined exception // type to throw - matches .NET Framework behavior. At present support // is limited to Windows so we branch on that. Assert.Throws <InvalidOperationException>(() => MarshalSafeHandleAsInterface()); } else { // When the interface marshaller is not available we fallback to // the marshalling system which will throw a different exception. Assert.Throws <MarshalDirectiveException>(() => MarshalSafeHandleAsInterface()); } Assert.Throws <MarshalDirectiveException>(() => SafeHandleNative.SafeHandle_Invalid(new TestSafeHandle[1])); Assert.Throws <TypeLoadException>(() => SafeHandleNative.SafeHandle_Invalid(new SafeHandleNative.StructWithSafeHandleArray())); }
static void MarshalSafeHandleAsInterface() { SafeHandleNative.SafeHandle_Invalid(new TestSafeHandle()); }
public static void RunTest() { Assert.Throws <InvalidOperationException>(() => SafeHandleNative.SafeHandle_Invalid(new TestSafeHandle())); Assert.Throws <MarshalDirectiveException>(() => SafeHandleNative.SafeHandle_Invalid(new TestSafeHandle[1])); Assert.Throws <TypeLoadException>(() => SafeHandleNative.SafeHandle_Invalid(new SafeHandleNative.StructWithSafeHandleArray())); }