2 using System.Collections.Generic;
3 using System.Threading;
5 using System.Reflection;
8 using Mono.Debugger.Soft;
9 using Diag = System.Diagnostics;
12 using System.Security.Cryptography;
14 using NUnit.Framework;
16 #pragma warning disable 0219
22 public class DebuggerTests
25 MethodMirror entry_point;
26 StepEventRequest step_req;
29 void AssertThrows<ExType> (Action del) where ExType : Exception {
37 Assert.IsTrue (thrown);
40 // No other way to pass arguments to the tests ?
41 public static bool listening = Environment.GetEnvironmentVariable ("DBG_SUSPEND") != null;
42 public static string runtime = Environment.GetEnvironmentVariable ("DBG_RUNTIME");
43 public static string agent_args = Environment.GetEnvironmentVariable ("DBG_AGENT_ARGS");
45 Event GetNextEvent () {
46 var es = vm.GetNextEventSet ();
47 Assert.AreEqual (1, es.Events.Length);
51 void Start (params string[] args) {
55 void Start (bool forceExit, params string[] args) {
56 this.forceExit = forceExit;
59 var pi = new Diag.ProcessStartInfo ();
62 pi.FileName = runtime;
65 pi.Arguments = String.Join (" ", args);
66 vm = VirtualMachineManager.Launch (pi, new LaunchOptions { AgentArgs = agent_args });
68 var ep = new IPEndPoint (IPAddress.Any, 10000);
69 Console.WriteLine ("Listening on " + ep + "...");
70 vm = VirtualMachineManager.Listen (ep);
73 var load_req = vm.CreateAssemblyLoadRequest ();
76 Event vmstart = GetNextEvent ();
77 Assert.AreEqual (EventType.VMStart, vmstart.EventType);
86 /* Find out the entry point */
90 if (e is AssemblyLoadEvent) {
91 AssemblyLoadEvent ae = (AssemblyLoadEvent)e;
92 entry_point = ae.Assembly.EntryPoint;
93 if (entry_point != null)
103 BreakpointEvent run_until (string name) {
105 MethodMirror m = entry_point.DeclaringType.GetMethod (name);
106 Assert.IsNotNull (m);
107 //Console.WriteLine ("X: " + name + " " + m.ILOffsets.Count + " " + m.Locations.Count);
108 var req = vm.SetBreakpoint (m, m.ILOffsets [0]);
115 if (e is BreakpointEvent)
121 Assert.IsInstanceOfType (typeof (BreakpointEvent), e);
122 Assert.AreEqual (m.Name, (e as BreakpointEvent).Method.Name);
124 return (e as BreakpointEvent);
127 Event single_step (ThreadMirror t) {
128 var req = vm.CreateStepRequest (t);
132 Event e = GetNextEvent ();
133 Assert.IsTrue (e is StepEvent);
140 Event step_until (ThreadMirror t, string method_name) {
144 if ((e as StepEvent).Method.Name == method_name)
150 void check_arg_val (StackFrame frame, int pos, Type type, object eval) {
151 object val = frame.GetArgument (pos);
152 Assert.IsTrue (val is PrimitiveValue);
153 object v = (val as PrimitiveValue).Value;
154 Assert.AreEqual (type, v.GetType ());
156 Assert.IsTrue (Math.Abs ((float)eval - (float)v) < 0.0001);
157 else if (eval is double)
158 Assert.IsTrue (Math.Abs ((double)eval - (double)v) < 0.0001);
160 Assert.AreEqual (eval, v);
163 void AssertValue (object expected, object val) {
164 if (expected is string) {
165 Assert.IsTrue (val is StringMirror);
166 Assert.AreEqual (expected, (val as StringMirror).Value);
167 } else if (val is StructMirror && (val as StructMirror).Type.Name == "IntPtr") {
168 AssertValue (expected, (val as StructMirror).Fields [0]);
170 Assert.IsTrue (val is PrimitiveValue);
171 Assert.AreEqual (expected, (val as PrimitiveValue).Value);
176 public void SetUp () {
177 ThreadMirror.NativeTransitions = false;
178 Start (new string [] { "dtest-app.exe" });
182 public void TearDown () {
186 if (step_req != null)
194 Event e = GetNextEvent ();
196 if (e is VMDeathEvent)
205 public void SimpleBreakpoint () {
208 MethodMirror m = entry_point.DeclaringType.GetMethod ("bp1");
209 Assert.IsNotNull (m);
211 vm.SetBreakpoint (m, 0);
216 Assert.AreEqual (EventType.Breakpoint, e.EventType);
217 Assert.IsTrue (e is BreakpointEvent);
218 Assert.AreEqual (m.Name, (e as BreakpointEvent).Method.Name);
221 AssertThrows<ArgumentException> (delegate {
223 vm.SetBreakpoint (m, 2);
228 public void BreakpointsSameLocation () {
229 MethodMirror m = entry_point.DeclaringType.GetMethod ("bp2");
230 Assert.IsNotNull (m);
232 vm.SetBreakpoint (m, 0);
233 vm.SetBreakpoint (m, 0);
237 var es = vm.GetNextEventSet ();
238 Assert.AreEqual (2, es.Events.Length);
239 Assert.IsTrue (es [0] is BreakpointEvent);
240 Assert.AreEqual (m, (es [0] as BreakpointEvent).Method);
242 Assert.IsTrue (es [1] is BreakpointEvent);
243 Assert.AreEqual (m.Name, (es [1] as BreakpointEvent).Method.Name);
247 public void BreakpointAlreadyJITted () {
248 Event e = run_until ("bp1");
250 /* Place a breakpoint on bp3 */
251 MethodMirror m = entry_point.DeclaringType.GetMethod ("bp3");
252 Assert.IsNotNull (m);
253 vm.SetBreakpoint (m, 0);
255 /* Same with generic instances */
256 MethodMirror m2 = entry_point.DeclaringType.GetMethod ("bp7");
257 Assert.IsNotNull (m2);
258 vm.SetBreakpoint (m2, 0);
263 Assert.AreEqual (EventType.Breakpoint, e.EventType);
264 Assert.AreEqual (m.Name, (e as BreakpointEvent).Method.Name);
268 /* Non-shared instance */
270 Assert.AreEqual (EventType.Breakpoint, e.EventType);
271 Assert.AreEqual (m2.Name, (e as BreakpointEvent).Method.Name);
275 /* Shared instance */
277 Assert.AreEqual (EventType.Breakpoint, e.EventType);
278 Assert.AreEqual (m2.Name, (e as BreakpointEvent).Method.Name);
282 public void ClearBreakpoint () {
285 MethodMirror m = entry_point.DeclaringType.GetMethod ("bp4");
286 Assert.IsNotNull (m);
287 EventRequest req1 = vm.SetBreakpoint (m, 0);
288 EventRequest req2 = vm.SetBreakpoint (m, 0);
290 MethodMirror m2 = entry_point.DeclaringType.GetMethod ("bp5");
291 Assert.IsNotNull (m2);
292 vm.SetBreakpoint (m2, 0);
297 var es = vm.GetNextEventSet ();
298 Assert.AreEqual (2, es.Events.Length);
299 Assert.AreEqual (EventType.Breakpoint, es [0].EventType);
300 Assert.AreEqual (m.Name, (es [0] as BreakpointEvent).Method.Name);
301 Assert.AreEqual (EventType.Breakpoint, es [1].EventType);
302 Assert.AreEqual (m.Name, (es [1] as BreakpointEvent).Method.Name);
304 /* Clear one of them */
310 Assert.AreEqual (EventType.Breakpoint, e.EventType);
311 Assert.AreEqual (m.Name, (e as BreakpointEvent).Method.Name);
313 /* Clear the other */
319 Assert.AreEqual (EventType.Breakpoint, e.EventType);
320 Assert.AreEqual (m2.Name, (e as BreakpointEvent).Method.Name);
324 public void ClearAllBreakpoints () {
327 MethodMirror m = entry_point.DeclaringType.GetMethod ("bp4");
328 Assert.IsNotNull (m);
329 vm.SetBreakpoint (m, 0);
331 MethodMirror m2 = entry_point.DeclaringType.GetMethod ("bp5");
332 Assert.IsNotNull (m2);
333 vm.SetBreakpoint (m2, 0);
335 vm.ClearAllBreakpoints ();
340 Assert.IsTrue (!(e is BreakpointEvent));
341 if (e is VMDeathEvent)
346 public void BreakpointOnGShared () {
349 MethodMirror m = entry_point.DeclaringType.GetMethod ("bp6");
350 Assert.IsNotNull (m);
352 vm.SetBreakpoint (m, 0);
357 Assert.AreEqual (EventType.Breakpoint, e.EventType);
358 Assert.IsTrue (e is BreakpointEvent);
359 Assert.AreEqual (m.Name, (e as BreakpointEvent).Method.Name);
361 // Breakpoint on an open generic method of a closed generic class (#3422)
362 var frame = e.Thread.GetFrames ()[0];
363 var ginst = frame.GetValue (frame.Method.GetLocal ("gc"));
364 var m2 = (ginst as ObjectMirror).Type.GetMethod ("bp");
365 vm.SetBreakpoint (m2, 0);
370 Assert.AreEqual (EventType.Breakpoint, e.EventType);
371 Assert.IsTrue (e is BreakpointEvent);
372 Assert.AreEqual (m2.Name, (e as BreakpointEvent).Method.Name);
375 void assert_location (Event e, string method) {
376 Assert.IsTrue (e is StepEvent);
377 Assert.AreEqual (method, (e as StepEvent).Method.Name);
380 StepEventRequest create_step (Event e) {
381 var req = vm.CreateStepRequest (e.Thread);
387 public void ClassLocalReflection () {
388 MethodMirror m = entry_point.DeclaringType.Assembly.GetType ("LocalReflectClass").GetMethod ("RunMe");
390 Assert.IsNotNull (m);
391 //Console.WriteLine ("X: " + name + " " + m.ILOffsets.Count + " " + m.Locations.Count);
393 int method_base_linum = m.Locations [0].LineNumber;
394 foreach (var location in m.Locations)
395 if (location.LineNumber == method_base_linum + 2) {
396 offset = location.ILOffset;
400 var req = vm.SetBreakpoint (m, offset);
407 if (e is BreakpointEvent)
413 Assert.IsInstanceOfType (typeof (BreakpointEvent), e);
414 Assert.AreEqual (m.Name, (e as BreakpointEvent).Method.Name);
416 e = single_step (e.Thread);
418 var frame = e.Thread.GetFrames ()[0];
419 Value variable = frame.GetValue (frame.Method.GetLocal ("reflectMe"));
421 ObjectMirror thisObj = (ObjectMirror)variable;
422 TypeMirror thisType = thisObj.Type;
423 FieldInfoMirror thisFi = null;
424 foreach (var fi in thisType.GetFields ())
425 if (fi.Name == "someField")
428 var gotVal = thisObj.GetValue (thisFi);
429 // If we got this far, we're good.
433 public void SingleStepping () {
434 Event e = run_until ("single_stepping");
436 var req = create_step (e);
439 // Step over 'bool b = true'
441 assert_location (e, "single_stepping");
448 assert_location (e, "ss1");
455 assert_location (e, "single_stepping");
459 assert_location (e, "single_stepping");
463 assert_location (e, "ss3");
465 // Step back into single_stepping
467 assert_location (e, "single_stepping");
469 // Step into next line
471 assert_location (e, "single_stepping");
473 // Step into ss3_2 ()
475 assert_location (e, "ss3_2");
477 // Step over ss3_2_2 ()
479 assert_location (e, "ss3_2");
481 // Recreate the request
488 // Step back into single_stepping () with the new request
490 assert_location (e, "single_stepping");
494 assert_location (e, "ss4");
499 // Change to StepSize.Line
501 req.Depth = StepDepth.Over;
502 req.Size = StepSize.Line;
505 // Step over ss1 (); ss1 ();
510 req.Depth = StepDepth.Into;
514 assert_location (e, "ss2");
519 e = run_until ("ss5");
521 // Add an assembly filter
522 req.AssemblyFilter = new AssemblyMirror [] { (e as BreakpointEvent).Method.DeclaringType.Assembly };
528 // Step into is_even, skipping the linq stuff
530 assert_location (e, "is_even");
532 // FIXME: Check that single stepping works with lock (obj)
536 e = run_until ("ss6");
538 req = create_step (e);
539 req.Depth = StepDepth.Over;
542 // Check that single stepping works in out-of-line bblocks
545 assert_location (e, "ss6");
548 // Check that a step over stops at an EH clause
549 e = run_until ("ss7_2");
550 req = create_step (e);
551 req.Depth = StepDepth.Out;
554 assert_location (e, "ss7");
556 req = create_step (e);
557 req.Depth = StepDepth.Over;
560 assert_location (e, "ss7");
563 // Check that stepping stops between nested calls
564 e = run_until ("ss_nested_2");
566 assert_location (e, "ss_nested");
568 assert_location (e, "ss_nested_1");
570 assert_location (e, "ss_nested");
571 // Check that step over steps over nested calls
573 assert_location (e, "ss_nested");
575 assert_location (e, "ss_nested_1");
577 assert_location (e, "ss_nested_1");
579 assert_location (e, "ss_nested");
582 // Check DebuggerStepThrough support
583 e = run_until ("ss_step_through");
584 req = create_step (e);
585 req.Filter = StepFilter.DebuggerStepThrough;
587 // Step through step_through_1 ()
589 assert_location (e, "ss_step_through");
590 // Step through StepThroughClass.step_through_2 ()
592 assert_location (e, "ss_step_through");
594 req.Filter = StepFilter.None;
596 assert_location (e, "step_through_3");
599 // Check DebuggerNonUserCode support
600 e = run_until ("ss_non_user_code");
601 req = create_step (e);
602 req.Filter = StepFilter.DebuggerNonUserCode;
604 // Step through non_user_code_1 ()
606 assert_location (e, "ss_non_user_code");
607 // Step through StepThroughClass.non_user_code_2 ()
609 assert_location (e, "ss_non_user_code");
611 req.Filter = StepFilter.None;
613 assert_location (e, "non_user_code_3");
616 // Check that step-over doesn't stop at inner frames with recursive functions
617 e = run_until ("ss_recursive");
618 req = create_step (e);
622 var f = e.Thread.GetFrames () [0];
623 assert_location (e, "ss_recursive");
624 AssertValue (1, f.GetValue (f.Method.GetLocal ("n")));
627 // Check that single stepping doesn't clobber fp values
628 e = run_until ("ss_fp_clobber");
629 req = create_step (e);
631 f = e.Thread.GetFrames ()[0];
633 if ((e as StepEvent).Method.Name == "ss_fp_clobber_2")
637 f = e.Thread.GetFrames ()[0];
638 AssertValue (7.0, f.GetValue (f.Method.GetParameters ()[0]));
643 public void MethodEntryExit () {
644 run_until ("single_stepping");
646 var req1 = vm.CreateMethodEntryRequest ();
647 var req2 = vm.CreateMethodExitRequest ();
653 Event e = GetNextEvent ();
654 Assert.IsTrue (e is MethodEntryEvent);
655 Assert.AreEqual ("ss1", (e as MethodEntryEvent).Method.Name);
659 Assert.IsTrue (e is MethodExitEvent);
660 Assert.AreEqual ("ss1", (e as MethodExitEvent).Method.Name);
667 public void CountFilter () {
668 run_until ("single_stepping");
670 MethodMirror m2 = entry_point.DeclaringType.GetMethod ("ss3");
671 Assert.IsNotNull (m2);
672 vm.SetBreakpoint (m2, 0);
674 var req1 = vm.CreateMethodEntryRequest ();
678 // Enter ss2, ss1 is skipped
680 Event e = GetNextEvent ();
681 Assert.IsTrue (e is MethodEntryEvent);
682 Assert.AreEqual ("ss2", (e as MethodEntryEvent).Method.Name);
684 // Breakpoint on ss3, the entry event is no longer reported
687 Assert.IsTrue (e is BreakpointEvent);
693 public void Arguments () {
696 var e = run_until ("arg1");
698 StackFrame frame = e.Thread.GetFrames () [0];
700 check_arg_val (frame, 0, typeof (sbyte), SByte.MaxValue - 5);
701 check_arg_val (frame, 1, typeof (byte), Byte.MaxValue - 5);
702 check_arg_val (frame, 2, typeof (bool), true);
703 check_arg_val (frame, 3, typeof (short), Int16.MaxValue - 5);
704 check_arg_val (frame, 4, typeof (ushort), UInt16.MaxValue - 5);
705 check_arg_val (frame, 5, typeof (char), 'F');
706 check_arg_val (frame, 6, typeof (int), Int32.MaxValue - 5);
707 check_arg_val (frame, 7, typeof (uint), UInt32.MaxValue - 5);
708 check_arg_val (frame, 8, typeof (long), Int64.MaxValue - 5);
709 check_arg_val (frame, 9, typeof (ulong), UInt64.MaxValue - 5);
710 check_arg_val (frame, 10, typeof (float), 1.2345f);
711 check_arg_val (frame, 11, typeof (double), 6.78910);
713 e = run_until ("arg2");
715 frame = e.Thread.GetFrames () [0];
718 val = frame.GetArgument (0);
719 AssertValue ("FOO", val);
720 Assert.AreEqual ("String", (val as ObjectMirror).Type.Name);
723 val = frame.GetArgument (1);
724 AssertValue (null, val);
727 val = frame.GetArgument (2);
728 AssertValue ("BLA", val);
731 val = frame.GetArgument (3);
732 AssertValue (42, val);
735 val = frame.GetArgument (4);
736 Assert.IsTrue (val is ObjectMirror);
737 Assert.AreEqual ("GClass`1", (val as ObjectMirror).Type.Name);
740 val = frame.GetArgument (5);
741 Assert.IsTrue (val is ObjectMirror);
742 Assert.AreEqual ("Object", (val as ObjectMirror).Type.Name);
744 // this on static methods
745 val = frame.GetThis ();
746 AssertValue (null, val);
748 e = run_until ("arg3");
750 frame = e.Thread.GetFrames () [0];
753 val = frame.GetThis ();
754 Assert.IsTrue (val is ObjectMirror);
755 Assert.AreEqual ("Tests", (val as ObjectMirror).Type.Name);
757 // objref in register
758 val = frame.GetArgument (0);
759 AssertValue ("BLA", val);
763 public void Arrays () {
766 var e = run_until ("o2");
768 StackFrame frame = e.Thread.GetFrames () [0];
771 val = frame.GetArgument (0);
772 Assert.IsTrue (val is ArrayMirror);
773 ArrayMirror arr = val as ArrayMirror;
774 Assert.AreEqual (2, arr.Length);
775 AssertValue ("BAR", arr [0]);
776 AssertValue ("BAZ", arr [1]);
778 var vals = arr.GetValues (0, 2);
779 Assert.AreEqual (2, vals.Count);
780 AssertValue ("BAR", vals [0]);
781 AssertValue ("BAZ", vals [1]);
783 arr [0] = vm.RootDomain.CreateString ("ABC");
784 AssertValue ("ABC", arr [0]);
786 arr [0] = vm.CreateValue (null);
787 AssertValue (null, arr [0]);
789 arr.SetValues (0, new Value [] { vm.RootDomain.CreateString ("D1"), vm.RootDomain.CreateString ("D2") });
790 AssertValue ("D1", arr [0]);
791 AssertValue ("D2", arr [1]);
794 val = frame.GetArgument (1);
795 Assert.IsTrue (val is ArrayMirror);
796 arr = val as ArrayMirror;
797 Assert.AreEqual (2, arr.Length);
798 AssertValue (42, arr [0]);
799 AssertValue (43, arr [1]);
802 AssertThrows<IndexOutOfRangeException> (delegate () {
806 AssertThrows<IndexOutOfRangeException> (delegate () {
807 val = arr [Int32.MinValue];
810 AssertThrows<IndexOutOfRangeException> (delegate () {
811 vals = arr.GetValues (0, 3);
814 AssertThrows<IndexOutOfRangeException> (delegate () {
815 arr [2] = vm.CreateValue (null);
818 AssertThrows<IndexOutOfRangeException> (delegate () {
819 arr [Int32.MinValue] = vm.CreateValue (null);
822 AssertThrows<IndexOutOfRangeException> (delegate () {
823 arr.SetValues (0, new Value [] { null, null, null });
827 val = frame.GetArgument (2);
828 Assert.IsTrue (val is ArrayMirror);
829 arr = val as ArrayMirror;
830 Assert.AreEqual (2, arr.Rank);
831 Assert.AreEqual (4, arr.Length);
832 Assert.AreEqual (2, arr.GetLength (0));
833 Assert.AreEqual (2, arr.GetLength (1));
834 Assert.AreEqual (0, arr.GetLowerBound (0));
835 Assert.AreEqual (0, arr.GetLowerBound (1));
836 vals = arr.GetValues (0, 4);
837 AssertValue (1, vals [0]);
838 AssertValue (2, vals [1]);
839 AssertValue (3, vals [2]);
840 AssertValue (4, vals [3]);
842 val = frame.GetArgument (3);
843 Assert.IsTrue (val is ArrayMirror);
844 arr = val as ArrayMirror;
845 Assert.AreEqual (2, arr.Rank);
846 Assert.AreEqual (4, arr.Length);
847 Assert.AreEqual (2, arr.GetLength (0));
848 Assert.AreEqual (2, arr.GetLength (1));
849 Assert.AreEqual (1, arr.GetLowerBound (0));
850 Assert.AreEqual (3, arr.GetLowerBound (1));
852 AssertThrows<ArgumentOutOfRangeException> (delegate () {
855 AssertThrows<ArgumentOutOfRangeException> (delegate () {
859 AssertThrows<ArgumentOutOfRangeException> (delegate () {
860 arr.GetLowerBound (-1);
862 AssertThrows<ArgumentOutOfRangeException> (delegate () {
863 arr.GetLowerBound (2);
866 // arrays treated as generic collections
867 val = frame.GetArgument (4);
868 Assert.IsTrue (val is ArrayMirror);
869 arr = val as ArrayMirror;
873 public void Object_GetValue () {
874 var e = run_until ("o1");
875 var frame = e.Thread.GetFrames () [0];
877 object val = frame.GetThis ();
878 Assert.IsTrue (val is ObjectMirror);
879 Assert.AreEqual ("Tests", (val as ObjectMirror).Type.Name);
880 ObjectMirror o = (val as ObjectMirror);
882 TypeMirror t = o.Type;
885 object f = o.GetValue (t.GetField ("field_i"));
887 f = o.GetValue (t.GetField ("field_s"));
888 AssertValue ("S", f);
889 f = o.GetValue (t.GetField ("field_enum"));
890 Assert.IsTrue (f is EnumMirror);
891 Assert.AreEqual (1, (f as EnumMirror).Value);
892 Assert.AreEqual ("B", (f as EnumMirror).StringValue);
894 // Inherited object fields
895 TypeMirror parent = t.BaseType;
896 f = o.GetValue (parent.GetField ("base_field_i"));
898 f = o.GetValue (parent.GetField ("base_field_s"));
899 AssertValue ("T", f);
902 f = o.GetValue (o.Type.GetField ("static_i"));
906 ObjectMirror o2 = frame.GetValue (frame.Method.GetParameters ()[1]) as ObjectMirror;
907 Assert.AreEqual ("GClass`1", o2.Type.Name);
908 TypeMirror t2 = o2.Type;
909 f = o2.GetValue (t2.GetField ("field"));
912 ObjectMirror o3 = frame.GetValue (frame.Method.GetParameters ()[2]) as ObjectMirror;
913 Assert.AreEqual ("GClass`1", o3.Type.Name);
914 TypeMirror t3 = o3.Type;
915 f = o3.GetValue (t3.GetField ("field"));
916 AssertValue ("FOO", f);
919 AssertThrows<ArgumentNullException> (delegate () {
925 public void Object_GetValues () {
926 var e = run_until ("o1");
927 var frame = e.Thread.GetFrames () [0];
929 object val = frame.GetThis ();
930 Assert.IsTrue (val is ObjectMirror);
931 Assert.AreEqual ("Tests", (val as ObjectMirror).Type.Name);
932 ObjectMirror o = (val as ObjectMirror);
934 ObjectMirror val2 = frame.GetValue (frame.Method.GetParameters ()[0]) as ObjectMirror;
936 TypeMirror t = o.Type;
938 object[] vals = o.GetValues (new FieldInfoMirror [] { t.GetField ("field_i"), t.GetField ("field_s") });
942 AssertValue ("S", f);
945 AssertThrows<ArgumentNullException> (delegate () {
949 AssertThrows<ArgumentNullException> (delegate () {
950 o.GetValues (new FieldInfoMirror [] { null });
953 // field of another class
954 AssertThrows<ArgumentException> (delegate () {
955 o.GetValue (val2.Type.GetField ("field_j"));
959 void TestSetValue (ObjectMirror o, string field_name, object val) {
961 o.SetValue (o.Type.GetField (field_name), vm.RootDomain.CreateString ((string)val));
963 o.SetValue (o.Type.GetField (field_name), vm.CreateValue (val));
964 Value f = o.GetValue (o.Type.GetField (field_name));
965 AssertValue (val, f);
969 public void Object_SetValues () {
970 var e = run_until ("o1");
971 var frame = e.Thread.GetFrames () [0];
973 object val = frame.GetThis ();
974 Assert.IsTrue (val is ObjectMirror);
975 Assert.AreEqual ("Tests", (val as ObjectMirror).Type.Name);
976 ObjectMirror o = (val as ObjectMirror);
978 ObjectMirror val2 = frame.GetValue (frame.Method.GetParameters ()[0]) as ObjectMirror;
980 TestSetValue (o, "field_i", 22);
981 TestSetValue (o, "field_bool1", false);
982 TestSetValue (o, "field_bool2", true);
983 TestSetValue (o, "field_char", 'B');
984 TestSetValue (o, "field_byte", (byte)129);
985 TestSetValue (o, "field_sbyte", (sbyte)-33);
986 TestSetValue (o, "field_short", (short)(Int16.MaxValue - 5));
987 TestSetValue (o, "field_ushort", (ushort)(UInt16.MaxValue - 5));
988 TestSetValue (o, "field_long", Int64.MaxValue - 5);
989 TestSetValue (o, "field_ulong", (ulong)(UInt64.MaxValue - 5));
990 TestSetValue (o, "field_float", 6.28f);
991 TestSetValue (o, "field_double", 6.28);
992 TestSetValue (o, "static_i", 23);
993 TestSetValue (o, "field_s", "CDEF");
998 f = o.GetValue (o.Type.GetField ("field_intptr"));
999 Assert.IsInstanceOfType (typeof (StructMirror), f);
1000 AssertValue (Int32.MaxValue - 5, (f as StructMirror).Fields [0]);
1003 FieldInfoMirror field = o.Type.GetField ("field_enum");
1004 f = o.GetValue (field);
1005 (f as EnumMirror).Value = 5;
1006 o.SetValue (field, f);
1007 f = o.GetValue (field);
1008 Assert.AreEqual (5, (f as EnumMirror).Value);
1011 o.SetValue (o.Type.GetField ("field_s"), vm.CreateValue (null));
1012 f = o.GetValue (o.Type.GetField ("field_s"));
1013 AssertValue (null, f);
1016 field = o.Type.GetField ("generic_field_struct");
1017 f = o.GetValue (field);
1018 o.SetValue (field, f);
1021 field = o.Type.GetField ("field_nullable");
1022 f = o.GetValue (field);
1023 AssertValue (0, (f as StructMirror).Fields [0]);
1024 AssertValue (false, (f as StructMirror).Fields [1]);
1025 o.SetValue (field, vm.CreateValue (6));
1026 f = o.GetValue (field);
1027 AssertValue (6, (f as StructMirror).Fields [0]);
1028 AssertValue (true, (f as StructMirror).Fields [1]);
1029 o.SetValue (field, vm.CreateValue (null));
1030 f = o.GetValue (field);
1031 AssertValue (0, (f as StructMirror).Fields [0]);
1032 AssertValue (false, (f as StructMirror).Fields [1]);
1034 // Argument checking
1035 AssertThrows<ArgumentNullException> (delegate () {
1036 o.SetValues (null, new Value [0]);
1039 AssertThrows<ArgumentNullException> (delegate () {
1040 o.SetValues (new FieldInfoMirror [0], null);
1043 AssertThrows<ArgumentNullException> (delegate () {
1044 o.SetValues (new FieldInfoMirror [] { null }, new Value [1] { null });
1047 // vtype with a wrong type
1048 AssertThrows<ArgumentException> (delegate () {
1049 o.SetValue (o.Type.GetField ("field_struct"), o.GetValue (o.Type.GetField ("field_enum")));
1052 // reference type not assignment compatible
1053 AssertThrows<ArgumentException> (delegate () {
1054 o.SetValue (o.Type.GetField ("field_class"), o);
1057 // field of another class
1058 AssertThrows<ArgumentException> (delegate () {
1059 o.SetValue (val2.Type.GetField ("field_j"), vm.CreateValue (1));
1064 public void Type_SetValue () {
1065 var e = run_until ("o1");
1066 var frame = e.Thread.GetFrames () [0];
1069 object val = frame.GetThis ();
1070 Assert.IsTrue (val is ObjectMirror);
1071 Assert.AreEqual ("Tests", (val as ObjectMirror).Type.Name);
1072 ObjectMirror o = (val as ObjectMirror);
1074 ObjectMirror val2 = frame.GetValue (frame.Method.GetParameters ()[0]) as ObjectMirror;
1076 o.Type.SetValue (o.Type.GetField ("static_i"), vm.CreateValue (55));
1077 f = o.Type.GetValue (o.Type.GetField ("static_i"));
1078 AssertValue (55, f);
1080 o.Type.SetValue (o.Type.GetField ("static_s"), vm.RootDomain.CreateString ("B"));
1081 f = o.Type.GetValue (o.Type.GetField ("static_s"));
1082 AssertValue ("B", f);
1084 // Argument checking
1085 AssertThrows<ArgumentNullException> (delegate () {
1086 o.Type.SetValue (null, vm.CreateValue (0));
1089 AssertThrows<ArgumentNullException> (delegate () {
1090 o.Type.SetValue (o.Type.GetField ("static_i"), null);
1093 // field of another class
1094 AssertThrows<ArgumentException> (delegate () {
1095 o.SetValue (val2.Type.GetField ("field_j"), vm.CreateValue (1));
1100 public void TypeInfo () {
1101 Event e = run_until ("ti2");
1102 StackFrame frame = e.Thread.GetFrames () [0];
1107 t = frame.Method.GetParameters ()[0].ParameterType;
1109 Assert.AreEqual ("String[]", t.Name);
1110 Assert.AreEqual ("string[]", t.CSharpName);
1111 Assert.AreEqual ("Array", t.BaseType.Name);
1112 Assert.AreEqual (true, t.HasElementType);
1113 Assert.AreEqual (true, t.IsArray);
1114 Assert.AreEqual (1, t.GetArrayRank ());
1115 Assert.AreEqual ("String", t.GetElementType ().Name);
1117 t = frame.Method.GetParameters ()[2].ParameterType;
1119 Assert.AreEqual ("Int32[,]", t.Name);
1121 //Assert.AreEqual ("int[,]", t.CSharpName);
1122 Assert.AreEqual ("Array", t.BaseType.Name);
1123 Assert.AreEqual (true, t.HasElementType);
1124 Assert.AreEqual (true, t.IsArray);
1125 Assert.AreEqual (2, t.GetArrayRank ());
1126 Assert.AreEqual ("Int32", t.GetElementType ().Name);
1129 t = frame.Method.GetParameters ()[3].ParameterType;
1131 //Assert.AreEqual ("Int32&", t.Name);
1132 //Assert.AreEqual (true, t.IsByRef);
1133 //Assert.AreEqual (true, t.HasElementType);
1136 t = frame.Method.GetParameters ()[4].ParameterType;
1138 //Assert.AreEqual ("Int32*", t.Name);
1139 Assert.AreEqual (true, t.IsPointer);
1140 Assert.AreEqual (true, t.HasElementType);
1141 Assert.AreEqual ("Int32", t.GetElementType ().Name);
1142 Assert.AreEqual (false, t.IsPrimitive);
1145 t = frame.Method.GetParameters ()[5].ParameterType;
1146 Assert.AreEqual (true, t.IsPrimitive);
1149 t = frame.Method.GetParameters ()[6].ParameterType;
1150 Assert.AreEqual ("AStruct", t.Name);
1151 Assert.AreEqual (false, t.IsPrimitive);
1152 Assert.AreEqual (true, t.IsValueType);
1153 Assert.AreEqual (false, t.IsClass);
1156 t = frame.Method.GetParameters ()[7].ParameterType;
1157 Assert.AreEqual ("Tests", t.Name);
1158 var nested = (from nt in t.GetNestedTypes () where nt.IsNestedPublic select nt).ToArray ();
1159 Assert.AreEqual (1, nested.Length);
1160 Assert.AreEqual ("NestedClass", nested [0].Name);
1161 Assert.IsTrue (t.BaseType.IsAssignableFrom (t));
1162 Assert.IsTrue (!t.IsAssignableFrom (t.BaseType));
1164 // generic instances
1165 t = frame.Method.GetParameters ()[9].ParameterType;
1166 Assert.AreEqual ("GClass`1", t.Name);
1167 Assert.IsTrue (t.IsGenericType);
1168 Assert.IsFalse (t.IsGenericTypeDefinition);
1170 var args = t.GetGenericArguments ();
1171 Assert.AreEqual (1, args.Length);
1172 Assert.AreEqual ("Int32", args [0].Name);
1174 // generic type definitions
1175 var gtd = t.GetGenericTypeDefinition ();
1176 Assert.AreEqual ("GClass`1", gtd.Name);
1177 Assert.IsTrue (gtd.IsGenericType);
1178 Assert.IsTrue (gtd.IsGenericTypeDefinition);
1179 Assert.AreEqual (gtd, gtd.GetGenericTypeDefinition ());
1181 args = gtd.GetGenericArguments ();
1182 Assert.AreEqual (1, args.Length);
1183 Assert.AreEqual ("T", args [0].Name);
1186 t = frame.Method.GetParameters ()[10].ParameterType;
1187 Assert.AreEqual ("AnEnum", t.Name);
1188 Assert.IsTrue (t.IsEnum);
1189 Assert.AreEqual ("Int32", t.EnumUnderlyingType.Name);
1192 t = frame.Method.GetParameters ()[11].ParameterType;
1193 Assert.AreEqual ("TypedReference", t.Name);
1196 t = frame.Method.GetParameters ()[7].ParameterType;
1198 var props = t.GetProperties ();
1199 Assert.AreEqual (3, props.Length);
1200 foreach (PropertyInfoMirror prop in props) {
1201 ParameterInfoMirror[] indexes = prop.GetIndexParameters ();
1203 if (prop.Name == "IntProperty") {
1204 Assert.AreEqual ("Int32", prop.PropertyType.Name);
1205 Assert.AreEqual ("get_IntProperty", prop.GetGetMethod ().Name);
1206 Assert.AreEqual ("set_IntProperty", prop.GetSetMethod ().Name);
1207 Assert.AreEqual (0, indexes.Length);
1208 } else if (prop.Name == "ReadOnlyProperty") {
1209 Assert.AreEqual ("Int32", prop.PropertyType.Name);
1210 Assert.AreEqual ("get_ReadOnlyProperty", prop.GetGetMethod ().Name);
1211 Assert.AreEqual (null, prop.GetSetMethod ());
1212 Assert.AreEqual (0, indexes.Length);
1213 } else if (prop.Name == "IndexedProperty") {
1214 Assert.AreEqual (1, indexes.Length);
1215 Assert.AreEqual ("Int32", indexes [0].ParameterType.Name);
1219 // custom attributes
1220 t = frame.Method.GetParameters ()[8].ParameterType;
1221 Assert.AreEqual ("Tests2", t.Name);
1222 var attrs = t.GetCustomAttributes (true);
1223 Assert.AreEqual (5, attrs.Length);
1224 foreach (var attr in attrs) {
1225 if (attr.Constructor.DeclaringType.Name == "DebuggerDisplayAttribute") {
1226 Assert.AreEqual (1, attr.ConstructorArguments.Count);
1227 Assert.AreEqual ("Tests", attr.ConstructorArguments [0].Value);
1228 Assert.AreEqual (2, attr.NamedArguments.Count);
1229 Assert.AreEqual ("Name", attr.NamedArguments [0].Property.Name);
1230 Assert.AreEqual ("FOO", attr.NamedArguments [0].TypedValue.Value);
1231 Assert.AreEqual ("Target", attr.NamedArguments [1].Property.Name);
1232 Assert.IsInstanceOfType (typeof (TypeMirror), attr.NamedArguments [1].TypedValue.Value);
1233 Assert.AreEqual ("Int32", (attr.NamedArguments [1].TypedValue.Value as TypeMirror).Name);
1234 } else if (attr.Constructor.DeclaringType.Name == "DebuggerTypeProxyAttribute") {
1235 Assert.AreEqual (1, attr.ConstructorArguments.Count);
1236 Assert.IsInstanceOfType (typeof (TypeMirror), attr.ConstructorArguments [0].Value);
1237 Assert.AreEqual ("Tests", (attr.ConstructorArguments [0].Value as TypeMirror).Name);
1238 } else if (attr.Constructor.DeclaringType.Name == "BAttribute") {
1239 Assert.AreEqual (2, attr.NamedArguments.Count);
1240 Assert.AreEqual ("afield", attr.NamedArguments [0].Field.Name);
1241 Assert.AreEqual ("bfield", attr.NamedArguments [1].Field.Name);
1242 } else if (attr.Constructor.DeclaringType.Name == "ClassInterfaceAttribute") {
1243 // inherited from System.Object
1244 //} else if (attr.Constructor.DeclaringType.Name == "Serializable") {
1245 // inherited from System.Object
1246 } else if (attr.Constructor.DeclaringType.Name == "ComVisibleAttribute") {
1247 // inherited from System.Object
1249 Assert.Fail (attr.Constructor.DeclaringType.Name);
1253 var assembly = entry_point.DeclaringType.Assembly;
1254 var type = assembly.GetType ("Tests4");
1255 Assert.IsFalse (type.IsInitialized);
1259 public void FieldInfo () {
1260 Event e = run_until ("ti2");
1261 StackFrame frame = e.Thread.GetFrames () [0];
1265 t = frame.Method.GetParameters ()[8].ParameterType;
1266 Assert.AreEqual ("Tests2", t.Name);
1268 var fi = t.GetField ("field_j");
1269 var attrs = fi.GetCustomAttributes (true);
1270 Assert.AreEqual (1, attrs.Length);
1271 var attr = attrs [0];
1272 Assert.AreEqual ("DebuggerBrowsableAttribute", attr.Constructor.DeclaringType.Name);
1273 Assert.AreEqual (1, attr.ConstructorArguments.Count);
1274 Assert.IsInstanceOfType (typeof (EnumMirror), attr.ConstructorArguments [0].Value);
1275 Assert.AreEqual ((int)System.Diagnostics.DebuggerBrowsableState.Collapsed, (attr.ConstructorArguments [0].Value as EnumMirror).Value);
1279 public void PropertyInfo () {
1280 Event e = run_until ("ti2");
1281 StackFrame frame = e.Thread.GetFrames () [0];
1285 t = frame.Method.GetParameters ()[8].ParameterType;
1286 Assert.AreEqual ("Tests2", t.Name);
1288 var pi = t.GetProperty ("AProperty");
1289 var attrs = pi.GetCustomAttributes (true);
1290 Assert.AreEqual (1, attrs.Length);
1291 var attr = attrs [0];
1292 Assert.AreEqual ("DebuggerBrowsableAttribute", attr.Constructor.DeclaringType.Name);
1293 Assert.AreEqual (1, attr.ConstructorArguments.Count);
1294 Assert.IsInstanceOfType (typeof (EnumMirror), attr.ConstructorArguments [0].Value);
1295 Assert.AreEqual ((int)System.Diagnostics.DebuggerBrowsableState.Collapsed, (attr.ConstructorArguments [0].Value as EnumMirror).Value);
1299 [Category ("only5")]
1300 public void Type_GetValue () {
1301 Event e = run_until ("o1");
1302 StackFrame frame = e.Thread.GetFrames () [0];
1304 ObjectMirror o = (frame.GetThis () as ObjectMirror);
1306 TypeMirror t = o.Type;
1308 ObjectMirror val2 = frame.GetValue (frame.Method.GetParameters ()[0]) as ObjectMirror;
1311 object f = t.GetValue (o.Type.GetField ("static_i"));
1312 AssertValue (55, f);
1314 f = t.GetValue (o.Type.GetField ("static_s"));
1315 AssertValue ("A", f);
1317 // literal static fields
1318 f = t.GetValue (o.Type.GetField ("literal_i"));
1319 AssertValue (56, f);
1321 f = t.GetValue (o.Type.GetField ("literal_s"));
1322 AssertValue ("B", f);
1324 // Inherited static fields
1325 TypeMirror parent = t.BaseType;
1326 f = t.GetValue (parent.GetField ("base_static_i"));
1327 AssertValue (57, f);
1329 f = t.GetValue (parent.GetField ("base_static_s"));
1330 AssertValue ("C", f);
1332 // thread static field
1333 f = t.GetValue (t.GetField ("tls_i"), e.Thread);
1334 AssertValue (42, f);
1336 // Argument checking
1337 AssertThrows<ArgumentNullException> (delegate () {
1342 AssertThrows<ArgumentException> (delegate () {
1343 t.GetValue (o.Type.GetField ("field_i"));
1346 // field on another type
1347 AssertThrows<ArgumentException> (delegate () {
1348 t.GetValue (val2.Type.GetField ("static_field_j"));
1351 // special static field
1352 AssertThrows<ArgumentException> (delegate () {
1353 t.GetValue (t.GetField ("tls_i"));
1358 public void Type_GetValues () {
1359 Event e = run_until ("o1");
1360 StackFrame frame = e.Thread.GetFrames () [0];
1362 ObjectMirror o = (frame.GetThis () as ObjectMirror);
1364 TypeMirror t = o.Type;
1367 object[] vals = t.GetValues (new FieldInfoMirror [] { t.GetField ("static_i"), t.GetField ("static_s") });
1368 object f = vals [0];
1369 AssertValue (55, f);
1372 AssertValue ("A", f);
1374 // Argument checking
1375 AssertThrows<ArgumentNullException> (delegate () {
1379 AssertThrows<ArgumentNullException> (delegate () {
1380 t.GetValues (new FieldInfoMirror [] { null });
1385 public void ObjRefs () {
1386 Event e = run_until ("objrefs1");
1387 StackFrame frame = e.Thread.GetFrames () [0];
1389 ObjectMirror o = frame.GetThis () as ObjectMirror;
1390 ObjectMirror child = o.GetValue (o.Type.GetField ("child")) as ObjectMirror;
1392 Assert.IsTrue (child.Address != 0);
1394 // Check that object references are internalized correctly
1395 Assert.AreEqual (o, frame.GetThis ());
1397 run_until ("objrefs2");
1399 // child should be gc'd now
1400 // This is not deterministic
1401 //Assert.IsTrue (child.IsCollected);
1404 * No longer works since Type is read eagerly
1407 AssertThrows<ObjectCollectedException> (delegate () {
1408 TypeMirror t = child.Type;
1412 AssertThrows<ObjectCollectedException> (delegate () {
1413 long addr = child.Address;
1419 public void Type_GetObject () {
1420 Event e = run_until ("o1");
1421 StackFrame frame = e.Thread.GetFrames () [0];
1423 ObjectMirror o = (frame.GetThis () as ObjectMirror);
1425 TypeMirror t = o.Type;
1427 Assert.AreEqual ("MonoType", t.GetTypeObject ().Type.Name);
1431 public void VTypes () {
1432 Event e = run_until ("vtypes1");
1433 StackFrame frame = e.Thread.GetFrames () [0];
1436 ObjectMirror o = frame.GetThis () as ObjectMirror;
1437 var obj = o.GetValue (o.Type.GetField ("field_struct"));
1438 Assert.IsTrue (obj is StructMirror);
1439 var s = obj as StructMirror;
1440 Assert.AreEqual ("AStruct", s.Type.Name);
1441 AssertValue (42, s ["i"]);
1443 AssertValue ("S", obj);
1444 AssertValue (43, s ["k"]);
1445 obj = o.GetValue (o.Type.GetField ("field_boxed_struct"));
1446 Assert.IsTrue (obj is StructMirror);
1447 s = obj as StructMirror;
1448 Assert.AreEqual ("AStruct", s.Type.Name);
1449 AssertValue (42, s ["i"]);
1451 // Check decoding of nested structs (#14942)
1452 obj = o.GetValue (o.Type.GetField ("nested_struct"));
1453 o.SetValue (o.Type.GetField ("nested_struct"), obj);
1455 // Check round tripping of boxed struct fields (#12354)
1456 obj = o.GetValue (o.Type.GetField ("boxed_struct_field"));
1457 o.SetValue (o.Type.GetField ("boxed_struct_field"), obj);
1458 obj = o.GetValue (o.Type.GetField ("boxed_struct_field"));
1459 s = obj as StructMirror;
1460 AssertValue (1, s ["key"]);
1462 Assert.IsTrue (obj is StructMirror);
1463 s = obj as StructMirror;
1464 AssertValue (42, s ["m_value"]);
1466 // vtypes as arguments
1467 s = frame.GetArgument (0) as StructMirror;
1468 AssertValue (44, s ["i"]);
1470 AssertValue ("T", obj);
1471 AssertValue (45, s ["k"]);
1473 // vtypes as array entries
1474 var arr = frame.GetArgument (1) as ArrayMirror;
1476 Assert.IsTrue (obj is StructMirror);
1477 s = obj as StructMirror;
1478 AssertValue (1, s ["i"]);
1479 AssertValue ("S1", s ["s"]);
1481 Assert.IsTrue (obj is StructMirror);
1482 s = obj as StructMirror;
1483 AssertValue (2, s ["i"]);
1484 AssertValue ("S2", s ["s"]);
1487 var typedref = frame.GetArgument (2) as StructMirror;
1488 Assert.IsTrue (typedref is StructMirror);
1490 // Argument checking
1491 s = frame.GetArgument (0) as StructMirror;
1492 AssertThrows<ArgumentException> (delegate () {
1496 // generic vtype instances
1497 o = frame.GetThis () as ObjectMirror;
1498 obj = o.GetValue (o.Type.GetField ("generic_field_struct"));
1499 Assert.IsTrue (obj is StructMirror);
1500 s = obj as StructMirror;
1501 Assert.AreEqual ("GStruct`1", s.Type.Name);
1502 AssertValue (42, s ["i"]);
1504 // this on vtype methods
1505 e = run_until ("vtypes2");
1506 e = step_until (e.Thread, "foo");
1508 frame = e.Thread.GetFrames () [0];
1510 Assert.AreEqual ("foo", (e as StepEvent).Method.Name);
1511 obj = frame.GetThis ();
1513 Assert.IsTrue (obj is StructMirror);
1514 s = obj as StructMirror;
1515 AssertValue (44, s ["i"]);
1516 AssertValue ("T", s ["s"]);
1517 AssertValue (45, s ["k"]);
1519 // this on static vtype methods
1520 e = run_until ("vtypes3");
1521 e = step_until (e.Thread, "static_foo");
1523 frame = e.Thread.GetFrames () [0];
1525 Assert.AreEqual ("static_foo", (e as StepEvent).Method.Name);
1526 obj = frame.GetThis ();
1527 AssertValue (null, obj);
1529 // vtypes which reference themselves recursively
1530 e = run_until ("vtypes4_2");
1531 frame = e.Thread.GetFrames () [0];
1533 Assert.IsTrue (frame.GetArgument (0) is StructMirror);
1537 public void AssemblyInfo () {
1538 Event e = run_until ("single_stepping");
1540 StackFrame frame = e.Thread.GetFrames () [0];
1542 var aname = frame.Method.DeclaringType.Assembly.GetName ();
1543 Assert.AreEqual ("dtest-app, Version=0.0.0.0, Culture=neutral, PublicKeyToken=null", aname.ToString ());
1545 ModuleMirror m = frame.Method.DeclaringType.Module;
1547 Assert.AreEqual ("dtest-app.exe", m.Name);
1548 Assert.AreEqual ("dtest-app.exe", m.ScopeName);
1549 Assert.IsTrue (m.FullyQualifiedName.IndexOf ("dtest-app.exe") != -1);
1550 Guid guid = m.ModuleVersionId;
1551 Assert.AreEqual (frame.Method.DeclaringType.Assembly, m.Assembly);
1552 Assert.AreEqual (frame.Method.DeclaringType.Assembly.ManifestModule, m);
1554 // This is no longer true on 4.0
1555 //Assert.AreEqual ("Assembly", frame.Method.DeclaringType.Assembly.GetAssemblyObject ().Type.Name);
1557 TypeMirror t = vm.RootDomain.Corlib.GetType ("System.Diagnostics.DebuggerDisplayAttribute");
1558 Assert.AreEqual ("DebuggerDisplayAttribute", t.Name);
1562 public void LocalsInfo () {
1563 Event e = run_until ("locals2");
1565 StackFrame frame = e.Thread.GetFrames () [0];
1567 var locals = frame.Method.GetLocals ();
1568 Assert.AreEqual (9, locals.Length);
1569 for (int i = 0; i < 9; ++i) {
1570 if (locals [i].Name == "args") {
1571 Assert.IsTrue (locals [i].IsArg);
1572 Assert.AreEqual ("String[]", locals [i].Type.Name);
1573 } else if (locals [i].Name == "arg") {
1574 Assert.IsTrue (locals [i].IsArg);
1575 Assert.AreEqual ("Int32", locals [i].Type.Name);
1576 } else if (locals [i].Name == "i") {
1577 Assert.IsFalse (locals [i].IsArg);
1578 Assert.AreEqual ("Int64", locals [i].Type.Name);
1579 } else if (locals [i].Name == "j") {
1580 Assert.IsFalse (locals [i].IsArg);
1581 Assert.AreEqual ("Int32", locals [i].Type.Name);
1582 } else if (locals [i].Name == "s") {
1583 Assert.IsFalse (locals [i].IsArg);
1584 Assert.AreEqual ("String", locals [i].Type.Name);
1585 } else if (locals [i].Name == "t") {
1587 Assert.IsTrue (locals [i].IsArg);
1588 Assert.AreEqual ("String", locals [i].Type.Name);
1589 } else if (locals [i].Name == "rs") {
1590 Assert.IsTrue (locals [i].IsArg);
1591 Assert.AreEqual ("String", locals [i].Type.Name);
1592 } else if (locals [i].Name == "astruct") {
1593 } else if (locals [i].Name == "alist") {
1600 Event step_once () {
1602 var e = GetNextEvent ();
1603 Assert.IsTrue (e is StepEvent);
1607 Event step_into () {
1608 step_req.Disable ();
1609 step_req.Depth = StepDepth.Into;
1611 return step_once ();
1614 Event step_over () {
1615 step_req.Disable ();
1616 step_req.Depth = StepDepth.Over;
1618 return step_once ();
1622 step_req.Disable ();
1623 step_req.Depth = StepDepth.Out;
1625 return step_once ();
1629 public void Locals () {
1630 var be = run_until ("locals1");
1632 StackFrame frame = be.Thread.GetFrames () [0];
1633 MethodMirror m1 = frame.Method;
1635 // Compiler generated byref local
1636 foreach (var l in m1.GetLocals ()) {
1637 // The byval flag is hidden from the type
1638 if (l.Name != "ri" && l.Type.Name == "Double")
1639 AssertValue (null, frame.GetValue (l));
1642 be = run_until ("locals2");
1644 frame = be.Thread.GetFrames () [0];
1646 object val = frame.GetValue (frame.Method.GetLocal ("i"));
1647 AssertValue (0, val);
1649 var req = create_step (be);
1656 var e = step_once ();
1657 Assert.AreEqual ("locals2", (e as StepEvent).Method.Name);
1659 // Execute s = "AB";
1661 Assert.AreEqual ("locals2", (e as StepEvent).Method.Name);
1663 frame = e.Thread.GetFrames () [0];
1665 val = frame.GetValue (frame.Method.GetLocal ("i"));
1666 AssertValue (42, val);
1668 LocalVariable[] locals = frame.Method.GetLocals ();
1669 var vals = frame.GetValues (locals);
1670 Assert.AreEqual (locals.Length, vals.Length);
1671 for (int i = 0; i < locals.Length; ++i) {
1672 if (locals [i].Name == "i")
1673 AssertValue (42, vals [i]);
1674 if (locals [i].Name == "s")
1675 AssertValue ("AB", vals [i]);
1676 if (locals [i].Name == "t")
1677 AssertValue ("ABC", vals [i]);
1678 if (locals [i].Name == "alist") {
1682 // Argument checking
1685 AssertThrows<ArgumentNullException> (delegate () {
1686 frame.GetValue ((LocalVariable)null);
1688 // GetValue () local from another method
1689 AssertThrows<ArgumentException> (delegate () {
1690 frame.GetValue (m1.GetLocal ("foo"));
1694 AssertThrows<ArgumentNullException> (delegate () {
1695 frame.GetValue ((ParameterInfoMirror)null);
1697 // GetValue () local from another method
1698 AssertThrows<ArgumentException> (delegate () {
1699 frame.GetValue (m1.GetParameters ()[0]);
1702 // GetValues () null
1703 AssertThrows<ArgumentNullException> (delegate () {
1704 frame.GetValues (null);
1706 // GetValues () embedded null
1707 AssertThrows<ArgumentNullException> (delegate () {
1708 frame.GetValues (new LocalVariable [] { null });
1710 // GetValues () local from another method
1711 AssertThrows<ArgumentException> (delegate () {
1712 frame.GetValues (new LocalVariable [] { m1.GetLocal ("foo") });
1715 AssertThrows<ArgumentException> (delegate () {
1716 val = frame.GetValue (frame.Method.ReturnParameter);
1719 // invalid stack frames
1721 e = GetNextEvent ();
1722 Assert.IsTrue (e is StepEvent);
1723 Assert.AreEqual ("locals2", (e as StepEvent).Method.Name);
1725 AssertThrows<InvalidStackFrameException> (delegate () {
1726 frame.GetValue (frame.Method.GetLocal ("i"));
1732 be = run_until ("locals7");
1734 req = create_step (be);
1740 // Test that locals are initialized
1741 frame = e.Thread.GetFrames () [0];
1742 val = frame.GetValue (frame.Method.GetLocal ("t"));
1743 AssertValue (0, val);
1747 Assert.AreEqual ("locals7", (e as StepEvent).Method.Name);
1751 Assert.AreEqual ("locals7", (e as StepEvent).Method.Name);
1753 frame = e.Thread.GetFrames () [0];
1754 val = frame.GetValue (frame.Method.GetParameters ()[0]);
1755 AssertValue (22, val);
1756 val = frame.GetValue (frame.Method.GetLocal ("t"));
1757 AssertValue (22, val);
1758 val = frame.GetValue (frame.Method.GetLocal ("t2"));
1759 AssertValue (22, val);
1763 public void GetVisibleVariables () {
1764 Event e = run_until ("locals4");
1767 var locals = e.Thread.GetFrames ()[1].GetVisibleVariables ();
1768 Assert.AreEqual (2, locals.Count);
1769 var loc = locals.First (l => l.Name == "i");
1770 Assert.AreEqual ("Int64", loc.Type.Name);
1771 loc = locals.First (l => l.Name == "s");
1772 Assert.AreEqual ("String", loc.Type.Name);
1774 loc = e.Thread.GetFrames ()[1].GetVisibleVariableByName ("i");
1775 Assert.AreEqual ("i", loc.Name);
1776 Assert.AreEqual ("Int64", loc.Type.Name);
1778 e = run_until ("locals5");
1781 locals = e.Thread.GetFrames ()[1].GetVisibleVariables ();
1782 Assert.AreEqual (2, locals.Count);
1783 loc = locals.First (l => l.Name == "i");
1784 Assert.AreEqual ("String", loc.Type.Name);
1785 loc = locals.First (l => l.Name == "s");
1786 Assert.AreEqual ("String", loc.Type.Name);
1788 loc = e.Thread.GetFrames ()[1].GetVisibleVariableByName ("i");
1789 Assert.AreEqual ("i", loc.Name);
1790 Assert.AreEqual ("String", loc.Type.Name);
1792 // Variable in another scope
1793 loc = e.Thread.GetFrames ()[1].GetVisibleVariableByName ("j");
1794 Assert.IsNull (loc);
1798 public void Exit () {
1803 var e = GetNextEvent ();
1804 Assert.IsInstanceOfType (typeof (VMDeathEvent), e);
1806 Assert.AreEqual (5, (e as VMDeathEvent).ExitCode);
1809 /* Could be a remote vm with no process */
1812 Assert.AreEqual (5, p.ExitCode);
1815 AssertThrows<VMDisconnectedException> (delegate () {
1824 public void Dispose () {
1829 var e = GetNextEvent ();
1830 Assert.IsInstanceOfType (typeof (VMDisconnectEvent), e);
1833 /* Could be a remote vm with no process */
1836 Assert.AreEqual (3, p.ExitCode);
1839 AssertThrows<VMDisconnectedException> (delegate () {
1848 public void ColumnNumbers () {
1849 Event e = run_until ("line_numbers");
1851 // FIXME: Merge this with LineNumbers () when its fixed
1853 step_req = create_step (e);
1854 step_req.Depth = StepDepth.Into;
1862 e = GetNextEvent ();
1863 Assert.IsTrue (e is StepEvent);
1864 if (e.Thread.GetFrames ()[0].Method.Name == "ln1")
1868 // Do an additional step over so we are not on the beginning line of the method
1869 step_req.Disable ();
1870 step_req.Depth = StepDepth.Over;
1873 e = GetNextEvent ();
1874 Assert.IsTrue (e is StepEvent);
1876 l = e.Thread.GetFrames ()[0].Location;
1878 Assert.AreEqual (3, l.ColumnNumber);
1880 step_req.Disable ();
1884 // Broken by mcs+runtime changes (#5438)
1885 [Category("NotWorking")]
1886 public void LineNumbers () {
1887 Event e = run_until ("line_numbers");
1889 step_req = create_step (e);
1890 step_req.Depth = StepDepth.Into;
1897 e = GetNextEvent ();
1898 Assert.IsTrue (e is StepEvent);
1900 l = e.Thread.GetFrames ()[0].Location;
1902 Assert.IsTrue (l.SourceFile.IndexOf ("dtest-app.cs") != -1);
1903 Assert.AreEqual ("ln1", l.Method.Name);
1906 using (FileStream fs = new FileStream (l.SourceFile, FileMode.Open, FileAccess.Read)) {
1907 MD5 md5 = MD5.Create ();
1908 var hash = md5.ComputeHash (fs);
1910 for (int i = 0; i < 16; ++i)
1911 Assert.AreEqual (hash [i], l.SourceFileHash [i]);
1914 int line_base = l.LineNumber;
1917 e = GetNextEvent ();
1918 Assert.IsTrue (e is StepEvent);
1919 l = e.Thread.GetFrames ()[0].Location;
1920 Assert.AreEqual ("ln2", l.Method.Name);
1921 Assert.AreEqual (line_base + 6, l.LineNumber);
1924 e = GetNextEvent ();
1925 Assert.IsTrue (e is StepEvent);
1926 l = e.Thread.GetFrames ()[0].Location;
1927 Assert.AreEqual ("ln1", l.Method.Name);
1928 Assert.AreEqual (line_base + 1, l.LineNumber);
1931 e = GetNextEvent ();
1932 Assert.IsTrue (e is StepEvent);
1933 l = e.Thread.GetFrames ()[0].Location;
1934 Assert.AreEqual ("ln3", l.Method.Name);
1935 Assert.AreEqual (line_base + 11, l.LineNumber);
1938 e = GetNextEvent ();
1939 Assert.IsTrue (e is StepEvent);
1940 l = e.Thread.GetFrames ()[0].Location;
1941 Assert.AreEqual ("ln3", l.Method.Name);
1942 Assert.IsTrue (l.SourceFile.EndsWith ("FOO"));
1943 Assert.AreEqual (55, l.LineNumber);
1946 e = GetNextEvent ();
1947 Assert.IsTrue (e is StepEvent);
1948 l = e.Thread.GetFrames ()[0].Location;
1949 Assert.AreEqual ("ln1", l.Method.Name);
1950 Assert.AreEqual (line_base + 2, l.LineNumber);
1952 // GetSourceFiles ()
1953 string[] sources = l.Method.DeclaringType.GetSourceFiles ();
1954 Assert.AreEqual (2, sources.Length);
1955 Assert.AreEqual ("dtest-app.cs", sources [0]);
1956 Assert.AreEqual ("FOO", sources [1]);
1958 sources = l.Method.DeclaringType.GetSourceFiles (true);
1959 Assert.AreEqual (2, sources.Length);
1960 Assert.IsTrue (sources [0].EndsWith ("dtest-app.cs"));
1961 Assert.IsTrue (sources [1].EndsWith ("FOO"));
1965 public void Suspend () {
1968 Start (new string [] { "dtest-app.exe", "suspend-test" });
1970 Event e = run_until ("suspend");
1972 ThreadMirror main = e.Thread;
1980 // The debuggee should be suspended while it is running the infinite loop
1982 StackFrame frame = main.GetFrames ()[0];
1983 Assert.AreEqual ("suspend", frame.Method.Name);
1987 // resuming when not suspended
1988 AssertThrows<InvalidOperationException> (delegate () {
1998 public void AssemblyLoad () {
1999 Event e = run_until ("assembly_load");
2001 var load_req = vm.CreateAssemblyLoadRequest ();
2006 e = GetNextEvent ();
2007 Assert.IsInstanceOfType (typeof (AssemblyLoadEvent), e);
2008 Assert.IsTrue ((e as AssemblyLoadEvent).Assembly.Location.EndsWith ("System.dll"));
2010 var frames = e.Thread.GetFrames ();
2011 Assert.IsTrue (frames.Length > 0);
2012 Assert.AreEqual ("assembly_load", frames [0].Method.Name);
2016 public void CreateValue () {
2019 v = vm.CreateValue (1);
2020 Assert.AreEqual (vm, v.VirtualMachine);
2021 Assert.AreEqual (1, v.Value);
2023 v = vm.CreateValue (null);
2024 Assert.AreEqual (vm, v.VirtualMachine);
2025 Assert.AreEqual (null, v.Value);
2027 // Argument checking
2028 AssertThrows <ArgumentException> (delegate () {
2029 v = vm.CreateValue ("FOO");
2034 public void CreateString () {
2035 StringMirror s = vm.RootDomain.CreateString ("ABC");
2037 Assert.AreEqual (vm, s.VirtualMachine);
2038 Assert.AreEqual ("ABC", s.Value);
2039 Assert.AreEqual (vm.RootDomain, s.Domain);
2042 StringBuilder sb = new StringBuilder ();
2043 for (int i = 0; i < 1024; ++i)
2045 s = vm.RootDomain.CreateString (sb.ToString ());
2047 // Argument checking
2048 AssertThrows <ArgumentNullException> (delegate () {
2049 s = vm.RootDomain.CreateString (null);
2054 public void CreateBoxedValue () {
2055 ObjectMirror o = vm.RootDomain.CreateBoxedValue (new PrimitiveValue (vm, 42));
2057 Assert.AreEqual ("Int32", o.Type.Name);
2058 //AssertValue (42, m.GetValue (o.Type.GetField ("m_value")));
2060 // Argument checking
2061 AssertThrows <ArgumentNullException> (delegate () {
2062 vm.RootDomain.CreateBoxedValue (null);
2065 AssertThrows <ArgumentException> (delegate () {
2066 vm.RootDomain.CreateBoxedValue (o);
2071 public void Invoke () {
2072 Event e = run_until ("invoke1");
2074 StackFrame frame = e.Thread.GetFrames () [0];
2076 TypeMirror t = frame.Method.DeclaringType;
2077 ObjectMirror this_obj = (ObjectMirror)frame.GetThis ();
2079 TypeMirror t2 = frame.Method.GetParameters ()[0].ParameterType;
2085 m = t.GetMethod ("invoke_return_void");
2086 v = this_obj.InvokeMethod (e.Thread, m, null);
2090 m = t.GetMethod ("invoke_return_ref");
2091 v = this_obj.InvokeMethod (e.Thread, m, null);
2092 AssertValue ("ABC", v);
2095 m = t.GetMethod ("invoke_return_null");
2096 v = this_obj.InvokeMethod (e.Thread, m, null);
2097 AssertValue (null, v);
2100 m = t.GetMethod ("invoke_return_primitive");
2101 v = this_obj.InvokeMethod (e.Thread, m, null);
2102 AssertValue (42, v);
2105 m = t.GetMethod ("invoke_return_nullable");
2106 v = this_obj.InvokeMethod (e.Thread, m, null);
2107 Assert.IsInstanceOfType (typeof (StructMirror), v);
2108 var s = v as StructMirror;
2109 AssertValue (42, s.Fields [0]);
2110 AssertValue (true, s.Fields [1]);
2112 // pass nullable as this
2113 //m = vm.RootDomain.Corlib.GetType ("System.Object").GetMethod ("ToString");
2114 m = s.Type.GetMethod ("ToString");
2115 v = s.InvokeMethod (e.Thread, m, null);
2117 // return nullable null
2118 m = t.GetMethod ("invoke_return_nullable_null");
2119 v = this_obj.InvokeMethod (e.Thread, m, null);
2120 Assert.IsInstanceOfType (typeof (StructMirror), v);
2121 s = v as StructMirror;
2122 AssertValue (0, s.Fields [0]);
2123 AssertValue (false, s.Fields [1]);
2125 // pass nullable as this
2126 //m = vm.RootDomain.Corlib.GetType ("System.Object").GetMethod ("ToString");
2127 m = s.Type.GetMethod ("ToString");
2128 v = s.InvokeMethod (e.Thread, m, null);
2131 m = t.GetMethod ("invoke_pass_primitive");
2132 Value[] args = new Value [] {
2133 vm.CreateValue ((byte)Byte.MaxValue),
2134 vm.CreateValue ((sbyte)SByte.MaxValue),
2135 vm.CreateValue ((short)1),
2136 vm.CreateValue ((ushort)1),
2137 vm.CreateValue ((int)1),
2138 vm.CreateValue ((uint)1),
2139 vm.CreateValue ((long)1),
2140 vm.CreateValue ((ulong)1),
2141 vm.CreateValue ('A'),
2142 vm.CreateValue (true),
2143 vm.CreateValue (3.14f),
2144 vm.CreateValue (3.14) };
2146 v = this_obj.InvokeMethod (e.Thread, m, args);
2147 AssertValue ((int)Byte.MaxValue + (int)SByte.MaxValue + 1 + 1 + 1 + 1 + 1 + 1 + 'A' + 1 + 3 + 3, v);
2150 m = t.GetMethod ("invoke_pass_ref");
2151 v = this_obj.InvokeMethod (e.Thread, m, new Value [] { vm.RootDomain.CreateString ("ABC") });
2152 AssertValue ("ABC", v);
2155 m = t.GetMethod ("invoke_pass_ref");
2156 v = this_obj.InvokeMethod (e.Thread, m, new Value [] { vm.CreateValue (null) });
2157 AssertValue (null, v);
2160 m = t.GetMethod ("invoke_static_pass_ref");
2161 v = t.InvokeMethod (e.Thread, m, new Value [] { vm.RootDomain.CreateString ("ABC") });
2162 AssertValue ("ABC", v);
2164 // static invoked using ObjectMirror.InvokeMethod
2165 m = t.GetMethod ("invoke_static_pass_ref");
2166 v = this_obj.InvokeMethod (e.Thread, m, new Value [] { vm.RootDomain.CreateString ("ABC") });
2167 AssertValue ("ABC", v);
2169 // method which throws an exception
2171 m = t.GetMethod ("invoke_throws");
2172 v = this_obj.InvokeMethod (e.Thread, m, null);
2174 } catch (InvocationException ex) {
2175 Assert.AreEqual ("Exception", ex.Exception.Type.Name);
2180 m = t.GetMethod ("invoke_out");
2181 var out_task = this_obj.InvokeMethodAsyncWithResult (e.Thread, m, new Value [] { vm.CreateValue (1), vm.CreateValue (null) }, InvokeOptions.ReturnOutArgs);
2182 var out_args = out_task.Result.OutArgs;
2183 AssertValue (5, out_args [0]);
2184 Assert.IsTrue (out_args [1] is ArrayMirror);
2185 Assert.AreEqual (10, (out_args [1] as ArrayMirror).Length);
2187 // without ReturnOutArgs flag
2188 out_task = this_obj.InvokeMethodAsyncWithResult (e.Thread, m, new Value [] { vm.CreateValue (1), vm.CreateValue (null) });
2189 out_args = out_task.Result.OutArgs;
2190 Assert.IsNull (out_args);
2194 m = t.GetMethod (".ctor");
2195 v = t.InvokeMethod (e.Thread, m, null);
2196 Assert.IsInstanceOfType (typeof (ObjectMirror), v);
2197 Assert.AreEqual ("Tests", (v as ObjectMirror).Type.Name);
2200 var cl1 = frame.Method.DeclaringType.Assembly.GetType ("ITest2");
2201 m = cl1.GetMethod ("invoke_iface");
2202 v = this_obj.InvokeMethod (e.Thread, m, null);
2203 AssertValue (42, v);
2206 m = t.BaseType.GetMethod ("virtual_method");
2207 v = this_obj.InvokeMethod (e.Thread, m, null, InvokeOptions.Virtual);
2208 AssertValue ("V2", v);
2210 // virtual call on static method
2211 m = t.GetMethod ("invoke_static_pass_ref");
2212 v = t.InvokeMethod (e.Thread, m, new Value [] { vm.RootDomain.CreateString ("ABC") }, InvokeOptions.Virtual);
2213 AssertValue ("ABC", v);
2217 m = t.GetMethod ("invoke_pass_ref");
2218 var task = this_obj.InvokeMethodAsync (e.Thread, m, new Value [] { vm.RootDomain.CreateString ("ABC") });
2219 AssertValue ("ABC", task.Result);
2222 m = t.GetMethod ("invoke_static_pass_ref");
2223 task = t.InvokeMethodAsync (e.Thread, m, new Value [] { vm.RootDomain.CreateString ("ABC") });
2224 AssertValue ("ABC", task.Result);
2227 // Argument checking
2230 AssertThrows<ArgumentNullException> (delegate {
2231 m = t.GetMethod ("invoke_pass_ref");
2232 v = this_obj.InvokeMethod (null, m, new Value [] { vm.CreateValue (null) });
2236 AssertThrows<ArgumentNullException> (delegate {
2237 v = this_obj.InvokeMethod (e.Thread, null, new Value [] { vm.CreateValue (null) });
2240 // invalid number of arguments
2241 m = t.GetMethod ("invoke_pass_ref");
2242 AssertThrows<ArgumentException> (delegate {
2243 v = this_obj.InvokeMethod (e.Thread, m, null);
2246 // invalid type of argument (ref != primitive)
2247 m = t.GetMethod ("invoke_pass_ref");
2248 AssertThrows<ArgumentException> (delegate {
2249 v = this_obj.InvokeMethod (e.Thread, m, new Value [] { vm.CreateValue (1) });
2252 // invalid type of argument (primitive != primitive)
2253 m = t.GetMethod ("invoke_pass_primitive_2");
2254 AssertThrows<ArgumentException> (delegate {
2255 v = this_obj.InvokeMethod (e.Thread, m, new Value [] { vm.CreateValue (1) });
2258 // invoking a non-static method as static
2259 m = t.GetMethod ("invoke_pass_ref");
2260 AssertThrows<ArgumentException> (delegate {
2261 v = t.InvokeMethod (e.Thread, m, new Value [] { vm.RootDomain.CreateString ("ABC") });
2264 // invoking a method defined in another class
2265 m = t2.GetMethod ("invoke");
2266 AssertThrows<ArgumentException> (delegate {
2267 v = this_obj.InvokeMethod (e.Thread, m, null);
2272 public void InvokeVType () {
2273 Event e = run_until ("invoke1");
2275 StackFrame frame = e.Thread.GetFrames () [0];
2277 var s = frame.GetArgument (1) as StructMirror;
2279 TypeMirror t = s.Type;
2284 // Pass struct as this, receive int
2285 m = t.GetMethod ("invoke_return_int");
2286 v = s.InvokeMethod (e.Thread, m, null);
2287 AssertValue (42, v);
2289 // Pass boxed struct as this
2290 var boxed_this = t.NewInstance () as ObjectMirror;
2291 m = t.GetMethod ("invoke_return_int");
2292 v = boxed_this.InvokeMethod (e.Thread, m, null);
2295 // Pass struct as this, receive intptr
2296 m = t.GetMethod ("invoke_return_intptr");
2297 v = s.InvokeMethod (e.Thread, m, null);
2298 AssertValue (43, v);
2301 m = t.GetMethod ("invoke_static");
2302 v = t.InvokeMethod (e.Thread, m, null);
2305 // Pass generic struct as this
2306 s = frame.GetArgument (2) as StructMirror;
2308 m = t.GetMethod ("invoke_return_int");
2309 v = s.InvokeMethod (e.Thread, m, null);
2310 AssertValue (42, v);
2313 s = frame.GetArgument (1) as StructMirror;
2315 m = t.GetMethods ().First (method => method.Name == ".ctor" && method.GetParameters ().Length == 1);
2316 v = t.InvokeMethod (e.Thread, m, new Value [] { vm.CreateValue (1) });
2317 AssertValue (1, (v as StructMirror)["i"]);
2320 // Invoke a method which changes state
2321 s = frame.GetArgument (1) as StructMirror;
2323 m = t.GetMethod ("invoke_mutate");
2324 var task = s.InvokeMethodAsyncWithResult (e.Thread, m, null, InvokeOptions.ReturnOutThis);
2325 var out_this = task.Result.OutThis as StructMirror;
2326 AssertValue (5, out_this ["l"]);
2328 // Without the ReturnOutThis flag
2329 s = frame.GetArgument (1) as StructMirror;
2331 m = t.GetMethod ("invoke_mutate");
2332 task = s.InvokeMethodAsyncWithResult (e.Thread, m, null);
2333 out_this = task.Result.OutThis as StructMirror;
2334 Assert.AreEqual (null, out_this);
2337 var cl1 = frame.Method.DeclaringType.Assembly.GetType ("ITest2");
2338 m = cl1.GetMethod ("invoke_iface");
2339 v = s.InvokeMethod (e.Thread, m, null);
2340 AssertValue (42, v);
2343 m = vm.RootDomain.Corlib.GetType ("System.Object").GetMethod ("ToString");
2344 v = s.InvokeMethod (e.Thread, m, null, InvokeOptions.Virtual);
2345 AssertValue ("42", v);
2350 public void BreakpointDuringInvoke () {
2351 Event e = run_until ("invoke1");
2353 MethodMirror m = entry_point.DeclaringType.GetMethod ("invoke2");
2354 Assert.IsNotNull (m);
2355 vm.SetBreakpoint (m, 0);
2357 StackFrame frame = e.Thread.GetFrames () [0];
2358 var o = frame.GetThis () as ObjectMirror;
2360 bool failed = false;
2362 bool finished = false;
2363 object wait = new object ();
2365 // Have to invoke in a separate thread as the invoke is suspended until we
2366 // resume after the breakpoint
2367 Thread t = new Thread (delegate () {
2369 o.InvokeMethod (e.Thread, m, null);
2375 Monitor.Pulse (wait);
2381 StackFrame invoke_frame = null;
2384 e = GetNextEvent ();
2385 Assert.IsInstanceOfType (typeof (BreakpointEvent), e);
2386 // Check stack trace support and invokes
2387 var frames = e.Thread.GetFrames ();
2388 invoke_frame = frames [0];
2389 Assert.AreEqual ("invoke2", frames [0].Method.Name);
2390 Assert.IsTrue (frames [0].IsDebuggerInvoke);
2391 Assert.AreEqual ("invoke1", frames [1].Method.Name);
2398 Monitor.Wait (wait);
2401 // Check that the invoke frames are no longer valid
2402 AssertThrows<InvalidStackFrameException> (delegate {
2403 invoke_frame.GetThis ();
2406 // Check InvokeOptions.DisableBreakpoints flag
2407 o.InvokeMethod (e.Thread, m, null, InvokeOptions.DisableBreakpoints);
2411 public void DisabledExceptionDuringInvoke () {
2412 Event e = run_until ("invoke_ex");
2414 MethodMirror m = entry_point.DeclaringType.GetMethod ("invoke_ex_inner");
2416 StackFrame frame = e.Thread.GetFrames () [0];
2417 var o = frame.GetThis () as ObjectMirror;
2419 var req = vm.CreateExceptionRequest (null);
2422 // Check InvokeOptions.DisableBreakpoints flag
2423 o.InvokeMethod (e.Thread, m, null, InvokeOptions.DisableBreakpoints);
2429 public void InvokeSingleThreaded () {
2432 Start (new string [] { "dtest-app.exe", "invoke-single-threaded" });
2434 Event e = run_until ("invoke_single_threaded_2");
2436 StackFrame f = e.Thread.GetFrames ()[0];
2438 var obj = f.GetThis () as ObjectMirror;
2440 // Check that the counter value incremented by the other thread does not increase
2441 // during the invoke.
2442 object counter1 = (obj.GetValue (obj.Type.GetField ("counter")) as PrimitiveValue).Value;
2444 var m = obj.Type.GetMethod ("invoke_return_void");
2445 obj.InvokeMethod (e.Thread, m, null, InvokeOptions.SingleThreaded);
2447 object counter2 = (obj.GetValue (obj.Type.GetField ("counter")) as PrimitiveValue).Value;
2449 Assert.AreEqual ((int)counter1, (int)counter2);
2451 // Test multiple invokes done in succession
2452 m = obj.Type.GetMethod ("invoke_return_void");
2453 obj.InvokeMethod (e.Thread, m, null, InvokeOptions.SingleThreaded);
2455 // Test events during single-threaded invokes
2456 vm.EnableEvents (EventType.TypeLoad);
2457 m = obj.Type.GetMethod ("invoke_type_load");
2458 obj.BeginInvokeMethod (e.Thread, m, null, InvokeOptions.SingleThreaded, delegate {
2462 e = GetNextEvent ();
2463 Assert.AreEqual (EventType.TypeLoad, e.EventType);
2466 List<Value> invoke_results;
2469 public void InvokeMultiple () {
2470 Event e = run_until ("invoke1");
2472 StackFrame frame = e.Thread.GetFrames () [0];
2474 TypeMirror t = frame.Method.DeclaringType;
2475 ObjectMirror this_obj = (ObjectMirror)frame.GetThis ();
2477 TypeMirror t2 = frame.Method.GetParameters ()[0].ParameterType;
2479 var methods = new MethodMirror [2];
2480 methods [0] = t.GetMethod ("invoke_return_ref");
2481 methods [1] = t.GetMethod ("invoke_return_primitive");
2483 invoke_results = new List<Value> ();
2485 var r = this_obj.BeginInvokeMultiple (e.Thread, methods, null, InvokeOptions.SingleThreaded, invoke_multiple_cb, this_obj);
2486 WaitHandle.WaitAll (new WaitHandle[] { r.AsyncWaitHandle });
2487 this_obj.EndInvokeMultiple (r);
2488 // The callback might still be running
2489 while (invoke_results.Count < 2) {
2492 if (invoke_results [0] is PrimitiveValue) {
2493 AssertValue ("ABC", invoke_results [1]);
2494 AssertValue (42, invoke_results [0]);
2496 AssertValue ("ABC", invoke_results [0]);
2497 AssertValue (42, invoke_results [1]);
2501 void invoke_multiple_cb (IAsyncResult ar) {
2502 ObjectMirror this_obj = (ObjectMirror)ar.AsyncState;
2504 var res = this_obj.EndInvokeMethod (ar);
2505 lock (invoke_results)
2506 invoke_results.Add (res);
2510 public void InvokeAbort () {
2513 Start (new string [] { "dtest-app.exe", "invoke-abort" });
2515 Event e = run_until ("invoke_abort");
2517 StackFrame f = e.Thread.GetFrames ()[0];
2519 var obj = f.GetThis () as ObjectMirror;
2521 var m = t.GetMethod ("invoke_abort_2");
2522 // Invoke multiple times to check that the subsequent invokes are aborted too
2523 var res = (IInvokeAsyncResult)obj.BeginInvokeMultiple (e.Thread, new MethodMirror[] { m, m, m, m }, null, InvokeOptions.None, delegate { }, null);
2526 AssertThrows<CommandException> (delegate {
2527 obj.EndInvokeMethod (res);
2532 public void GetThreads () {
2537 public void Threads () {
2538 Event e = run_until ("threads");
2540 Assert.AreEqual (ThreadState.Running, e.Thread.ThreadState);
2542 Assert.IsTrue (e.Thread.ThreadId > 0);
2544 Assert.AreEqual (e.Thread.TID, e.Thread.TID);
2546 vm.EnableEvents (EventType.ThreadStart, EventType.ThreadDeath);
2550 e = GetNextEvent ();
2551 Assert.IsInstanceOfType (typeof (ThreadStartEvent), e);
2552 var state = e.Thread.ThreadState;
2553 Assert.IsTrue (state == ThreadState.Running || state == ThreadState.Unstarted);
2557 e = GetNextEvent ();
2558 Assert.IsInstanceOfType (typeof (ThreadDeathEvent), e);
2559 Assert.AreEqual (ThreadState.Stopped, e.Thread.ThreadState);
2563 public void Frame_SetValue () {
2564 Event e = run_until ("locals2");
2566 StackFrame frame = e.Thread.GetFrames () [0];
2569 var l = frame.Method.GetLocal ("i");
2570 frame.SetValue (l, vm.CreateValue ((long)55));
2571 AssertValue (55, frame.GetValue (l));
2574 l = frame.Method.GetLocal ("s");
2575 frame.SetValue (l, vm.RootDomain.CreateString ("DEF"));
2576 AssertValue ("DEF", frame.GetValue (l));
2578 // argument as local
2579 l = frame.Method.GetLocal ("arg");
2580 frame.SetValue (l, vm.CreateValue (6));
2581 AssertValue (6, frame.GetValue (l));
2584 var p = frame.Method.GetParameters ()[1];
2585 frame.SetValue (p, vm.CreateValue (7));
2586 AssertValue (7, frame.GetValue (p));
2589 p = frame.Method.GetParameters ()[2];
2590 frame.SetValue (p, vm.RootDomain.CreateString ("DEF"));
2591 AssertValue ("DEF", frame.GetValue (p));
2594 p = frame.Method.GetParameters ()[3];
2595 frame.SetValue (p, vm.RootDomain.CreateString ("DEF2"));
2596 AssertValue ("DEF2", frame.GetValue (p));
2599 p = frame.Method.GetParameters ()[4];
2600 var v = frame.GetValue (p) as StructMirror;
2601 v ["i"] = vm.CreateValue (43);
2602 frame.SetValue (p, v);
2603 v = frame.GetValue (p) as StructMirror;
2604 AssertValue (43, v ["i"]);
2606 // argument checking
2609 AssertThrows<ArgumentNullException> (delegate () {
2610 frame.SetValue ((LocalVariable)null, vm.CreateValue (55));
2614 AssertThrows<ArgumentNullException> (delegate () {
2615 l = frame.Method.GetLocal ("i");
2616 frame.SetValue (l, null);
2619 // value of invalid type
2620 AssertThrows<ArgumentException> (delegate () {
2621 l = frame.Method.GetLocal ("i");
2622 frame.SetValue (l, vm.CreateValue (55));
2628 public void Frame_SetValue_Registers () {
2629 Event e = run_until ("locals6_1");
2631 StackFrame frame = e.Thread.GetFrames () [1];
2634 var l = frame.Method.GetLocal ("j");
2635 frame.SetValue (l, vm.CreateValue (99));
2636 AssertValue (99, frame.GetValue (l));
2638 // Check it during execution
2639 e = run_until ("locals6_2");
2640 frame = e.Thread.GetFrames () [0];
2641 AssertValue (99, frame.GetValue (frame.Method.GetParameters ()[0]));
2643 // Set it while in a frame which clobbers its register
2644 e = run_until ("locals6_3");
2645 frame = e.Thread.GetFrames () [1];
2646 frame.SetValue (l, vm.CreateValue (100));
2647 AssertValue (100, frame.GetValue (l));
2649 // Check it during execution
2650 e = run_until ("locals6_4");
2651 frame = e.Thread.GetFrames () [0];
2652 AssertValue (100, frame.GetValue (frame.Method.GetParameters ()[0]));
2654 // Signed byte value
2655 e = run_until ("locals6_5");
2656 frame = e.Thread.GetFrames () [1];
2657 var l2 = frame.Method.GetLocal ("sb");
2658 frame.SetValue (l2, vm.CreateValue ((sbyte)-99));
2659 AssertValue (-99, frame.GetValue (l2));
2661 // Check it during execution
2662 e = run_until ("locals6_6");
2663 frame = e.Thread.GetFrames () [0];
2664 AssertValue (-99, frame.GetValue (frame.Method.GetParameters ()[0]));
2668 public void InvokeRegress () {
2669 Event e = run_until ("invoke1");
2671 StackFrame frame = e.Thread.GetFrames () [0];
2673 TypeMirror t = frame.Method.DeclaringType;
2674 ObjectMirror this_obj = (ObjectMirror)frame.GetThis ();
2676 TypeMirror t2 = frame.Method.GetParameters ()[0].ParameterType;
2682 m = t.GetMethod ("invoke_return_void");
2683 v = this_obj.InvokeMethod (e.Thread, m, null);
2686 // Check that the stack frames remain valid during the invoke
2687 Assert.AreEqual ("Tests", (frame.GetThis () as ObjectMirror).Type.Name);
2689 // do another invoke
2690 m = t.GetMethod ("invoke_return_void");
2691 v = this_obj.InvokeMethod (e.Thread, m, null);
2694 // Try a single step after the invoke
2695 var req = create_step (e);
2696 req.Depth = StepDepth.Into;
2697 req.Size = StepSize.Line;
2703 // Step into invoke2
2705 e = GetNextEvent ();
2706 Assert.IsTrue (e is StepEvent);
2707 Assert.AreEqual ("invoke2", (e as StepEvent).Method.Name);
2711 frame = e.Thread.GetFrames () [0];
2715 public void Exceptions () {
2716 Event e = run_until ("exceptions");
2717 var req = vm.CreateExceptionRequest (null);
2722 e = GetNextEvent ();
2723 Assert.IsInstanceOfType (typeof (ExceptionEvent), e);
2724 Assert.AreEqual ("OverflowException", (e as ExceptionEvent).Exception.Type.Name);
2726 var frames = e.Thread.GetFrames ();
2727 Assert.AreEqual ("exceptions", frames [0].Method.Name);
2730 // exception type filter
2732 req = vm.CreateExceptionRequest (vm.RootDomain.Corlib.GetType ("System.ArgumentException"));
2735 // Skip the throwing of the second OverflowException
2738 e = GetNextEvent ();
2739 Assert.IsInstanceOfType (typeof (ExceptionEvent), e);
2740 Assert.AreEqual ("ArgumentException", (e as ExceptionEvent).Exception.Type.Name);
2743 // exception type filter for subclasses
2744 req = vm.CreateExceptionRequest (vm.RootDomain.Corlib.GetType ("System.Exception"));
2749 e = GetNextEvent ();
2750 Assert.IsInstanceOfType (typeof (ExceptionEvent), e);
2751 Assert.AreEqual ("OverflowException", (e as ExceptionEvent).Exception.Type.Name);
2755 req.IncludeSubclasses = false;
2760 e = GetNextEvent ();
2761 Assert.IsInstanceOfType (typeof (ExceptionEvent), e);
2762 Assert.AreEqual ("Exception", (e as ExceptionEvent).Exception.Type.Name);
2765 // Implicit exceptions
2766 req = vm.CreateExceptionRequest (null);
2771 e = GetNextEvent ();
2772 Assert.IsInstanceOfType (typeof (ExceptionEvent), e);
2773 Assert.AreEqual ("NullReferenceException", (e as ExceptionEvent).Exception.Type.Name);
2776 // Single stepping after an exception
2777 req = vm.CreateExceptionRequest (null);
2782 e = GetNextEvent ();
2783 Assert.IsInstanceOfType (typeof (ExceptionEvent), e);
2784 Assert.AreEqual ("Exception", (e as ExceptionEvent).Exception.Type.Name);
2785 frames = e.Thread.GetFrames ();
2786 Assert.AreEqual ("exceptions2", frames [0].Method.Name);
2789 var sreq = create_step (e);
2790 sreq.Depth = StepDepth.Over;
2791 sreq.Size = StepSize.Line;
2795 e = GetNextEvent ();
2796 Assert.IsInstanceOfType (typeof (StepEvent), e);
2797 frames = e.Thread.GetFrames ();
2798 Assert.AreEqual ("exceptions", frames [0].Method.Name);
2801 // Argument checking
2802 AssertThrows<ArgumentException> (delegate {
2803 vm.CreateExceptionRequest (e.Thread.Type);
2808 public void ExceptionFilter () {
2809 Event e = run_until ("exception_filter");
2811 MethodMirror m = entry_point.DeclaringType.GetMethod ("exception_filter_filter");
2812 Assert.IsNotNull (m);
2814 vm.SetBreakpoint (m, 0);
2818 e = GetNextEvent ();
2819 Assert.AreEqual (EventType.Breakpoint, e.EventType);
2820 Assert.IsTrue (e is BreakpointEvent);
2821 Assert.AreEqual (m.Name, (e as BreakpointEvent).Method.Name);
2823 var frames = e.Thread.GetFrames ();
2825 Assert.IsTrue (frames [0].Location.SourceFile.IndexOf ("dtest-app.cs") != -1);
2826 Assert.AreEqual ("exception_filter_filter", frames [0].Location.Method.Name);
2828 Assert.AreEqual (0, frames [1].Location.Method.MetadataToken);
2829 Assert.AreEqual (0x0f, frames [1].Location.ILOffset);
2831 Assert.AreEqual ("exception_filter_method", frames [2].Location.Method.Name);
2832 Assert.AreEqual (0x06, frames [2].Location.ILOffset);
2834 Assert.AreEqual (0, frames [3].Location.Method.MetadataToken, 0);
2835 Assert.AreEqual (0, frames [3].Location.ILOffset);
2837 Assert.AreEqual ("exception_filter", frames [4].Location.Method.Name);
2841 public void ExceptionFilter2 () {
2844 Start (new string [] { "dtest-excfilter.exe" });
2846 MethodMirror filter_method = entry_point.DeclaringType.GetMethod ("Filter");
2847 Assert.IsNotNull (filter_method);
2849 MethodMirror test_method = entry_point.DeclaringType.GetMethod ("Test");
2850 Assert.IsNotNull (test_method);
2852 vm.SetBreakpoint (filter_method, 0);
2856 var e = GetNextEvent ();
2857 Assert.AreEqual (EventType.Breakpoint, e.EventType);
2858 Assert.IsTrue (e is BreakpointEvent);
2859 Assert.AreEqual (filter_method.Name, (e as BreakpointEvent).Method.Name);
2861 var frames = e.Thread.GetFrames ();
2863 Assert.AreEqual (4, frames.Count ());
2865 Assert.AreEqual (filter_method.Name, frames [0].Location.Method.Name);
2866 Assert.AreEqual (20, frames [0].Location.LineNumber);
2867 Assert.AreEqual (0, frames [0].Location.ILOffset);
2869 Assert.AreEqual (test_method.Name, frames [1].Location.Method.Name);
2870 Assert.AreEqual (37, frames [1].Location.LineNumber);
2871 Assert.AreEqual (0x0b, frames [1].Location.ILOffset);
2873 Assert.AreEqual (test_method.Name, frames [2].Location.Method.Name);
2874 Assert.AreEqual (33, frames [2].Location.LineNumber);
2875 Assert.AreEqual (0x05, frames [2].Location.ILOffset);
2877 Assert.AreEqual (entry_point.Name, frames [3].Location.Method.Name);
2878 Assert.AreEqual (14, frames [3].Location.LineNumber);
2879 Assert.AreEqual (0x00, frames [3].Location.ILOffset);
2887 public void EventSets () {
2889 // Create two filter which both match the same exception
2891 Event e = run_until ("exceptions");
2893 var req = vm.CreateExceptionRequest (null);
2896 var req2 = vm.CreateExceptionRequest (vm.RootDomain.Corlib.GetType ("System.OverflowException"));
2901 var es = vm.GetNextEventSet ();
2902 Assert.AreEqual (2, es.Events.Length);
2905 Assert.IsInstanceOfType (typeof (ExceptionEvent), e);
2906 Assert.AreEqual ("OverflowException", (e as ExceptionEvent).Exception.Type.Name);
2909 Assert.IsInstanceOfType (typeof (ExceptionEvent), e);
2910 Assert.AreEqual ("OverflowException", (e as ExceptionEvent).Exception.Type.Name);
2917 // Test single threaded invokes during processing of nullref exceptions.
2918 // These won't work if the exception handling is done from the sigsegv signal
2919 // handler, since the sigsegv signal is disabled until control returns from the
2923 [Category ("only3")]
2924 public void NullRefExceptionAndSingleThreadedInvoke () {
2925 Event e = run_until ("exceptions");
2926 var req = vm.CreateExceptionRequest (vm.RootDomain.Corlib.GetType ("System.NullReferenceException"));
2931 e = GetNextEvent ();
2932 Assert.IsInstanceOfType (typeof (ExceptionEvent), e);
2933 Assert.AreEqual ("NullReferenceException", (e as ExceptionEvent).Exception.Type.Name);
2935 var ex = (e as ExceptionEvent).Exception;
2936 var tostring_method = vm.RootDomain.Corlib.GetType ("System.Object").GetMethod ("ToString");
2937 ex.InvokeMethod (e.Thread, tostring_method, null, InvokeOptions.SingleThreaded);
2941 public void MemberInOtherDomain () {
2944 Start (new string [] { "dtest-app.exe", "domain-test" });
2946 vm.EnableEvents (EventType.AppDomainCreate, EventType.AppDomainUnload, EventType.AssemblyUnload);
2948 Event e = run_until ("domains_print_across");
2950 var frame = e.Thread.GetFrames ()[0];
2951 var inOtherDomain = frame.GetArgument (0) as ObjectMirror;
2952 var crossDomainField = (ObjectMirror) inOtherDomain.GetValue (inOtherDomain.Type.GetField("printMe"));
2953 Assert.AreEqual ("SentinelClass", crossDomainField.Type.Name);
2957 public void Domains () {
2960 Start (new string [] { "dtest-app.exe", "domain-test" });
2962 vm.EnableEvents (EventType.AppDomainCreate, EventType.AppDomainUnload, EventType.AssemblyUnload);
2964 Event e = run_until ("domains");
2968 e = GetNextEvent ();
2969 Assert.IsInstanceOfType (typeof (AppDomainCreateEvent), e);
2971 var domain = (e as AppDomainCreateEvent).Domain;
2973 // Check the object type
2974 e = run_until ("domains_2");
2975 var frame = e.Thread.GetFrames ()[0];
2976 var o = frame.GetArgument (0) as ObjectMirror;
2977 Assert.AreEqual ("CrossDomain", o.Type.Name);
2979 // Do a remoting invoke
2980 var cross_domain_type = o.Type;
2981 var v = o.InvokeMethod (e.Thread, cross_domain_type.GetMethod ("invoke_3"), null);
2982 AssertValue (42, v);
2984 // Run until the callback in the domain
2985 MethodMirror m = entry_point.DeclaringType.GetMethod ("invoke_in_domain");
2986 Assert.IsNotNull (m);
2987 vm.SetBreakpoint (m, 0);
2991 e = GetNextEvent ();
2992 if (e is BreakpointEvent)
2996 Assert.AreEqual ("invoke_in_domain", (e as BreakpointEvent).Method.Name);
2998 // d_method is from another domain
2999 MethodMirror d_method = (e as BreakpointEvent).Method;
3000 Assert.IsTrue (m != d_method);
3002 var frames = e.Thread.GetFrames ();
3003 Assert.AreEqual ("invoke_in_domain", frames [0].Method.Name);
3004 Assert.AreEqual (domain, frames [0].Domain);
3005 Assert.AreEqual ("invoke", frames [1].Method.Name);
3006 Assert.AreEqual ("domains", frames [2].Method.Name);
3007 Assert.AreEqual (vm.RootDomain, frames [2].Domain);
3009 // Test breakpoints on already JITted methods in other domains
3010 m = entry_point.DeclaringType.GetMethod ("invoke_in_domain_2");
3011 Assert.IsNotNull (m);
3012 vm.SetBreakpoint (m, 0);
3016 e = GetNextEvent ();
3017 if (e is BreakpointEvent)
3021 Assert.AreEqual ("invoke_in_domain_2", (e as BreakpointEvent).Method.Name);
3023 // This is empty when receiving the AppDomainCreateEvent
3024 Assert.AreEqual ("domain", domain.FriendlyName);
3026 // Run until the unload
3029 e = GetNextEvent ();
3030 if (e is AssemblyUnloadEvent) {
3036 Assert.IsInstanceOfType (typeof (AppDomainUnloadEvent), e);
3037 Assert.AreEqual (domain, (e as AppDomainUnloadEvent).Domain);
3039 // Run past the unload
3040 e = run_until ("domains_3");
3042 // Test access to unloaded types
3043 // FIXME: Add an exception type for this
3044 AssertThrows<Exception> (delegate {
3045 d_method.DeclaringType.GetValue (d_method.DeclaringType.GetField ("static_i"));
3048 // Check that .Domain is accessible for stack frames with native transitions
3049 e = run_until ("called_from_invoke");
3050 ThreadMirror.NativeTransitions = true;
3051 foreach (var f in e.Thread.GetFrames ()) {
3057 public void DynamicMethods () {
3058 Event e = run_until ("dyn_call");
3060 var m = e.Thread.GetFrames ()[1].Method;
3061 Assert.AreEqual ("dyn_method", m.Name);
3063 // Test access to IL
3064 var body = m.GetMethodBody ();
3066 ILInstruction ins = body.Instructions [0];
3067 Assert.AreEqual (OpCodes.Ldstr, ins.OpCode);
3068 Assert.AreEqual ("FOO", ins.Operand);
3072 public void RefEmit () {
3075 Start (new string [] { "dtest-app.exe", "ref-emit-test" });
3077 Event e = run_until ("ref_emit_call");
3079 var m = e.Thread.GetFrames ()[1].Method;
3080 Assert.AreEqual ("ref_emit_method", m.Name);
3082 // Test access to IL
3083 var body = m.GetMethodBody ();
3087 ins = body.Instructions [0];
3088 Assert.AreEqual (OpCodes.Ldstr, ins.OpCode);
3089 Assert.AreEqual ("FOO", ins.Operand);
3091 ins = body.Instructions [1];
3092 Assert.AreEqual (OpCodes.Call, ins.OpCode);
3093 Assert.IsInstanceOfType (typeof (MethodMirror), ins.Operand);
3094 Assert.AreEqual ("ref_emit_call", (ins.Operand as MethodMirror).Name);
3098 public void IsAttached () {
3099 var f = entry_point.DeclaringType.GetField ("is_attached");
3101 Event e = run_until ("Main");
3103 AssertValue (true, entry_point.DeclaringType.GetValue (f));
3107 public void StackTraceInNative () {
3108 // Check that stack traces can be produced for threads in native code
3111 Start (new string [] { "dtest-app.exe", "frames-in-native" });
3113 var e = run_until ("frames_in_native");
3115 // FIXME: This is racy
3122 StackFrame[] frames = e.Thread.GetFrames ();
3124 int frame_index = -1;
3125 for (int i = 0; i < frames.Length; ++i) {
3126 if (frames [i].Method.Name == "Sleep") {
3132 Assert.IsTrue (frame_index != -1);
3133 Assert.AreEqual ("Sleep", frames [frame_index].Method.Name);
3134 Assert.AreEqual ("frames_in_native", frames [frame_index + 1].Method.Name);
3135 Assert.AreEqual ("Main", frames [frame_index + 2].Method.Name);
3137 // Check that invokes are disabled for such threads
3138 TypeMirror t = frames [frame_index + 1].Method.DeclaringType;
3140 var m = t.GetMethod ("invoke_static_return_void");
3141 AssertThrows<InvalidOperationException> (delegate {
3142 t.InvokeMethod (e.Thread, m, null);
3145 // Check that the frame info is invalidated
3146 run_until ("frames_in_native_2");
3148 AssertThrows<InvalidStackFrameException> (delegate {
3149 Console.WriteLine (frames [frame_index].GetThis ());
3154 public void VirtualMachine_CreateEnumMirror () {
3155 var e = run_until ("o1");
3156 var frame = e.Thread.GetFrames () [0];
3158 object val = frame.GetThis ();
3159 Assert.IsTrue (val is ObjectMirror);
3160 Assert.AreEqual ("Tests", (val as ObjectMirror).Type.Name);
3161 ObjectMirror o = (val as ObjectMirror);
3163 FieldInfoMirror field = o.Type.GetField ("field_enum");
3164 Value f = o.GetValue (field);
3165 TypeMirror enumType = (f as EnumMirror).Type;
3167 o.SetValue (field, vm.CreateEnumMirror (enumType, vm.CreateValue (1)));
3168 f = o.GetValue (field);
3169 Assert.AreEqual (1, (f as EnumMirror).Value);
3171 // Argument checking
3172 AssertThrows<ArgumentNullException> (delegate () {
3173 vm.CreateEnumMirror (enumType, null);
3176 AssertThrows<ArgumentNullException> (delegate () {
3177 vm.CreateEnumMirror (null, vm.CreateValue (1));
3181 AssertThrows<ArgumentException> (delegate () {
3182 vm.CreateEnumMirror (enumType, vm.CreateValue (null));
3185 // value of a wrong type
3186 AssertThrows<ArgumentException> (delegate () {
3187 vm.CreateEnumMirror (enumType, vm.CreateValue ((long)1));
3192 public void VirtualMachine_EnableEvents_Breakpoint () {
3193 AssertThrows<ArgumentException> (delegate () {
3194 vm.EnableEvents (EventType.Breakpoint);
3199 public void SingleStepRegress654694 () {
3202 MethodMirror m = entry_point.DeclaringType.GetMethod ("ss_regress_654694");
3203 foreach (Location l in m.Locations) {
3204 if (l.ILOffset > 0 && il_offset == -1)
3205 il_offset = l.ILOffset;
3208 Event e = run_until ("ss_regress_654694");
3210 Assert.IsNotNull (m);
3211 vm.SetBreakpoint (m, il_offset);
3215 e = GetNextEvent ();
3216 Assert.IsTrue (e is BreakpointEvent);
3218 var req = create_step (e);
3219 req.Depth = StepDepth.Over;
3220 req.Size = StepSize.Line;
3225 e = GetNextEvent ();
3226 Assert.IsTrue (e is StepEvent);
3232 public void DebugBreak () {
3233 vm.EnableEvents (EventType.UserBreak);
3238 var e = GetNextEvent ();
3239 Assert.IsTrue (e is UserBreakEvent);
3243 public void DebugLog () {
3244 vm.EnableEvents (EventType.UserLog);
3249 var e = GetNextEvent ();
3250 Assert.IsTrue (e is UserLogEvent);
3251 var le = e as UserLogEvent;
3253 Assert.AreEqual (5, le.Level);
3254 Assert.AreEqual ("A", le.Category);
3255 Assert.AreEqual ("B", le.Message);
3259 public void TypeGetMethodsByNameFlags () {
3261 var assembly = entry_point.DeclaringType.Assembly;
3262 var type = assembly.GetType ("Tests3");
3264 Assert.IsNotNull (type);
3266 mm = type.GetMethodsByNameFlags (null, BindingFlags.Static | BindingFlags.Public, false);
3267 Assert.AreEqual (1, mm.Length, "#1");
3268 Assert.AreEqual ("M1", mm[0].Name, "#2");
3270 mm = type.GetMethodsByNameFlags (null, BindingFlags.Static | BindingFlags.NonPublic, false);
3271 Assert.AreEqual (1, mm.Length, "#3");
3272 Assert.AreEqual ("M2", mm[0].Name, "#4");
3274 mm = type.GetMethodsByNameFlags (null, BindingFlags.Instance | BindingFlags.Public, false);
3275 Assert.AreEqual (7, mm.Length, "#5"); //M3 plus Equals, GetHashCode, GetType, ToString, .ctor
3277 mm = type.GetMethodsByNameFlags (null, BindingFlags.Instance | BindingFlags.Public | BindingFlags.DeclaredOnly, false);
3278 Assert.AreEqual (2, mm.Length, "#7");
3280 mm = type.GetMethodsByNameFlags (null, BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.DeclaredOnly, false);
3281 Assert.AreEqual (1, mm.Length, "#9");
3283 mm = type.GetMethodsByNameFlags (null, BindingFlags.Static | BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.DeclaredOnly, false);
3284 Assert.AreEqual (5, mm.Length, "#11");
3287 mm = type.GetMethodsByNameFlags ("M1", BindingFlags.Static | BindingFlags.Public, false);
3288 Assert.AreEqual (1, mm.Length, "#12");
3289 Assert.AreEqual ("M1", mm[0].Name, "#13");
3291 mm = type.GetMethodsByNameFlags ("m1", BindingFlags.Static | BindingFlags.Public, true);
3292 Assert.AreEqual (1, mm.Length, "#14");
3293 Assert.AreEqual ("M1", mm[0].Name, "#15");
3295 mm = type.GetMethodsByNameFlags ("M1", BindingFlags.Static | BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic, false);
3296 Assert.AreEqual (1, mm.Length, "#16");
3297 Assert.AreEqual ("M1", mm[0].Name, "#17");
3301 [Category ("only88")]
3302 public void TypeLoadSourceFileFilter () {
3303 Event e = run_until ("type_load");
3305 if (!vm.Version.AtLeast (2, 7))
3308 string srcfile = (e as BreakpointEvent).Method.DeclaringType.GetSourceFiles (true)[0];
3310 var req = vm.CreateTypeLoadRequest ();
3311 req.SourceFileFilter = new string [] { srcfile.ToUpper () };
3315 e = GetNextEvent ();
3316 Assert.IsTrue (e is TypeLoadEvent);
3317 Assert.AreEqual ("TypeLoadClass", (e as TypeLoadEvent).Type.FullName);
3321 public void TypeLoadTypeNameFilter () {
3322 Event e = run_until ("type_load");
3324 var req = vm.CreateTypeLoadRequest ();
3325 req.TypeNameFilter = new string [] { "TypeLoadClass2" };
3329 e = GetNextEvent ();
3330 Assert.IsTrue (e is TypeLoadEvent);
3331 Assert.AreEqual ("TypeLoadClass2", (e as TypeLoadEvent).Type.FullName);
3335 public void GetTypesForSourceFile () {
3338 var types = vm.GetTypesForSourceFile ("dtest-app.cs", false);
3339 Assert.IsTrue (types.Any (t => t.FullName == "Tests"));
3340 Assert.IsFalse (types.Any (t => t.FullName == "System.Int32"));
3342 types = vm.GetTypesForSourceFile ("DTEST-app.cs", true);
3343 Assert.IsTrue (types.Any (t => t.FullName == "Tests"));
3344 Assert.IsFalse (types.Any (t => t.FullName == "System.Int32"));
3348 public void GetTypesNamed () {
3351 var types = vm.GetTypes ("Tests", false);
3352 Assert.AreEqual (1, types.Count);
3353 Assert.AreEqual ("Tests", types [0].FullName);
3355 types = vm.GetTypes ("System.Exception", false);
3356 Assert.AreEqual (1, types.Count);
3357 Assert.AreEqual ("System.Exception", types [0].FullName);
3361 public void String_GetValue () {
3366 var e = run_until ("arg2");
3368 var frame = e.Thread.GetFrames () [0];
3370 val = frame.GetArgument (6);
3371 Assert.AreEqual ('\0'.ToString () + "A", (val as StringMirror).Value);
3375 public void String_GetChars () {
3379 var e = run_until ("arg2");
3381 var frame = e.Thread.GetFrames () [0];
3383 val = frame.GetArgument (0);
3384 Assert.IsTrue (val is StringMirror);
3385 AssertValue ("FOO", val);
3386 var s = (val as StringMirror);
3387 Assert.AreEqual (3, s.Length);
3389 var c = s.GetChars (0, 2);
3390 Assert.AreEqual (2, c.Length);
3391 Assert.AreEqual ('F', c [0]);
3392 Assert.AreEqual ('O', c [1]);
3394 AssertThrows<ArgumentException> (delegate () {
3400 public void GetInterfaces () {
3401 var e = run_until ("arg2");
3403 var frame = e.Thread.GetFrames () [0];
3405 var cl1 = frame.Method.DeclaringType.Assembly.GetType ("TestIfaces");
3406 var ifaces = cl1.GetInterfaces ();
3407 Assert.AreEqual (1, ifaces.Length);
3408 Assert.AreEqual ("ITest", ifaces [0].Name);
3410 var cl2 = cl1.GetMethod ("Baz").ReturnType;
3411 var ifaces2 = cl2.GetInterfaces ();
3412 Assert.AreEqual (1, ifaces2.Length);
3413 Assert.AreEqual ("ITest`1", ifaces2 [0].Name);
3417 public void GetInterfaceMap () {
3418 var e = run_until ("arg2");
3420 var frame = e.Thread.GetFrames () [0];
3422 var cl1 = frame.Method.DeclaringType.Assembly.GetType ("TestIfaces");
3423 var iface = cl1.Assembly.GetType ("ITest");
3424 var map = cl1.GetInterfaceMap (iface);
3425 Assert.AreEqual (cl1, map.TargetType);
3426 Assert.AreEqual (iface, map.InterfaceType);
3427 Assert.AreEqual (2, map.InterfaceMethods.Length);
3428 Assert.AreEqual (2, map.TargetMethods.Length);
3432 public void StackAlloc_Breakpoints_Regress2775 () {
3433 // Check that breakpoints on arm don't overwrite stackalloc-ed memory
3434 var e = run_until ("regress_2755");
3436 var frame = e.Thread.GetFrames () [0];
3438 // This breaks at the call site
3439 vm.SetBreakpoint (m, m.Locations [2].ILOffset);
3442 var e2 = GetNextEvent ();
3443 Assert.IsTrue (e2 is BreakpointEvent);
3445 e = run_until ("regress_2755_3");
3446 frame = e.Thread.GetFrames () [1];
3447 var res = frame.GetValue (m.GetLocal ("sum"));
3448 AssertValue (0, res);
3452 public void MethodInfo () {
3453 Event e = run_until ("locals2");
3455 StackFrame frame = e.Thread.GetFrames () [0];
3456 var m = frame.Method;
3458 Assert.IsTrue (m.IsGenericMethod);
3459 Assert.IsFalse (m.IsGenericMethodDefinition);
3461 var args = m.GetGenericArguments ();
3462 Assert.AreEqual (1, args.Length);
3463 Assert.AreEqual ("String", args [0].Name);
3465 var gmd = m.GetGenericMethodDefinition ();
3466 Assert.IsTrue (gmd.IsGenericMethod);
3467 Assert.IsTrue (gmd.IsGenericMethodDefinition);
3468 Assert.AreEqual (gmd, gmd.GetGenericMethodDefinition ());
3470 args = gmd.GetGenericArguments ();
3471 Assert.AreEqual (1, args.Length);
3472 Assert.AreEqual ("T", args [0].Name);
3474 var attrs = m.GetCustomAttributes (true);
3475 Assert.AreEqual (1, attrs.Length);
3476 Assert.AreEqual ("StateMachineAttribute", attrs [0].Constructor.DeclaringType.Name);
3480 public void UnhandledException () {
3483 Start (new string [] { "dtest-app.exe", "unhandled-exception" });
3485 var req = vm.CreateExceptionRequest (null, false, true);
3488 var e = run_until ("unhandled_exception");
3491 var e2 = GetNextEvent ();
3492 Assert.IsTrue (e2 is ExceptionEvent);
3499 public void UnhandledException_2 () {
3502 Start (new string [] { "dtest-app.exe", "unhandled-exception-endinvoke" });
3504 var req = vm.CreateExceptionRequest (null, false, true);
3507 MethodMirror m = entry_point.DeclaringType.GetMethod ("unhandled_exception_endinvoke_2");
3508 Assert.IsNotNull (m);
3509 vm.SetBreakpoint (m, m.ILOffsets [0]);
3511 var e = run_until ("unhandled_exception_endinvoke");
3514 var e2 = GetNextEvent ();
3515 Assert.IsFalse (e2 is ExceptionEvent);
3523 public void UnhandledExceptionUserCode () {
3526 // Exceptions caught in non-user code are treated as unhandled
3527 Start (new string [] { "dtest-app.exe", "unhandled-exception-user" });
3529 var req = vm.CreateExceptionRequest (null, false, true);
3530 req.AssemblyFilter = new List<AssemblyMirror> () { entry_point.DeclaringType.Assembly };
3533 var e = run_until ("unhandled_exception_user");
3536 var e2 = GetNextEvent ();
3537 Assert.IsTrue (e2 is ExceptionEvent);
3545 public void GCWhileSuspended () {
3546 // Check that objects are kept alive during suspensions
3547 Event e = run_until ("gc_suspend_1");
3549 MethodMirror m = entry_point.DeclaringType.GetMethod ("gc_suspend_invoke");
3551 var o = entry_point.DeclaringType.GetValue (entry_point.DeclaringType.GetField ("gc_suspend_field")) as ObjectMirror;
3552 //Console.WriteLine (o);
3554 StackFrame frame = e.Thread.GetFrames () [0];
3555 TypeMirror t = frame.Method.DeclaringType;
3556 for (int i = 0; i < 10; ++i)
3557 t.InvokeMethod (e.Thread, m, new Value [] { });
3559 // This throws an exception if the object is collected
3560 long addr = o.Address;
3562 var o2 = entry_point.DeclaringType.GetValue (entry_point.DeclaringType.GetField ("gc_suspend_field")) as ObjectMirror;
3567 public void MakeGenericMethod () {
3568 Event e = run_until ("bp1");
3570 var intm = vm.RootDomain.GetCorrespondingType (typeof (int));
3571 var stringm = vm.RootDomain.GetCorrespondingType (typeof (string));
3572 var gm = entry_point.DeclaringType.GetMethod ("generic_method");
3573 var res = gm.MakeGenericMethod (new TypeMirror [] { stringm });
3574 var args = res.GetGenericArguments ();
3575 Assert.AreEqual (1, args.Length);
3576 Assert.AreEqual (stringm, args [0]);
3579 AssertThrows<ArgumentNullException> (delegate {
3580 gm.MakeGenericMethod (null);
3582 AssertThrows<ArgumentNullException> (delegate {
3583 gm.MakeGenericMethod (new TypeMirror [] { null });
3585 AssertThrows<ArgumentException> (delegate {
3586 gm.MakeGenericMethod (new TypeMirror [] { stringm, stringm });
3588 AssertThrows<InvalidOperationException> (delegate {
3589 gm.MakeGenericMethod (new TypeMirror [] { intm });
3591 AssertThrows<InvalidOperationException> (delegate {
3592 entry_point.DeclaringType.GetMethod ("Main").MakeGenericMethod (new TypeMirror [] { intm });
3597 public void InspectThreadSuspenedOnWaitOne () {
3599 Start (true, "dtest-app.exe", "wait-one" );
3601 ThreadMirror.NativeTransitions = true;
3603 var evt = run_until ("wait_one");
3604 Assert.IsNotNull (evt, "#1");
3606 var thread = evt.Thread;
3607 Assert.AreEqual (ThreadState.Running, thread.ThreadState, "#1.1");
3609 var frames = thread.GetFrames ();
3610 Assert.IsNotNull (frames, "#2");
3611 Assert.AreEqual (2, frames.Length, "#3");
3612 Assert.AreEqual ("wait_one", frames [0].Method.Name, "#4");
3613 Assert.AreEqual ("Main", frames [1].Method.Name, "#5");
3617 Thread.Sleep (500); //FIXME this is racy, maybe single step? or something?
3620 Assert.AreEqual (ThreadState.WaitSleepJoin, thread.ThreadState, "#6");
3622 frames = thread.GetFrames ();
3623 Assert.AreEqual (4, frames.Length, "#7");
3624 Assert.AreEqual ("WaitOne_internal", frames [0].Method.Name, "#8");
3625 Assert.AreEqual ("WaitOne", frames [1].Method.Name, "#8.1");
3626 Assert.AreEqual ("wait_one", frames [2].Method.Name, "#9");
3627 Assert.AreEqual ("Main", frames [3].Method.Name, "#10");
3630 var frame = frames [0];
3631 Assert.IsTrue (frame.IsNativeTransition, "#11.1");
3634 Assert.Fail ("Known limitation - can't get info from m2n frames");
3635 } catch (AbsentInformationException) {}
3638 Assert.IsFalse (frame.IsNativeTransition, "#12.1");
3639 var wait_one_this = frame.GetThis ();
3640 Assert.IsNotNull (wait_one_this, "#12.2");
3643 var locals = frame.GetVisibleVariables ();
3644 Assert.AreEqual (1, locals.Count, "#13.1");
3646 var local_0 = frame.GetValue (locals [0]);
3647 Assert.IsNotNull (local_0, "#13.2");
3649 Assert.AreEqual (wait_one_this, local_0, "#14.2");
3653 public void GetMethodBody () {
3654 var bevent = run_until ("Main");
3656 var m = bevent.Method.DeclaringType.GetMethod ("get_IntProperty");
3657 var body = m.GetMethodBody ();
3658 foreach (var ins in body.Instructions) {
3659 if (ins.OpCode == OpCodes.Ldfld) {
3660 var field = (FieldInfoMirror)ins.Operand;
3661 Assert.AreEqual ("field_i", field.Name);
3667 public void EvaluateMethod () {
3668 var bevent = run_until ("evaluate_method_2");
3670 var m = bevent.Method.DeclaringType.GetMethod ("get_IntProperty");
3672 var this_obj = bevent.Thread.GetFrames ()[0].GetThis ();
3673 var v = m.Evaluate (this_obj, null);
3674 AssertValue (42, v);
3678 public void SetIP () {
3679 var bevent = run_until ("set_ip_1");
3681 var invalid_loc = bevent.Thread.GetFrames ()[0].Location;
3683 var req = create_step (bevent);
3684 var e = step_out ();
3686 var frames = e.Thread.GetFrames ();
3687 var locs = frames [0].Method.Locations;
3688 var next_loc = locs.First (l => (l.LineNumber == frames [0].Location.LineNumber + 2));
3690 e.Thread.SetIP (next_loc);
3692 /* Check that i ++; j = 5; was skipped */
3693 bevent = run_until ("set_ip_2");
3694 var f = bevent.Thread.GetFrames ()[1];
3695 AssertValue (2, f.GetValue (f.Method.GetLocal ("i")));
3696 AssertValue (0, f.GetValue (f.Method.GetLocal ("j")));
3699 AssertThrows<ArgumentNullException> (delegate {
3700 e.Thread.SetIP (null);
3703 AssertThrows<ArgumentException> (delegate {
3704 e.Thread.SetIP (invalid_loc);
3709 public void SetIPSingleStep () {
3710 // Check that single stepping after set-ip steps from the new ip
3711 var bevent = run_until ("set_ip_1");
3713 var invalid_loc = bevent.Thread.GetFrames ()[0].Location;
3715 var req = create_step (bevent);
3716 req.Size = StepSize.Line;
3717 var e = step_out ();
3719 var frames = e.Thread.GetFrames ();
3720 var locs = frames [0].Method.Locations;
3721 var prev_loc = locs.First (l => (l.LineNumber == frames [0].Location.LineNumber - 3));
3722 AssertValue (2, frames [0].GetValue (frames [0].Method.GetLocal ("i")));
3724 // Set back the ip to the first i ++; line
3725 e.Thread.SetIP (prev_loc);
3728 var f = e.Thread.GetFrames ()[0];
3729 AssertValue (3, f.GetValue (f.Method.GetLocal ("i")));
3733 public void NewInstanceNoCtor () {
3734 var bevent = run_until ("Main");
3736 var stype = bevent.Method.DeclaringType.Assembly.GetType ("AStruct");
3737 var obj = stype.NewInstance ();
3738 Assert.IsTrue (obj is ObjectMirror);
3739 Assert.AreEqual ("AStruct", (obj as ObjectMirror).Type.Name);
3743 public void StaticCtorFilterInCctor () {
3744 // Check that single stepping when in a cctor only ignores
3745 // other cctors, not the current one
3746 var bevent = run_until ("step_filters");
3748 var assembly = entry_point.DeclaringType.Assembly;
3749 var type = assembly.GetType ("Tests/ClassWithCctor");
3750 var cctor = type.GetMethod (".cctor");
3751 vm.SetBreakpoint (cctor, 0);
3754 var e = vm.GetNextEvent ();
3755 Assert.IsTrue (e is BreakpointEvent);
3757 var req = create_step (e);
3758 req.Filter = StepFilter.StaticCtor;
3760 // Make sure we are still in the cctor
3761 Assert.AreEqual (".cctor", e.Thread.GetFrames ()[0].Location.Method.Name);