public static extern int mono_test_marshal_variant_in_double([MarshalAs(UnmanagedType.Struct)]object obj);
[DllImport("libtest")]
- public static extern int mono_test_marshal_variant_in_bstr([MarshalAs(UnmanagedType.Struct)]object obj);
+ public static extern int mono_test_marshal_variant_in_bstr ([MarshalAs (UnmanagedType.Struct)]object obj);
+
+ [DllImport ("libtest")]
+ public static extern int mono_test_marshal_variant_in_bool_true ([MarshalAs (UnmanagedType.Struct)]object obj);
+
+ [DllImport ("libtest")]
+ public static extern int mono_test_marshal_variant_in_bool_false ([MarshalAs (UnmanagedType.Struct)]object obj);
[DllImport("libtest")]
public static extern int mono_test_marshal_variant_out_sbyte([MarshalAs(UnmanagedType.Struct)]out object obj);
public static extern int mono_test_marshal_variant_out_double([MarshalAs(UnmanagedType.Struct)]out object obj);
[DllImport("libtest")]
- public static extern int mono_test_marshal_variant_out_bstr([MarshalAs(UnmanagedType.Struct)]out object obj);
+ public static extern int mono_test_marshal_variant_out_bstr ([MarshalAs (UnmanagedType.Struct)]out object obj);
+
+ [DllImport("libtest")]
+ public static extern int mono_test_marshal_variant_out_bool_true ([MarshalAs (UnmanagedType.Struct)]out object obj);
+
+ [DllImport ("libtest")]
+ public static extern int mono_test_marshal_variant_out_bool_false ([MarshalAs (UnmanagedType.Struct)]out object obj);
+
+
+ public delegate int VarFunc (VarEnum vt, [MarshalAs (UnmanagedType.Struct)] object obj);
+
+ public delegate int VarRefFunc (VarEnum vt, [MarshalAs (UnmanagedType.Struct)] ref object obj);
+
+ [DllImport ("libtest")]
+ public static extern int mono_test_marshal_variant_in_sbyte_unmanaged (VarFunc func);
+
+ [DllImport ("libtest")]
+ public static extern int mono_test_marshal_variant_in_byte_unmanaged (VarFunc func);
+
+ [DllImport ("libtest")]
+ public static extern int mono_test_marshal_variant_in_short_unmanaged (VarFunc func);
+
+ [DllImport ("libtest")]
+ public static extern int mono_test_marshal_variant_in_ushort_unmanaged (VarFunc func);
+
+ [DllImport ("libtest")]
+ public static extern int mono_test_marshal_variant_in_int_unmanaged (VarFunc func);
+
+ [DllImport ("libtest")]
+ public static extern int mono_test_marshal_variant_in_uint_unmanaged (VarFunc func);
+
+ [DllImport ("libtest")]
+ public static extern int mono_test_marshal_variant_in_long_unmanaged (VarFunc func);
+
+ [DllImport ("libtest")]
+ public static extern int mono_test_marshal_variant_in_ulong_unmanaged (VarFunc func);
+
+ [DllImport ("libtest")]
+ public static extern int mono_test_marshal_variant_in_float_unmanaged (VarFunc func);
+
+ [DllImport ("libtest")]
+ public static extern int mono_test_marshal_variant_in_double_unmanaged (VarFunc func);
+
+ [DllImport ("libtest")]
+ public static extern int mono_test_marshal_variant_in_bstr_unmanaged (VarFunc func);
+
+ [DllImport ("libtest")]
+ public static extern int mono_test_marshal_variant_in_bool_true_unmanaged (VarFunc func);
+
+ [DllImport ("libtest")]
+ public static extern int mono_test_marshal_variant_in_bool_false_unmanaged (VarFunc func);
+
+ [DllImport ("libtest")]
+ public static extern int mono_test_marshal_variant_out_sbyte_unmanaged (VarRefFunc func);
+
+ [DllImport ("libtest")]
+ public static extern int mono_test_marshal_variant_out_byte_unmanaged (VarRefFunc func);
+
+ [DllImport ("libtest")]
+ public static extern int mono_test_marshal_variant_out_short_unmanaged (VarRefFunc func);
+
+ [DllImport ("libtest")]
+ public static extern int mono_test_marshal_variant_out_ushort_unmanaged (VarRefFunc func);
+
+ [DllImport ("libtest")]
+ public static extern int mono_test_marshal_variant_out_int_unmanaged (VarRefFunc func);
+
+ [DllImport ("libtest")]
+ public static extern int mono_test_marshal_variant_out_uint_unmanaged (VarRefFunc func);
+
+ [DllImport ("libtest")]
+ public static extern int mono_test_marshal_variant_out_long_unmanaged (VarRefFunc func);
+
+ [DllImport ("libtest")]
+ public static extern int mono_test_marshal_variant_out_ulong_unmanaged (VarRefFunc func);
+
+ [DllImport ("libtest")]
+ public static extern int mono_test_marshal_variant_out_float_unmanaged (VarRefFunc func);
+
+ [DllImport ("libtest")]
+ public static extern int mono_test_marshal_variant_out_double_unmanaged (VarRefFunc func);
+
+ [DllImport ("libtest")]
+ public static extern int mono_test_marshal_variant_out_bstr_unmanaged (VarRefFunc func);
+
+ [DllImport ("libtest")]
+ public static extern int mono_test_marshal_variant_out_bool_true_unmanaged (VarRefFunc func);
+
+ [DllImport ("libtest")]
+ public static extern int mono_test_marshal_variant_out_bool_false_unmanaged (VarRefFunc func);
[DllImport ("libtest")]
- public static extern int mono_test_marshal_com_object_create (out IntPtr pUnk);
+ public static extern int mono_test_marshal_com_object_create (out IntPtr pUnk);
+
+ [DllImport ("libtest")]
+ public static extern int mono_test_marshal_com_object_same (out IntPtr pUnk);
[DllImport ("libtest")]
public static extern int mono_test_marshal_com_object_destroy (IntPtr pUnk);
- [DllImport ("libtest")]
- public static extern int mono_test_marshal_com_object_ref_count (IntPtr pUnk);
+ [DllImport ("libtest")]
+ public static extern int mono_test_marshal_com_object_ref_count (IntPtr pUnk);
+
+ [DllImport ("libtest")]
+ public static extern int mono_test_marshal_ccw_identity ([MarshalAs (UnmanagedType.Interface)]ITest itest);
+
+ [DllImport ("libtest")]
+ public static extern int mono_test_marshal_ccw_reflexive ([MarshalAs (UnmanagedType.Interface)]ITest itest);
+
+ [DllImport ("libtest")]
+ public static extern int mono_test_marshal_ccw_transitive ([MarshalAs (UnmanagedType.Interface)]ITest itest);
+
+ [DllImport ("libtest")]
+ public static extern int mono_test_marshal_ccw_itest ([MarshalAs (UnmanagedType.Interface)]ITest itest);
+
+ [DllImport ("libtest")]
+ public static extern int mono_test_marshal_ccw_itest ([MarshalAs (UnmanagedType.Interface)]ITestPresSig itest);
public static int Main() {
if (mono_test_marshal_variant_out_bstr (out obj) != 0 || (string)obj != "PI")
return 34;
+ VarFunc func = new VarFunc (mono_test_marshal_variant_in_callback);
+ if (mono_test_marshal_variant_in_sbyte_unmanaged (func) != 0)
+ return 35;
+ if (mono_test_marshal_variant_in_byte_unmanaged (func) != 0)
+ return 36;
+ if (mono_test_marshal_variant_in_short_unmanaged (func) != 0)
+ return 37;
+ if (mono_test_marshal_variant_in_ushort_unmanaged (func) != 0)
+ return 38;
+ if (mono_test_marshal_variant_in_int_unmanaged (func) != 0)
+ return 39;
+ if (mono_test_marshal_variant_in_uint_unmanaged (func) != 0)
+ return 40;
+ if (mono_test_marshal_variant_in_long_unmanaged (func) != 0)
+ return 41;
+ if (mono_test_marshal_variant_in_ulong_unmanaged (func) != 0)
+ return 42;
+ if (mono_test_marshal_variant_in_float_unmanaged (func) != 0)
+ return 43;
+ if (mono_test_marshal_variant_in_double_unmanaged (func) != 0)
+ return 44;
+ if (mono_test_marshal_variant_in_bstr_unmanaged (func) != 0)
+ return 45;
+ if (mono_test_marshal_variant_in_bool_true_unmanaged (func) != 0)
+ return 46;
+
+ VarRefFunc reffunc = new VarRefFunc (mono_test_marshal_variant_out_callback);
+ if (mono_test_marshal_variant_out_sbyte_unmanaged (reffunc) != 0)
+ return 50;
+ if (mono_test_marshal_variant_out_byte_unmanaged (reffunc) != 0)
+ return 51;
+ if (mono_test_marshal_variant_out_short_unmanaged (reffunc) != 0)
+ return 52;
+ if (mono_test_marshal_variant_out_ushort_unmanaged (reffunc) != 0)
+ return 53;
+ if (mono_test_marshal_variant_out_int_unmanaged (reffunc) != 0)
+ return 54;
+ if (mono_test_marshal_variant_out_uint_unmanaged (reffunc) != 0)
+ return 55;
+ if (mono_test_marshal_variant_out_long_unmanaged (reffunc) != 0)
+ return 56;
+ if (mono_test_marshal_variant_out_ulong_unmanaged (reffunc) != 0)
+ return 57;
+ if (mono_test_marshal_variant_out_float_unmanaged (reffunc) != 0)
+ return 58;
+ if (mono_test_marshal_variant_out_double_unmanaged (reffunc) != 0)
+ return 59;
+ if (mono_test_marshal_variant_out_bstr_unmanaged (reffunc) != 0)
+ return 60;
+ if (mono_test_marshal_variant_out_bool_true_unmanaged (reffunc) != 0)
+ return 61;
+
#endregion // VARIANT Tests
- #region Marshal COM Interop Tests
+ #region Runtime Callable Wrapper Tests
IntPtr pUnk;
if (mono_test_marshal_com_object_create (out pUnk) != 0)
- return 65;
+ return 145;
if (mono_test_marshal_com_object_ref_count (pUnk) != 1)
- return 46;
+ return 146;
if (Marshal.AddRef (pUnk) != 2)
- return 47;
+ return 147;
if (mono_test_marshal_com_object_ref_count (pUnk) != 2)
- return 48;
+ return 148;
if (Marshal.Release (pUnk) != 1)
- return 49;
+ return 149;
if (mono_test_marshal_com_object_ref_count (pUnk) != 1)
- return 50;
+ return 150;
object com_obj = Marshal.GetObjectForIUnknown (pUnk);
if (com_obj == null)
- return 51;
+ return 151;
- IMath imath = com_obj as IMath;
+ ITest itest = com_obj as ITest;
- if (imath == null)
- return 52;
+ if (itest == null)
+ return 152;
- if (imath.Add (20, 10) != 30)
- return 53;
+ IntPtr pUnk2;
+ if (mono_test_marshal_com_object_same (out pUnk2) != 0)
+ return 153;
- if (imath.Subtract (20, 10) != 10)
- return 54;
+ object com_obj2 = Marshal.GetObjectForIUnknown (pUnk2);
+
+ if (com_obj != com_obj2)
+ return 154;
- IMath same1, same2;
- imath.Same (out same1);
- imath.Same (out same2);
- if (same1 != same2)
- return 55;
+ if (!com_obj.Equals (com_obj2))
+ return 155;
- if (!same1.Equals (same2))
- return 56;
+ IntPtr pUnk3;
+ if (mono_test_marshal_com_object_create (out pUnk3) != 0)
+ return 156;
- IMath diff1, diff2;
- imath.Different (out diff1);
- imath.Different (out diff2);
- if (diff1 == diff2)
- return 57;
+ object com_obj3 = Marshal.GetObjectForIUnknown (pUnk3);
+ if (com_obj == com_obj3)
+ return 157;
- if (diff1.Equals (diff2))
- return 58;
+ if (com_obj.Equals (com_obj3))
+ return 158;
- // same1 & same2 share a RCW
- if (Marshal.ReleaseComObject (same1) != 1)
- return 59;
+ // com_obj & com_obj2 share a RCW
+ if (Marshal.ReleaseComObject (com_obj2) != 1)
+ return 159;
- if (Marshal.ReleaseComObject (same2) != 0)
- return 60;
+ // com_obj3 should only have one RCW
+ if (Marshal.ReleaseComObject (com_obj3) != 0)
+ return 160;
+ IntPtr iunknown = Marshal.GetIUnknownForObject (com_obj);
+ if (iunknown == IntPtr.Zero)
+ return 170;
- if (Marshal.ReleaseComObject (diff1) != 0 ||
- Marshal.ReleaseComObject (diff2) != 0)
- return 61;
+ if (pUnk != iunknown)
+ return 171;
- IntPtr pUnk2 = Marshal.GetIUnknownForObject (imath);
- if (pUnk2 == IntPtr.Zero)
- return 70;
+ if (TestITest (itest) != 0)
+ return 172;
- if (pUnk != pUnk2)
- return 71;
+ if (TestITestPresSig (itest as ITestPresSig) != 0)
+ return 173;
- IntPtr pDisp = Marshal.GetIDispatchForObject (imath);
- if (pDisp == IntPtr.Zero)
- return 72;
+ #endregion // Runtime Callable Wrapper Tests
- if (pUnk != pDisp)
- return 73;
+ #region COM Callable Wrapper Tests
+ ManagedTest test = new ManagedTest ();
- //if (mono_test_marshal_com_object_destroy (pUnk) != 0)
- // return 71;
- #endregion // Marshal COM Interop Tests
+ mono_test_marshal_ccw_itest (test);
+
+ if (test.Status != 0)
+ return 200;
+
+ ManagedTestPresSig test_pres_sig = new ManagedTestPresSig ();
+
+ mono_test_marshal_ccw_itest (test_pres_sig);
+
+ #endregion // COM Callable Wrapper Tests
}
return 0;
}
- [ComImport()]
- [Guid ("00000000-0000-0000-0000-000000000001")]
- [InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
- public interface IMath
- {
- [MethodImplAttribute (MethodImplOptions.InternalCall,MethodCodeType=MethodCodeType.Runtime)]
- int Add (int a, int b);
- [MethodImplAttribute (MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)]
- int Subtract (int a, int b);
+
+ [ComImport ()]
+ [Guid ("00000000-0000-0000-0000-000000000001")]
+ [InterfaceType (ComInterfaceType.InterfaceIsIUnknown)]
+ public interface ITest
+ {
+ // properties need to go first since mcs puts them there
+ ITest Test
+ {
+ [return: MarshalAs (UnmanagedType.Interface)]
+ [MethodImpl (MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime), DispId (5242884)]
+ get;
+ }
+
+ [MethodImplAttribute (MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)]
+ void SByteIn (sbyte val);
+ [MethodImplAttribute (MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)]
+ void ByteIn (byte val);
+ [MethodImplAttribute (MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)]
+ void ShortIn (short val);
[MethodImplAttribute (MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)]
- int Same ([MarshalAs(UnmanagedType.Interface)] out IMath imath);
+ void UShortIn (ushort val);
[MethodImplAttribute (MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)]
- int Different ([MarshalAs (UnmanagedType.Interface)] out IMath imath);
- }
+ void IntIn (int val);
+ [MethodImplAttribute (MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)]
+ void UIntIn (uint val);
+ [MethodImplAttribute (MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)]
+ void LongIn (long val);
+ [MethodImplAttribute (MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)]
+ void ULongIn (ulong val);
+ [MethodImplAttribute (MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)]
+ void FloatIn (float val);
+ [MethodImplAttribute (MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)]
+ void DoubleIn (double val);
+ [MethodImplAttribute (MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)]
+ void ITestIn ([MarshalAs (UnmanagedType.Interface)]ITest val);
+ [MethodImplAttribute (MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)]
+ void ITestOut ([MarshalAs (UnmanagedType.Interface)]out ITest val);
+ }
[ComImport ()]
- [Guid ("00000000-0000-0000-0000-000000000002")]
- public class Foo : IMath
+ [Guid ("00000000-0000-0000-0000-000000000001")]
+ [InterfaceType (ComInterfaceType.InterfaceIsIUnknown)]
+ public interface ITestPresSig
{
+ // properties need to go first since mcs puts them there
+ ITestPresSig Test
+ {
+ [return: MarshalAs (UnmanagedType.Interface)]
+ [MethodImpl (MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime), DispId (5242884)]
+ get;
+ }
+
+ [MethodImplAttribute (MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)]
+ [PreserveSig ()]
+ int SByteIn (sbyte val);
[MethodImplAttribute (MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)]
- public extern int Add (int a, int b);
+ [PreserveSig ()]
+ int ByteIn (byte val);
[MethodImplAttribute (MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)]
- public extern int Subtract (int a, int b);
+ [PreserveSig ()]
+ int ShortIn (short val);
[MethodImplAttribute (MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)]
- public extern int Same ([MarshalAs (UnmanagedType.Interface)] out IMath imath);
+ [PreserveSig ()]
+ int UShortIn (ushort val);
[MethodImplAttribute (MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)]
- public extern int Different ([MarshalAs (UnmanagedType.Interface)] out IMath imath);
+ [PreserveSig ()]
+ int IntIn (int val);
+ [MethodImplAttribute (MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)]
+ [PreserveSig ()]
+ int UIntIn (uint val);
+ [MethodImplAttribute (MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)]
+ [PreserveSig ()]
+ int LongIn (long val);
+ [MethodImplAttribute (MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)]
+ [PreserveSig ()]
+ int ULongIn (ulong val);
+ [MethodImplAttribute (MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)]
+ [PreserveSig ()]
+ int FloatIn (float val);
+ [MethodImplAttribute (MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)]
+ [PreserveSig ()]
+ int DoubleIn (double val);
+ [MethodImplAttribute (MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)]
+ [PreserveSig ()]
+ int ITestIn ([MarshalAs (UnmanagedType.Interface)]ITestPresSig val);
+ [MethodImplAttribute (MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)]
+ [PreserveSig ()]
+ int ITestOut ([MarshalAs (UnmanagedType.Interface)]out ITestPresSig val);
+ }
+
+ public class ManagedTestPresSig : ITestPresSig
+ { // properties need to go first since mcs puts them there
+ public ITestPresSig Test
+ {
+ get
+ {
+ return new ManagedTestPresSig ();
+ }
+ }
+
+ public int SByteIn (sbyte val)
+ {
+ if (val != -100)
+ return 1;
+ return 0;
+ }
+
+ public int ByteIn (byte val)
+ {
+ if (val != 100)
+ return 2;
+ return 0;
+ }
+
+ public int ShortIn (short val)
+ {
+ if (val != -100)
+ return 3;
+ return 0;
+ }
+
+ public int UShortIn (ushort val)
+ {
+ if (val != 100)
+ return 4;
+ return 0;
+ }
+
+ public int IntIn (int val)
+ {
+ if (val != -100)
+ return 5;
+ return 0;
+ }
+
+ public int UIntIn (uint val)
+ {
+ if (val != 100)
+ return 6;
+ return 0;
+ }
+
+ public int LongIn (long val)
+ {
+ if (val != -100)
+ return 7;
+ return 0;
+ }
+
+ public int ULongIn (ulong val)
+ {
+ if (val != 100)
+ return 8;
+ return 0;
+ }
+
+ public int FloatIn (float val)
+ {
+ if (Math.Abs (val - 3.14f) > .000001)
+ return 9;
+ return 0;
+ }
+
+ public int DoubleIn (double val)
+ {
+ if (Math.Abs (val - 3.14f) > .000001)
+ return 10;
+ return 0;
+ }
+
+ public int ITestIn ([MarshalAs (UnmanagedType.Interface)]ITestPresSig val)
+ {
+ if (val == null)
+ return 11;
+ if (null == val as ManagedTestPresSig)
+ return 12;
+ return 0;
+ }
+
+ public int ITestOut ([MarshalAs (UnmanagedType.Interface)]out ITestPresSig val)
+ {
+ val = new ManagedTestPresSig ();
+ return 0;
+ }
+ }
+
+ public class ManagedTest : ITest
+ {
+ private int status = 0;
+ public int Status
+ {
+ get { return status; }
+ }
+ public void SByteIn (sbyte val)
+ {
+ if (val != -100)
+ status = 1;
+ }
+
+ public void ByteIn (byte val)
+ {
+ if (val != 100)
+ status = 2;
+ }
+
+ public void ShortIn (short val)
+ {
+ if (val != -100)
+ status = 3;
+ }
+
+ public void UShortIn (ushort val)
+ {
+ if (val != 100)
+ status = 4;
+ }
+
+ public void IntIn (int val)
+ {
+ if (val != -100)
+ status = 5;
+ }
+
+ public void UIntIn (uint val)
+ {
+ if (val != 100)
+ status = 6;
+ }
+
+ public void LongIn (long val)
+ {
+ if (val != -100)
+ status = 7;
+ }
+
+ public void ULongIn (ulong val)
+ {
+ if (val != 100)
+ status = 8;
+ }
+
+ public void FloatIn (float val)
+ {
+ if (Math.Abs (val - 3.14f) > .000001)
+ status = 9;
+ }
+
+ public void DoubleIn (double val)
+ {
+ if (Math.Abs (val - 3.14) > .000001)
+ status = 10;
+ }
+
+ public void ITestIn (ITest val)
+ {
+ if (val == null)
+ status = 11;
+ if (null == val as ManagedTest)
+ status = 12;
+ }
+
+ public void ITestOut (out ITest val)
+ {
+ val = new ManagedTest ();
+ }
+
+ public ITest Test
+ {
+ get
+ {
+ return new ManagedTest ();
+ }
+ }
+ }
+
+ public static int mono_test_marshal_variant_in_callback (VarEnum vt, object obj)
+ {
+ switch (vt)
+ {
+ case VarEnum.VT_I1:
+ if (obj.GetType () != typeof (sbyte))
+ return 1;
+ if ((sbyte)obj != -100)
+ return 2;
+ break;
+ case VarEnum.VT_UI1:
+ if (obj.GetType () != typeof (byte))
+ return 1;
+ if ((byte)obj != 100)
+ return 2;
+ break;
+ case VarEnum.VT_I2:
+ if (obj.GetType () != typeof (short))
+ return 1;
+ if ((short)obj != -100)
+ return 2;
+ break;
+ case VarEnum.VT_UI2:
+ if (obj.GetType () != typeof (ushort))
+ return 1;
+ if ((ushort)obj != 100)
+ return 2;
+ break;
+ case VarEnum.VT_I4:
+ if (obj.GetType () != typeof (int))
+ return 1;
+ if ((int)obj != -100)
+ return 2;
+ break;
+ case VarEnum.VT_UI4:
+ if (obj.GetType () != typeof (uint))
+ return 1;
+ if ((uint)obj != 100)
+ return 2;
+ break;
+ case VarEnum.VT_I8:
+ if (obj.GetType () != typeof (long))
+ return 1;
+ if ((long)obj != -100)
+ return 2;
+ break;
+ case VarEnum.VT_UI8:
+ if (obj.GetType () != typeof (ulong))
+ return 1;
+ if ((ulong)obj != 100)
+ return 2;
+ break;
+ case VarEnum.VT_R4:
+ if (obj.GetType () != typeof (float))
+ return 1;
+ if (Math.Abs ((float)obj - 3.14f) > 1e-10)
+ return 2;
+ break;
+ case VarEnum.VT_R8:
+ if (obj.GetType () != typeof (double))
+ return 1;
+ if (Math.Abs ((double)obj - 3.14) > 1e-10)
+ return 2;
+ break;
+ case VarEnum.VT_BSTR:
+ if (obj.GetType () != typeof (string))
+ return 1;
+ if ((string)obj != "PI")
+ return 2;
+ break;
+ case VarEnum.VT_BOOL:
+ if (obj.GetType () != typeof (bool))
+ return 1;
+ if ((bool)obj != true)
+ return 2;
+ break;
+ }
+ return 0;
+ }
+
+ public static int mono_test_marshal_variant_out_callback (VarEnum vt, ref object obj)
+ {
+ switch (vt) {
+ case VarEnum.VT_I1:
+ obj = (sbyte)-100;
+ break;
+ case VarEnum.VT_UI1:
+ obj = (byte)100;
+ break;
+ case VarEnum.VT_I2:
+ obj = (short)-100;
+ break;
+ case VarEnum.VT_UI2:
+ obj = (ushort)100;
+ break;
+ case VarEnum.VT_I4:
+ obj = (int)-100;
+ break;
+ case VarEnum.VT_UI4:
+ obj = (uint)100;
+ break;
+ case VarEnum.VT_I8:
+ obj = (long)-100;
+ break;
+ case VarEnum.VT_UI8:
+ obj = (ulong)100;
+ break;
+ case VarEnum.VT_R4:
+ obj = (float)3.14f;
+ break;
+ case VarEnum.VT_R8:
+ obj = (double)3.14;
+ break;
+ case VarEnum.VT_BSTR:
+ obj = "PI";
+ break;
+ case VarEnum.VT_BOOL:
+ obj = true;
+ break;
+ }
+ return 0;
+ }
+
+ public static int TestITest (ITest itest)
+ {
+ try {
+ ITest itest2;
+ itest.SByteIn (-100);
+ itest.ByteIn (100);
+ itest.ShortIn (-100);
+ itest.UShortIn (100);
+ itest.IntIn (-100);
+ itest.UIntIn (100);
+ itest.LongIn (-100);
+ itest.ULongIn (100);
+ itest.FloatIn (3.14f);
+ itest.DoubleIn (3.14);
+ itest.ITestIn (itest);
+ itest.ITestOut (out itest2);
+ }
+ catch (Exception ex) {
+ return 1;
+ }
+ return 0;
+ }
+
+ public static int TestITestPresSig (ITestPresSig itest)
+ {
+ ITestPresSig itest2;
+ if (itest.SByteIn (-100) != 0)
+ return 1000;
+ if (itest.ByteIn (100) != 0)
+ return 1001;
+ if (itest.ShortIn (-100) != 0)
+ return 1002;
+ if (itest.UShortIn (100) != 0)
+ return 1003;
+ if (itest.IntIn (-100) != 0)
+ return 1004;
+ if (itest.UIntIn (100) != 0)
+ return 1005;
+ if (itest.LongIn (-100) != 0)
+ return 1006;
+ if (itest.ULongIn (100) != 0)
+ return 1007;
+ if (itest.FloatIn (3.14f) != 0)
+ return 1008;
+ if (itest.DoubleIn (3.14) != 0)
+ return 1009;
+ if (itest.ITestIn (itest) != 0)
+ return 1010;
+ if (itest.ITestOut (out itest2) != 0)
+ return 1011;
+ return 0;
}
}
projects / mono.git / blobdiff