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 InvokeNested () {
2511 Event e = run_until ("invoke1");
2513 MethodMirror m = entry_point.DeclaringType.GetMethod ("invoke2");
2514 Assert.IsNotNull (m);
2515 vm.SetBreakpoint (m, 0);
2517 StackFrame frame = e.Thread.GetFrames () [0];
2518 var o = frame.GetThis () as ObjectMirror;
2520 bool failed = false;
2522 bool finished = false;
2523 object wait = new object ();
2525 Thread t = new Thread (delegate () {
2527 o.InvokeMethod (e.Thread, m, null);
2533 Monitor.Pulse (wait);
2539 StackFrame invoke_frame = null;
2541 e = GetNextEvent ();
2542 Assert.IsInstanceOfType (typeof (BreakpointEvent), e);
2544 // Check that nested invokes are not allowed
2545 AssertThrows<VMNotSuspendedException> (delegate {
2546 o.InvokeMethod (e.Thread, m, null);
2552 Monitor.Wait (wait);
2557 public void GetThreads () {
2562 public void Threads () {
2563 Event e = run_until ("threads");
2565 Assert.AreEqual (ThreadState.Running, e.Thread.ThreadState);
2567 Assert.IsTrue (e.Thread.ThreadId > 0);
2569 Assert.AreEqual (e.Thread.TID, e.Thread.TID);
2571 vm.EnableEvents (EventType.ThreadStart, EventType.ThreadDeath);
2575 e = GetNextEvent ();
2576 Assert.IsInstanceOfType (typeof (ThreadStartEvent), e);
2577 var state = e.Thread.ThreadState;
2578 Assert.IsTrue (state == ThreadState.Running || state == ThreadState.Unstarted);
2582 e = GetNextEvent ();
2583 Assert.IsInstanceOfType (typeof (ThreadDeathEvent), e);
2584 Assert.AreEqual (ThreadState.Stopped, e.Thread.ThreadState);
2588 public void Frame_SetValue () {
2589 Event e = run_until ("locals2");
2591 StackFrame frame = e.Thread.GetFrames () [0];
2594 var l = frame.Method.GetLocal ("i");
2595 frame.SetValue (l, vm.CreateValue ((long)55));
2596 AssertValue (55, frame.GetValue (l));
2599 l = frame.Method.GetLocal ("s");
2600 frame.SetValue (l, vm.RootDomain.CreateString ("DEF"));
2601 AssertValue ("DEF", frame.GetValue (l));
2603 // argument as local
2604 l = frame.Method.GetLocal ("arg");
2605 frame.SetValue (l, vm.CreateValue (6));
2606 AssertValue (6, frame.GetValue (l));
2609 var p = frame.Method.GetParameters ()[1];
2610 frame.SetValue (p, vm.CreateValue (7));
2611 AssertValue (7, frame.GetValue (p));
2614 p = frame.Method.GetParameters ()[2];
2615 frame.SetValue (p, vm.RootDomain.CreateString ("DEF"));
2616 AssertValue ("DEF", frame.GetValue (p));
2619 p = frame.Method.GetParameters ()[3];
2620 frame.SetValue (p, vm.RootDomain.CreateString ("DEF2"));
2621 AssertValue ("DEF2", frame.GetValue (p));
2624 p = frame.Method.GetParameters ()[4];
2625 var v = frame.GetValue (p) as StructMirror;
2626 v ["i"] = vm.CreateValue (43);
2627 frame.SetValue (p, v);
2628 v = frame.GetValue (p) as StructMirror;
2629 AssertValue (43, v ["i"]);
2631 // argument checking
2634 AssertThrows<ArgumentNullException> (delegate () {
2635 frame.SetValue ((LocalVariable)null, vm.CreateValue (55));
2639 AssertThrows<ArgumentNullException> (delegate () {
2640 l = frame.Method.GetLocal ("i");
2641 frame.SetValue (l, null);
2644 // value of invalid type
2645 AssertThrows<ArgumentException> (delegate () {
2646 l = frame.Method.GetLocal ("i");
2647 frame.SetValue (l, vm.CreateValue (55));
2653 public void Frame_SetValue_Registers () {
2654 Event e = run_until ("locals6_1");
2656 StackFrame frame = e.Thread.GetFrames () [1];
2659 var l = frame.Method.GetLocal ("j");
2660 frame.SetValue (l, vm.CreateValue (99));
2661 AssertValue (99, frame.GetValue (l));
2663 // Check it during execution
2664 e = run_until ("locals6_2");
2665 frame = e.Thread.GetFrames () [0];
2666 AssertValue (99, frame.GetValue (frame.Method.GetParameters ()[0]));
2668 // Set it while in a frame which clobbers its register
2669 e = run_until ("locals6_3");
2670 frame = e.Thread.GetFrames () [1];
2671 frame.SetValue (l, vm.CreateValue (100));
2672 AssertValue (100, frame.GetValue (l));
2674 // Check it during execution
2675 e = run_until ("locals6_4");
2676 frame = e.Thread.GetFrames () [0];
2677 AssertValue (100, frame.GetValue (frame.Method.GetParameters ()[0]));
2679 // Signed byte value
2680 e = run_until ("locals6_5");
2681 frame = e.Thread.GetFrames () [1];
2682 var l2 = frame.Method.GetLocal ("sb");
2683 frame.SetValue (l2, vm.CreateValue ((sbyte)-99));
2684 AssertValue (-99, frame.GetValue (l2));
2686 // Check it during execution
2687 e = run_until ("locals6_6");
2688 frame = e.Thread.GetFrames () [0];
2689 AssertValue (-99, frame.GetValue (frame.Method.GetParameters ()[0]));
2693 public void InvokeRegress () {
2694 Event e = run_until ("invoke1");
2696 StackFrame frame = e.Thread.GetFrames () [0];
2698 TypeMirror t = frame.Method.DeclaringType;
2699 ObjectMirror this_obj = (ObjectMirror)frame.GetThis ();
2701 TypeMirror t2 = frame.Method.GetParameters ()[0].ParameterType;
2707 m = t.GetMethod ("invoke_return_void");
2708 v = this_obj.InvokeMethod (e.Thread, m, null);
2711 // Check that the stack frames remain valid during the invoke
2712 Assert.AreEqual ("Tests", (frame.GetThis () as ObjectMirror).Type.Name);
2714 // do another invoke
2715 m = t.GetMethod ("invoke_return_void");
2716 v = this_obj.InvokeMethod (e.Thread, m, null);
2719 // Try a single step after the invoke
2720 var req = create_step (e);
2721 req.Depth = StepDepth.Into;
2722 req.Size = StepSize.Line;
2728 // Step into invoke2
2730 e = GetNextEvent ();
2731 Assert.IsTrue (e is StepEvent);
2732 Assert.AreEqual ("invoke2", (e as StepEvent).Method.Name);
2736 frame = e.Thread.GetFrames () [0];
2740 public void Exceptions () {
2741 Event e = run_until ("exceptions");
2742 var req = vm.CreateExceptionRequest (null);
2747 e = GetNextEvent ();
2748 Assert.IsInstanceOfType (typeof (ExceptionEvent), e);
2749 Assert.AreEqual ("OverflowException", (e as ExceptionEvent).Exception.Type.Name);
2751 var frames = e.Thread.GetFrames ();
2752 Assert.AreEqual ("exceptions", frames [0].Method.Name);
2755 // exception type filter
2757 req = vm.CreateExceptionRequest (vm.RootDomain.Corlib.GetType ("System.ArgumentException"));
2760 // Skip the throwing of the second OverflowException
2763 e = GetNextEvent ();
2764 Assert.IsInstanceOfType (typeof (ExceptionEvent), e);
2765 Assert.AreEqual ("ArgumentException", (e as ExceptionEvent).Exception.Type.Name);
2768 // exception type filter for subclasses
2769 req = vm.CreateExceptionRequest (vm.RootDomain.Corlib.GetType ("System.Exception"));
2774 e = GetNextEvent ();
2775 Assert.IsInstanceOfType (typeof (ExceptionEvent), e);
2776 Assert.AreEqual ("OverflowException", (e as ExceptionEvent).Exception.Type.Name);
2780 req.IncludeSubclasses = false;
2785 e = GetNextEvent ();
2786 Assert.IsInstanceOfType (typeof (ExceptionEvent), e);
2787 Assert.AreEqual ("Exception", (e as ExceptionEvent).Exception.Type.Name);
2790 // Implicit exceptions
2791 req = vm.CreateExceptionRequest (null);
2796 e = GetNextEvent ();
2797 Assert.IsInstanceOfType (typeof (ExceptionEvent), e);
2798 Assert.AreEqual ("NullReferenceException", (e as ExceptionEvent).Exception.Type.Name);
2801 // Single stepping after an exception
2802 req = vm.CreateExceptionRequest (null);
2807 e = GetNextEvent ();
2808 Assert.IsInstanceOfType (typeof (ExceptionEvent), e);
2809 Assert.AreEqual ("Exception", (e as ExceptionEvent).Exception.Type.Name);
2810 frames = e.Thread.GetFrames ();
2811 Assert.AreEqual ("exceptions2", frames [0].Method.Name);
2814 var sreq = create_step (e);
2815 sreq.Depth = StepDepth.Over;
2816 sreq.Size = StepSize.Line;
2820 e = GetNextEvent ();
2821 Assert.IsInstanceOfType (typeof (StepEvent), e);
2822 frames = e.Thread.GetFrames ();
2823 Assert.AreEqual ("exceptions", frames [0].Method.Name);
2826 // Argument checking
2827 AssertThrows<ArgumentException> (delegate {
2828 vm.CreateExceptionRequest (e.Thread.Type);
2833 public void ExceptionFilter () {
2834 Event e = run_until ("exception_filter");
2836 MethodMirror m = entry_point.DeclaringType.GetMethod ("exception_filter_filter");
2837 Assert.IsNotNull (m);
2839 vm.SetBreakpoint (m, 0);
2843 e = GetNextEvent ();
2844 Assert.AreEqual (EventType.Breakpoint, e.EventType);
2845 Assert.IsTrue (e is BreakpointEvent);
2846 Assert.AreEqual (m.Name, (e as BreakpointEvent).Method.Name);
2848 var frames = e.Thread.GetFrames ();
2850 Assert.IsTrue (frames [0].Location.SourceFile.IndexOf ("dtest-app.cs") != -1);
2851 Assert.AreEqual ("exception_filter_filter", frames [0].Location.Method.Name);
2853 Assert.AreEqual (0, frames [1].Location.Method.MetadataToken);
2854 Assert.AreEqual (0x0f, frames [1].Location.ILOffset);
2856 Assert.AreEqual ("exception_filter_method", frames [2].Location.Method.Name);
2857 Assert.AreEqual (0x06, frames [2].Location.ILOffset);
2859 Assert.AreEqual (0, frames [3].Location.Method.MetadataToken, 0);
2860 Assert.AreEqual (0, frames [3].Location.ILOffset);
2862 Assert.AreEqual ("exception_filter", frames [4].Location.Method.Name);
2866 public void ExceptionFilter2 () {
2869 Start (new string [] { "dtest-excfilter.exe" });
2871 MethodMirror filter_method = entry_point.DeclaringType.GetMethod ("Filter");
2872 Assert.IsNotNull (filter_method);
2874 MethodMirror test_method = entry_point.DeclaringType.GetMethod ("Test");
2875 Assert.IsNotNull (test_method);
2877 vm.SetBreakpoint (filter_method, 0);
2881 var e = GetNextEvent ();
2882 Assert.AreEqual (EventType.Breakpoint, e.EventType);
2883 Assert.IsTrue (e is BreakpointEvent);
2884 Assert.AreEqual (filter_method.Name, (e as BreakpointEvent).Method.Name);
2886 var frames = e.Thread.GetFrames ();
2888 Assert.AreEqual (4, frames.Count ());
2890 Assert.AreEqual (filter_method.Name, frames [0].Location.Method.Name);
2891 Assert.AreEqual (20, frames [0].Location.LineNumber);
2892 Assert.AreEqual (0, frames [0].Location.ILOffset);
2894 Assert.AreEqual (test_method.Name, frames [1].Location.Method.Name);
2895 Assert.AreEqual (37, frames [1].Location.LineNumber);
2896 Assert.AreEqual (0x0b, frames [1].Location.ILOffset);
2898 Assert.AreEqual (test_method.Name, frames [2].Location.Method.Name);
2899 Assert.AreEqual (33, frames [2].Location.LineNumber);
2900 Assert.AreEqual (0x05, frames [2].Location.ILOffset);
2902 Assert.AreEqual (entry_point.Name, frames [3].Location.Method.Name);
2903 Assert.AreEqual (14, frames [3].Location.LineNumber);
2904 Assert.AreEqual (0x00, frames [3].Location.ILOffset);
2912 public void EventSets () {
2914 // Create two filter which both match the same exception
2916 Event e = run_until ("exceptions");
2918 var req = vm.CreateExceptionRequest (null);
2921 var req2 = vm.CreateExceptionRequest (vm.RootDomain.Corlib.GetType ("System.OverflowException"));
2926 var es = vm.GetNextEventSet ();
2927 Assert.AreEqual (2, es.Events.Length);
2930 Assert.IsInstanceOfType (typeof (ExceptionEvent), e);
2931 Assert.AreEqual ("OverflowException", (e as ExceptionEvent).Exception.Type.Name);
2934 Assert.IsInstanceOfType (typeof (ExceptionEvent), e);
2935 Assert.AreEqual ("OverflowException", (e as ExceptionEvent).Exception.Type.Name);
2942 // Test single threaded invokes during processing of nullref exceptions.
2943 // These won't work if the exception handling is done from the sigsegv signal
2944 // handler, since the sigsegv signal is disabled until control returns from the
2948 [Category ("only3")]
2949 public void NullRefExceptionAndSingleThreadedInvoke () {
2950 Event e = run_until ("exceptions");
2951 var req = vm.CreateExceptionRequest (vm.RootDomain.Corlib.GetType ("System.NullReferenceException"));
2956 e = GetNextEvent ();
2957 Assert.IsInstanceOfType (typeof (ExceptionEvent), e);
2958 Assert.AreEqual ("NullReferenceException", (e as ExceptionEvent).Exception.Type.Name);
2960 var ex = (e as ExceptionEvent).Exception;
2961 var tostring_method = vm.RootDomain.Corlib.GetType ("System.Object").GetMethod ("ToString");
2962 ex.InvokeMethod (e.Thread, tostring_method, null, InvokeOptions.SingleThreaded);
2966 public void Domains () {
2969 Start (new string [] { "dtest-app.exe", "domain-test" });
2971 vm.EnableEvents (EventType.AppDomainCreate, EventType.AppDomainUnload, EventType.AssemblyUnload);
2973 Event e = run_until ("domains");
2977 e = GetNextEvent ();
2978 Assert.IsInstanceOfType (typeof (AppDomainCreateEvent), e);
2980 var domain = (e as AppDomainCreateEvent).Domain;
2982 // Check the object type
2983 e = run_until ("domains_2");
2984 var frame = e.Thread.GetFrames ()[0];
2985 var o = frame.GetArgument (0) as ObjectMirror;
2986 Assert.AreEqual ("CrossDomain", o.Type.Name);
2988 // Do a remoting invoke
2989 var cross_domain_type = o.Type;
2990 var v = o.InvokeMethod (e.Thread, cross_domain_type.GetMethod ("invoke_3"), null);
2991 AssertValue (42, v);
2993 // Run until the callback in the domain
2994 MethodMirror m = entry_point.DeclaringType.GetMethod ("invoke_in_domain");
2995 Assert.IsNotNull (m);
2996 vm.SetBreakpoint (m, 0);
3000 e = GetNextEvent ();
3001 if (e is BreakpointEvent)
3005 Assert.AreEqual ("invoke_in_domain", (e as BreakpointEvent).Method.Name);
3007 // d_method is from another domain
3008 MethodMirror d_method = (e as BreakpointEvent).Method;
3009 Assert.IsTrue (m != d_method);
3011 var frames = e.Thread.GetFrames ();
3012 Assert.AreEqual ("invoke_in_domain", frames [0].Method.Name);
3013 Assert.AreEqual (domain, frames [0].Domain);
3014 Assert.AreEqual ("invoke", frames [1].Method.Name);
3015 Assert.AreEqual ("domains", frames [2].Method.Name);
3016 Assert.AreEqual (vm.RootDomain, frames [2].Domain);
3018 // Test breakpoints on already JITted methods in other domains
3019 m = entry_point.DeclaringType.GetMethod ("invoke_in_domain_2");
3020 Assert.IsNotNull (m);
3021 vm.SetBreakpoint (m, 0);
3025 e = GetNextEvent ();
3026 if (e is BreakpointEvent)
3030 Assert.AreEqual ("invoke_in_domain_2", (e as BreakpointEvent).Method.Name);
3032 // This is empty when receiving the AppDomainCreateEvent
3033 Assert.AreEqual ("domain", domain.FriendlyName);
3035 // Run until the unload
3038 e = GetNextEvent ();
3039 if (e is AssemblyUnloadEvent) {
3045 Assert.IsInstanceOfType (typeof (AppDomainUnloadEvent), e);
3046 Assert.AreEqual (domain, (e as AppDomainUnloadEvent).Domain);
3048 // Run past the unload
3049 e = run_until ("domains_3");
3051 // Test access to unloaded types
3052 // FIXME: Add an exception type for this
3053 AssertThrows<Exception> (delegate {
3054 d_method.DeclaringType.GetValue (d_method.DeclaringType.GetField ("static_i"));
3057 // Check that .Domain is accessible for stack frames with native transitions
3058 e = run_until ("called_from_invoke");
3059 ThreadMirror.NativeTransitions = true;
3060 foreach (var f in e.Thread.GetFrames ()) {
3066 public void DynamicMethods () {
3067 Event e = run_until ("dyn_call");
3069 var m = e.Thread.GetFrames ()[1].Method;
3070 Assert.AreEqual ("dyn_method", m.Name);
3072 // Test access to IL
3073 var body = m.GetMethodBody ();
3075 ILInstruction ins = body.Instructions [0];
3076 Assert.AreEqual (OpCodes.Ldstr, ins.OpCode);
3077 Assert.AreEqual ("FOO", ins.Operand);
3081 public void RefEmit () {
3084 Start (new string [] { "dtest-app.exe", "ref-emit-test" });
3086 Event e = run_until ("ref_emit_call");
3088 var m = e.Thread.GetFrames ()[1].Method;
3089 Assert.AreEqual ("ref_emit_method", m.Name);
3091 // Test access to IL
3092 var body = m.GetMethodBody ();
3096 ins = body.Instructions [0];
3097 Assert.AreEqual (OpCodes.Ldstr, ins.OpCode);
3098 Assert.AreEqual ("FOO", ins.Operand);
3100 ins = body.Instructions [1];
3101 Assert.AreEqual (OpCodes.Call, ins.OpCode);
3102 Assert.IsInstanceOfType (typeof (MethodMirror), ins.Operand);
3103 Assert.AreEqual ("ref_emit_call", (ins.Operand as MethodMirror).Name);
3107 public void IsAttached () {
3108 var f = entry_point.DeclaringType.GetField ("is_attached");
3110 Event e = run_until ("Main");
3112 AssertValue (true, entry_point.DeclaringType.GetValue (f));
3116 public void StackTraceInNative () {
3117 // Check that stack traces can be produced for threads in native code
3120 Start (new string [] { "dtest-app.exe", "frames-in-native" });
3122 var e = run_until ("frames_in_native");
3124 // FIXME: This is racy
3131 StackFrame[] frames = e.Thread.GetFrames ();
3133 int frame_index = -1;
3134 for (int i = 0; i < frames.Length; ++i) {
3135 if (frames [i].Method.Name == "Sleep") {
3141 Assert.IsTrue (frame_index != -1);
3142 Assert.AreEqual ("Sleep", frames [frame_index].Method.Name);
3143 Assert.AreEqual ("frames_in_native", frames [frame_index + 1].Method.Name);
3144 Assert.AreEqual ("Main", frames [frame_index + 2].Method.Name);
3146 // Check that invokes are disabled for such threads
3147 TypeMirror t = frames [frame_index + 1].Method.DeclaringType;
3149 var m = t.GetMethod ("invoke_static_return_void");
3150 AssertThrows<InvalidOperationException> (delegate {
3151 t.InvokeMethod (e.Thread, m, null);
3154 // Check that the frame info is invalidated
3155 run_until ("frames_in_native_2");
3157 AssertThrows<InvalidStackFrameException> (delegate {
3158 Console.WriteLine (frames [frame_index].GetThis ());
3163 public void VirtualMachine_CreateEnumMirror () {
3164 var e = run_until ("o1");
3165 var frame = e.Thread.GetFrames () [0];
3167 object val = frame.GetThis ();
3168 Assert.IsTrue (val is ObjectMirror);
3169 Assert.AreEqual ("Tests", (val as ObjectMirror).Type.Name);
3170 ObjectMirror o = (val as ObjectMirror);
3172 FieldInfoMirror field = o.Type.GetField ("field_enum");
3173 Value f = o.GetValue (field);
3174 TypeMirror enumType = (f as EnumMirror).Type;
3176 o.SetValue (field, vm.CreateEnumMirror (enumType, vm.CreateValue (1)));
3177 f = o.GetValue (field);
3178 Assert.AreEqual (1, (f as EnumMirror).Value);
3180 // Argument checking
3181 AssertThrows<ArgumentNullException> (delegate () {
3182 vm.CreateEnumMirror (enumType, null);
3185 AssertThrows<ArgumentNullException> (delegate () {
3186 vm.CreateEnumMirror (null, vm.CreateValue (1));
3190 AssertThrows<ArgumentException> (delegate () {
3191 vm.CreateEnumMirror (enumType, vm.CreateValue (null));
3194 // value of a wrong type
3195 AssertThrows<ArgumentException> (delegate () {
3196 vm.CreateEnumMirror (enumType, vm.CreateValue ((long)1));
3201 public void VirtualMachine_EnableEvents_Breakpoint () {
3202 AssertThrows<ArgumentException> (delegate () {
3203 vm.EnableEvents (EventType.Breakpoint);
3208 public void SingleStepRegress654694 () {
3211 MethodMirror m = entry_point.DeclaringType.GetMethod ("ss_regress_654694");
3212 foreach (Location l in m.Locations) {
3213 if (l.ILOffset > 0 && il_offset == -1)
3214 il_offset = l.ILOffset;
3217 Event e = run_until ("ss_regress_654694");
3219 Assert.IsNotNull (m);
3220 vm.SetBreakpoint (m, il_offset);
3224 e = GetNextEvent ();
3225 Assert.IsTrue (e is BreakpointEvent);
3227 var req = create_step (e);
3228 req.Depth = StepDepth.Over;
3229 req.Size = StepSize.Line;
3234 e = GetNextEvent ();
3235 Assert.IsTrue (e is StepEvent);
3241 public void DebugBreak () {
3242 vm.EnableEvents (EventType.UserBreak);
3247 var e = GetNextEvent ();
3248 Assert.IsTrue (e is UserBreakEvent);
3252 public void DebugLog () {
3253 vm.EnableEvents (EventType.UserLog);
3258 var e = GetNextEvent ();
3259 Assert.IsTrue (e is UserLogEvent);
3260 var le = e as UserLogEvent;
3262 Assert.AreEqual (5, le.Level);
3263 Assert.AreEqual ("A", le.Category);
3264 Assert.AreEqual ("B", le.Message);
3268 public void TypeGetMethodsByNameFlags () {
3270 var assembly = entry_point.DeclaringType.Assembly;
3271 var type = assembly.GetType ("Tests3");
3273 Assert.IsNotNull (type);
3275 mm = type.GetMethodsByNameFlags (null, BindingFlags.Static | BindingFlags.Public, false);
3276 Assert.AreEqual (1, mm.Length, "#1");
3277 Assert.AreEqual ("M1", mm[0].Name, "#2");
3279 mm = type.GetMethodsByNameFlags (null, BindingFlags.Static | BindingFlags.NonPublic, false);
3280 Assert.AreEqual (1, mm.Length, "#3");
3281 Assert.AreEqual ("M2", mm[0].Name, "#4");
3283 mm = type.GetMethodsByNameFlags (null, BindingFlags.Instance | BindingFlags.Public, false);
3284 Assert.AreEqual (7, mm.Length, "#5"); //M3 plus Equals, GetHashCode, GetType, ToString, .ctor
3286 mm = type.GetMethodsByNameFlags (null, BindingFlags.Instance | BindingFlags.Public | BindingFlags.DeclaredOnly, false);
3287 Assert.AreEqual (2, mm.Length, "#7");
3289 mm = type.GetMethodsByNameFlags (null, BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.DeclaredOnly, false);
3290 Assert.AreEqual (1, mm.Length, "#9");
3292 mm = type.GetMethodsByNameFlags (null, BindingFlags.Static | BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.DeclaredOnly, false);
3293 Assert.AreEqual (5, mm.Length, "#11");
3296 mm = type.GetMethodsByNameFlags ("M1", BindingFlags.Static | BindingFlags.Public, false);
3297 Assert.AreEqual (1, mm.Length, "#12");
3298 Assert.AreEqual ("M1", mm[0].Name, "#13");
3300 mm = type.GetMethodsByNameFlags ("m1", BindingFlags.Static | BindingFlags.Public, true);
3301 Assert.AreEqual (1, mm.Length, "#14");
3302 Assert.AreEqual ("M1", mm[0].Name, "#15");
3304 mm = type.GetMethodsByNameFlags ("M1", BindingFlags.Static | BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic, false);
3305 Assert.AreEqual (1, mm.Length, "#16");
3306 Assert.AreEqual ("M1", mm[0].Name, "#17");
3310 [Category ("only88")]
3311 public void TypeLoadSourceFileFilter () {
3312 Event e = run_until ("type_load");
3314 if (!vm.Version.AtLeast (2, 7))
3317 string srcfile = (e as BreakpointEvent).Method.DeclaringType.GetSourceFiles (true)[0];
3319 var req = vm.CreateTypeLoadRequest ();
3320 req.SourceFileFilter = new string [] { srcfile.ToUpper () };
3324 e = GetNextEvent ();
3325 Assert.IsTrue (e is TypeLoadEvent);
3326 Assert.AreEqual ("TypeLoadClass", (e as TypeLoadEvent).Type.FullName);
3330 public void TypeLoadTypeNameFilter () {
3331 Event e = run_until ("type_load");
3333 var req = vm.CreateTypeLoadRequest ();
3334 req.TypeNameFilter = new string [] { "TypeLoadClass2" };
3338 e = GetNextEvent ();
3339 Assert.IsTrue (e is TypeLoadEvent);
3340 Assert.AreEqual ("TypeLoadClass2", (e as TypeLoadEvent).Type.FullName);
3344 public void GetTypesForSourceFile () {
3347 var types = vm.GetTypesForSourceFile ("dtest-app.cs", false);
3348 Assert.IsTrue (types.Any (t => t.FullName == "Tests"));
3349 Assert.IsFalse (types.Any (t => t.FullName == "System.Int32"));
3351 types = vm.GetTypesForSourceFile ("DTEST-app.cs", true);
3352 Assert.IsTrue (types.Any (t => t.FullName == "Tests"));
3353 Assert.IsFalse (types.Any (t => t.FullName == "System.Int32"));
3357 public void GetTypesNamed () {
3360 var types = vm.GetTypes ("Tests", false);
3361 Assert.AreEqual (1, types.Count);
3362 Assert.AreEqual ("Tests", types [0].FullName);
3364 types = vm.GetTypes ("System.Exception", false);
3365 Assert.AreEqual (1, types.Count);
3366 Assert.AreEqual ("System.Exception", types [0].FullName);
3370 public void String_GetValue () {
3375 var e = run_until ("arg2");
3377 var frame = e.Thread.GetFrames () [0];
3379 val = frame.GetArgument (6);
3380 Assert.AreEqual ('\0'.ToString () + "A", (val as StringMirror).Value);
3384 public void String_GetChars () {
3388 var e = run_until ("arg2");
3390 var frame = e.Thread.GetFrames () [0];
3392 val = frame.GetArgument (0);
3393 Assert.IsTrue (val is StringMirror);
3394 AssertValue ("FOO", val);
3395 var s = (val as StringMirror);
3396 Assert.AreEqual (3, s.Length);
3398 var c = s.GetChars (0, 2);
3399 Assert.AreEqual (2, c.Length);
3400 Assert.AreEqual ('F', c [0]);
3401 Assert.AreEqual ('O', c [1]);
3403 AssertThrows<ArgumentException> (delegate () {
3409 public void GetInterfaces () {
3410 var e = run_until ("arg2");
3412 var frame = e.Thread.GetFrames () [0];
3414 var cl1 = frame.Method.DeclaringType.Assembly.GetType ("TestIfaces");
3415 var ifaces = cl1.GetInterfaces ();
3416 Assert.AreEqual (1, ifaces.Length);
3417 Assert.AreEqual ("ITest", ifaces [0].Name);
3419 var cl2 = cl1.GetMethod ("Baz").ReturnType;
3420 var ifaces2 = cl2.GetInterfaces ();
3421 Assert.AreEqual (1, ifaces2.Length);
3422 Assert.AreEqual ("ITest`1", ifaces2 [0].Name);
3426 public void GetInterfaceMap () {
3427 var e = run_until ("arg2");
3429 var frame = e.Thread.GetFrames () [0];
3431 var cl1 = frame.Method.DeclaringType.Assembly.GetType ("TestIfaces");
3432 var iface = cl1.Assembly.GetType ("ITest");
3433 var map = cl1.GetInterfaceMap (iface);
3434 Assert.AreEqual (cl1, map.TargetType);
3435 Assert.AreEqual (iface, map.InterfaceType);
3436 Assert.AreEqual (2, map.InterfaceMethods.Length);
3437 Assert.AreEqual (2, map.TargetMethods.Length);
3441 public void StackAlloc_Breakpoints_Regress2775 () {
3442 // Check that breakpoints on arm don't overwrite stackalloc-ed memory
3443 var e = run_until ("regress_2755");
3445 var frame = e.Thread.GetFrames () [0];
3447 // This breaks at the call site
3448 vm.SetBreakpoint (m, m.Locations [2].ILOffset);
3451 var e2 = GetNextEvent ();
3452 Assert.IsTrue (e2 is BreakpointEvent);
3454 e = run_until ("regress_2755_3");
3455 frame = e.Thread.GetFrames () [1];
3456 var res = frame.GetValue (m.GetLocal ("sum"));
3457 AssertValue (0, res);
3461 public void MethodInfo () {
3462 Event e = run_until ("locals2");
3464 StackFrame frame = e.Thread.GetFrames () [0];
3465 var m = frame.Method;
3467 Assert.IsTrue (m.IsGenericMethod);
3468 Assert.IsFalse (m.IsGenericMethodDefinition);
3470 var args = m.GetGenericArguments ();
3471 Assert.AreEqual (1, args.Length);
3472 Assert.AreEqual ("String", args [0].Name);
3474 var gmd = m.GetGenericMethodDefinition ();
3475 Assert.IsTrue (gmd.IsGenericMethod);
3476 Assert.IsTrue (gmd.IsGenericMethodDefinition);
3477 Assert.AreEqual (gmd, gmd.GetGenericMethodDefinition ());
3479 args = gmd.GetGenericArguments ();
3480 Assert.AreEqual (1, args.Length);
3481 Assert.AreEqual ("T", args [0].Name);
3483 var attrs = m.GetCustomAttributes (true);
3484 Assert.AreEqual (1, attrs.Length);
3485 Assert.AreEqual ("StateMachineAttribute", attrs [0].Constructor.DeclaringType.Name);
3489 public void UnhandledException () {
3492 Start (new string [] { "dtest-app.exe", "unhandled-exception" });
3494 var req = vm.CreateExceptionRequest (null, false, true);
3497 var e = run_until ("unhandled_exception");
3500 var e2 = GetNextEvent ();
3501 Assert.IsTrue (e2 is ExceptionEvent);
3508 public void UnhandledException_2 () {
3511 Start (new string [] { "dtest-app.exe", "unhandled-exception-endinvoke" });
3513 var req = vm.CreateExceptionRequest (null, false, true);
3516 MethodMirror m = entry_point.DeclaringType.GetMethod ("unhandled_exception_endinvoke_2");
3517 Assert.IsNotNull (m);
3518 vm.SetBreakpoint (m, m.ILOffsets [0]);
3520 var e = run_until ("unhandled_exception_endinvoke");
3523 var e2 = GetNextEvent ();
3524 Assert.IsFalse (e2 is ExceptionEvent);
3532 public void UnhandledExceptionUserCode () {
3535 // Exceptions caught in non-user code are treated as unhandled
3536 Start (new string [] { "dtest-app.exe", "unhandled-exception-user" });
3538 var req = vm.CreateExceptionRequest (null, false, true);
3539 req.AssemblyFilter = new List<AssemblyMirror> () { entry_point.DeclaringType.Assembly };
3542 var e = run_until ("unhandled_exception_user");
3545 var e2 = GetNextEvent ();
3546 Assert.IsTrue (e2 is ExceptionEvent);
3554 public void GCWhileSuspended () {
3555 // Check that objects are kept alive during suspensions
3556 Event e = run_until ("gc_suspend_1");
3558 MethodMirror m = entry_point.DeclaringType.GetMethod ("gc_suspend_invoke");
3560 var o = entry_point.DeclaringType.GetValue (entry_point.DeclaringType.GetField ("gc_suspend_field")) as ObjectMirror;
3561 //Console.WriteLine (o);
3563 StackFrame frame = e.Thread.GetFrames () [0];
3564 TypeMirror t = frame.Method.DeclaringType;
3565 for (int i = 0; i < 10; ++i)
3566 t.InvokeMethod (e.Thread, m, new Value [] { });
3568 // This throws an exception if the object is collected
3569 long addr = o.Address;
3571 var o2 = entry_point.DeclaringType.GetValue (entry_point.DeclaringType.GetField ("gc_suspend_field")) as ObjectMirror;
3576 public void MakeGenericMethod () {
3577 Event e = run_until ("bp1");
3579 var intm = vm.RootDomain.GetCorrespondingType (typeof (int));
3580 var stringm = vm.RootDomain.GetCorrespondingType (typeof (string));
3581 var gm = entry_point.DeclaringType.GetMethod ("generic_method");
3582 var res = gm.MakeGenericMethod (new TypeMirror [] { stringm });
3583 var args = res.GetGenericArguments ();
3584 Assert.AreEqual (1, args.Length);
3585 Assert.AreEqual (stringm, args [0]);
3588 AssertThrows<ArgumentNullException> (delegate {
3589 gm.MakeGenericMethod (null);
3591 AssertThrows<ArgumentNullException> (delegate {
3592 gm.MakeGenericMethod (new TypeMirror [] { null });
3594 AssertThrows<ArgumentException> (delegate {
3595 gm.MakeGenericMethod (new TypeMirror [] { stringm, stringm });
3597 AssertThrows<InvalidOperationException> (delegate {
3598 gm.MakeGenericMethod (new TypeMirror [] { intm });
3600 AssertThrows<InvalidOperationException> (delegate {
3601 entry_point.DeclaringType.GetMethod ("Main").MakeGenericMethod (new TypeMirror [] { intm });
3606 public void InspectThreadSuspenedOnWaitOne () {
3608 Start (true, "dtest-app.exe", "wait-one" );
3610 ThreadMirror.NativeTransitions = true;
3612 var evt = run_until ("wait_one");
3613 Assert.IsNotNull (evt, "#1");
3615 var thread = evt.Thread;
3616 Assert.AreEqual (ThreadState.Running, thread.ThreadState, "#1.1");
3618 var frames = thread.GetFrames ();
3619 Assert.IsNotNull (frames, "#2");
3620 Assert.AreEqual (2, frames.Length, "#3");
3621 Assert.AreEqual ("wait_one", frames [0].Method.Name, "#4");
3622 Assert.AreEqual ("Main", frames [1].Method.Name, "#5");
3626 Thread.Sleep (500); //FIXME this is racy, maybe single step? or something?
3629 Assert.AreEqual (ThreadState.WaitSleepJoin, thread.ThreadState, "#6");
3631 frames = thread.GetFrames ();
3632 Assert.AreEqual (4, frames.Length, "#7");
3633 Assert.AreEqual ("WaitOne_internal", frames [0].Method.Name, "#8");
3634 Assert.AreEqual ("WaitOne", frames [1].Method.Name, "#8.1");
3635 Assert.AreEqual ("wait_one", frames [2].Method.Name, "#9");
3636 Assert.AreEqual ("Main", frames [3].Method.Name, "#10");
3639 var frame = frames [0];
3640 Assert.IsTrue (frame.IsNativeTransition, "#11.1");
3643 Assert.Fail ("Known limitation - can't get info from m2n frames");
3644 } catch (AbsentInformationException) {}
3647 Assert.IsFalse (frame.IsNativeTransition, "#12.1");
3648 var wait_one_this = frame.GetThis ();
3649 Assert.IsNotNull (wait_one_this, "#12.2");
3652 var locals = frame.GetVisibleVariables ();
3653 Assert.AreEqual (1, locals.Count, "#13.1");
3655 var local_0 = frame.GetValue (locals [0]);
3656 Assert.IsNotNull (local_0, "#13.2");
3658 Assert.AreEqual (wait_one_this, local_0, "#14.2");
3662 public void GetMethodBody () {
3663 var bevent = run_until ("Main");
3665 var m = bevent.Method.DeclaringType.GetMethod ("get_IntProperty");
3666 var body = m.GetMethodBody ();
3667 foreach (var ins in body.Instructions) {
3668 if (ins.OpCode == OpCodes.Ldfld) {
3669 var field = (FieldInfoMirror)ins.Operand;
3670 Assert.AreEqual ("field_i", field.Name);
3676 public void EvaluateMethod () {
3677 var bevent = run_until ("evaluate_method_2");
3679 var m = bevent.Method.DeclaringType.GetMethod ("get_IntProperty");
3681 var this_obj = bevent.Thread.GetFrames ()[0].GetThis ();
3682 var v = m.Evaluate (this_obj, null);
3683 AssertValue (42, v);
3687 public void SetIP () {
3688 var bevent = run_until ("set_ip_1");
3690 var invalid_loc = bevent.Thread.GetFrames ()[0].Location;
3692 var req = create_step (bevent);
3693 var e = step_out ();
3695 var frames = e.Thread.GetFrames ();
3696 var locs = frames [0].Method.Locations;
3697 var next_loc = locs.First (l => (l.LineNumber == frames [0].Location.LineNumber + 2));
3699 e.Thread.SetIP (next_loc);
3701 /* Check that i ++; j = 5; was skipped */
3702 bevent = run_until ("set_ip_2");
3703 var f = bevent.Thread.GetFrames ()[1];
3704 AssertValue (2, f.GetValue (f.Method.GetLocal ("i")));
3705 AssertValue (0, f.GetValue (f.Method.GetLocal ("j")));
3708 AssertThrows<ArgumentNullException> (delegate {
3709 e.Thread.SetIP (null);
3712 AssertThrows<ArgumentException> (delegate {
3713 e.Thread.SetIP (invalid_loc);
3718 public void SetIPSingleStep () {
3719 // Check that single stepping after set-ip steps from the new ip
3720 var bevent = run_until ("set_ip_1");
3722 var invalid_loc = bevent.Thread.GetFrames ()[0].Location;
3724 var req = create_step (bevent);
3725 req.Size = StepSize.Line;
3726 var e = step_out ();
3728 var frames = e.Thread.GetFrames ();
3729 var locs = frames [0].Method.Locations;
3730 var prev_loc = locs.First (l => (l.LineNumber == frames [0].Location.LineNumber - 3));
3731 AssertValue (2, frames [0].GetValue (frames [0].Method.GetLocal ("i")));
3733 // Set back the ip to the first i ++; line
3734 e.Thread.SetIP (prev_loc);
3737 var f = e.Thread.GetFrames ()[0];
3738 AssertValue (3, f.GetValue (f.Method.GetLocal ("i")));
3742 public void NewInstanceNoCtor () {
3743 var bevent = run_until ("Main");
3745 var stype = bevent.Method.DeclaringType.Assembly.GetType ("AStruct");
3746 var obj = stype.NewInstance ();
3747 Assert.IsTrue (obj is ObjectMirror);
3748 Assert.AreEqual ("AStruct", (obj as ObjectMirror).Type.Name);
3752 public void StaticCtorFilterInCctor () {
3753 // Check that single stepping when in a cctor only ignores
3754 // other cctors, not the current one
3755 var bevent = run_until ("step_filters");
3757 var assembly = entry_point.DeclaringType.Assembly;
3758 var type = assembly.GetType ("Tests/ClassWithCctor");
3759 var cctor = type.GetMethod (".cctor");
3760 vm.SetBreakpoint (cctor, 0);
3763 var e = vm.GetNextEvent ();
3764 Assert.IsTrue (e is BreakpointEvent);
3766 var req = create_step (e);
3767 req.Filter = StepFilter.StaticCtor;
3769 // Make sure we are still in the cctor
3770 Assert.AreEqual (".cctor", e.Thread.GetFrames ()[0].Location.Method.Name);