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 struct as this, receive intptr
2290 m = t.GetMethod ("invoke_return_intptr");
2291 v = s.InvokeMethod (e.Thread, m, null);
2292 AssertValue (43, v);
2295 m = t.GetMethod ("invoke_static");
2296 v = t.InvokeMethod (e.Thread, m, null);
2299 // Pass generic struct as this
2300 s = frame.GetArgument (2) as StructMirror;
2302 m = t.GetMethod ("invoke_return_int");
2303 v = s.InvokeMethod (e.Thread, m, null);
2304 AssertValue (42, v);
2307 // Invoke a method which changes state
2308 s = frame.GetArgument (1) as StructMirror;
2310 m = t.GetMethod ("invoke_mutate");
2311 var task = s.InvokeMethodAsyncWithResult (e.Thread, m, null, InvokeOptions.ReturnOutThis);
2312 var out_this = task.Result.OutThis as StructMirror;
2313 AssertValue (5, out_this ["l"]);
2315 // Without the ReturnOutThis flag
2316 s = frame.GetArgument (1) as StructMirror;
2318 m = t.GetMethod ("invoke_mutate");
2319 task = s.InvokeMethodAsyncWithResult (e.Thread, m, null);
2320 out_this = task.Result.OutThis as StructMirror;
2321 Assert.AreEqual (null, out_this);
2324 var cl1 = frame.Method.DeclaringType.Assembly.GetType ("ITest2");
2325 m = cl1.GetMethod ("invoke_iface");
2326 v = s.InvokeMethod (e.Thread, m, null);
2327 AssertValue (42, v);
2330 m = vm.RootDomain.Corlib.GetType ("System.Object").GetMethod ("ToString");
2331 v = s.InvokeMethod (e.Thread, m, null, InvokeOptions.Virtual);
2332 AssertValue ("42", v);
2337 public void BreakpointDuringInvoke () {
2338 Event e = run_until ("invoke1");
2340 MethodMirror m = entry_point.DeclaringType.GetMethod ("invoke2");
2341 Assert.IsNotNull (m);
2342 vm.SetBreakpoint (m, 0);
2344 StackFrame frame = e.Thread.GetFrames () [0];
2345 var o = frame.GetThis () as ObjectMirror;
2347 bool failed = false;
2349 bool finished = false;
2350 object wait = new object ();
2352 // Have to invoke in a separate thread as the invoke is suspended until we
2353 // resume after the breakpoint
2354 Thread t = new Thread (delegate () {
2356 o.InvokeMethod (e.Thread, m, null);
2362 Monitor.Pulse (wait);
2368 StackFrame invoke_frame = null;
2371 e = GetNextEvent ();
2372 Assert.IsInstanceOfType (typeof (BreakpointEvent), e);
2373 // Check stack trace support and invokes
2374 var frames = e.Thread.GetFrames ();
2375 invoke_frame = frames [0];
2376 Assert.AreEqual ("invoke2", frames [0].Method.Name);
2377 Assert.IsTrue (frames [0].IsDebuggerInvoke);
2378 Assert.AreEqual ("invoke1", frames [1].Method.Name);
2385 Monitor.Wait (wait);
2388 // Check that the invoke frames are no longer valid
2389 AssertThrows<InvalidStackFrameException> (delegate {
2390 invoke_frame.GetThis ();
2393 // Check InvokeOptions.DisableBreakpoints flag
2394 o.InvokeMethod (e.Thread, m, null, InvokeOptions.DisableBreakpoints);
2398 public void DisabledExceptionDuringInvoke () {
2399 Event e = run_until ("invoke_ex");
2401 MethodMirror m = entry_point.DeclaringType.GetMethod ("invoke_ex_inner");
2403 StackFrame frame = e.Thread.GetFrames () [0];
2404 var o = frame.GetThis () as ObjectMirror;
2406 var req = vm.CreateExceptionRequest (null);
2409 // Check InvokeOptions.DisableBreakpoints flag
2410 o.InvokeMethod (e.Thread, m, null, InvokeOptions.DisableBreakpoints);
2416 public void InvokeSingleThreaded () {
2419 Start (new string [] { "dtest-app.exe", "invoke-single-threaded" });
2421 Event e = run_until ("invoke_single_threaded_2");
2423 StackFrame f = e.Thread.GetFrames ()[0];
2425 var obj = f.GetThis () as ObjectMirror;
2427 // Check that the counter value incremented by the other thread does not increase
2428 // during the invoke.
2429 object counter1 = (obj.GetValue (obj.Type.GetField ("counter")) as PrimitiveValue).Value;
2431 var m = obj.Type.GetMethod ("invoke_return_void");
2432 obj.InvokeMethod (e.Thread, m, null, InvokeOptions.SingleThreaded);
2434 object counter2 = (obj.GetValue (obj.Type.GetField ("counter")) as PrimitiveValue).Value;
2436 Assert.AreEqual ((int)counter1, (int)counter2);
2438 // Test multiple invokes done in succession
2439 m = obj.Type.GetMethod ("invoke_return_void");
2440 obj.InvokeMethod (e.Thread, m, null, InvokeOptions.SingleThreaded);
2442 // Test events during single-threaded invokes
2443 vm.EnableEvents (EventType.TypeLoad);
2444 m = obj.Type.GetMethod ("invoke_type_load");
2445 obj.BeginInvokeMethod (e.Thread, m, null, InvokeOptions.SingleThreaded, delegate {
2449 e = GetNextEvent ();
2450 Assert.AreEqual (EventType.TypeLoad, e.EventType);
2453 List<Value> invoke_results;
2456 public void InvokeMultiple () {
2457 Event e = run_until ("invoke1");
2459 StackFrame frame = e.Thread.GetFrames () [0];
2461 TypeMirror t = frame.Method.DeclaringType;
2462 ObjectMirror this_obj = (ObjectMirror)frame.GetThis ();
2464 TypeMirror t2 = frame.Method.GetParameters ()[0].ParameterType;
2466 var methods = new MethodMirror [2];
2467 methods [0] = t.GetMethod ("invoke_return_ref");
2468 methods [1] = t.GetMethod ("invoke_return_primitive");
2470 invoke_results = new List<Value> ();
2472 var r = this_obj.BeginInvokeMultiple (e.Thread, methods, null, InvokeOptions.SingleThreaded, invoke_multiple_cb, this_obj);
2473 WaitHandle.WaitAll (new WaitHandle[] { r.AsyncWaitHandle });
2474 this_obj.EndInvokeMultiple (r);
2475 // The callback might still be running
2476 while (invoke_results.Count < 2) {
2479 if (invoke_results [0] is PrimitiveValue) {
2480 AssertValue ("ABC", invoke_results [1]);
2481 AssertValue (42, invoke_results [0]);
2483 AssertValue ("ABC", invoke_results [0]);
2484 AssertValue (42, invoke_results [1]);
2488 void invoke_multiple_cb (IAsyncResult ar) {
2489 ObjectMirror this_obj = (ObjectMirror)ar.AsyncState;
2491 var res = this_obj.EndInvokeMethod (ar);
2492 lock (invoke_results)
2493 invoke_results.Add (res);
2497 public void GetThreads () {
2502 public void Threads () {
2503 Event e = run_until ("threads");
2505 Assert.AreEqual (ThreadState.Running, e.Thread.ThreadState);
2507 Assert.IsTrue (e.Thread.ThreadId > 0);
2509 Assert.AreEqual (e.Thread.TID, e.Thread.TID);
2511 vm.EnableEvents (EventType.ThreadStart, EventType.ThreadDeath);
2515 e = GetNextEvent ();
2516 Assert.IsInstanceOfType (typeof (ThreadStartEvent), e);
2517 var state = e.Thread.ThreadState;
2518 Assert.IsTrue (state == ThreadState.Running || state == ThreadState.Unstarted);
2522 e = GetNextEvent ();
2523 Assert.IsInstanceOfType (typeof (ThreadDeathEvent), e);
2524 Assert.AreEqual (ThreadState.Stopped, e.Thread.ThreadState);
2528 public void Frame_SetValue () {
2529 Event e = run_until ("locals2");
2531 StackFrame frame = e.Thread.GetFrames () [0];
2534 var l = frame.Method.GetLocal ("i");
2535 frame.SetValue (l, vm.CreateValue ((long)55));
2536 AssertValue (55, frame.GetValue (l));
2539 l = frame.Method.GetLocal ("s");
2540 frame.SetValue (l, vm.RootDomain.CreateString ("DEF"));
2541 AssertValue ("DEF", frame.GetValue (l));
2543 // argument as local
2544 l = frame.Method.GetLocal ("arg");
2545 frame.SetValue (l, vm.CreateValue (6));
2546 AssertValue (6, frame.GetValue (l));
2549 var p = frame.Method.GetParameters ()[1];
2550 frame.SetValue (p, vm.CreateValue (7));
2551 AssertValue (7, frame.GetValue (p));
2554 p = frame.Method.GetParameters ()[2];
2555 frame.SetValue (p, vm.RootDomain.CreateString ("DEF"));
2556 AssertValue ("DEF", frame.GetValue (p));
2559 p = frame.Method.GetParameters ()[3];
2560 frame.SetValue (p, vm.RootDomain.CreateString ("DEF2"));
2561 AssertValue ("DEF2", frame.GetValue (p));
2564 p = frame.Method.GetParameters ()[4];
2565 var v = frame.GetValue (p) as StructMirror;
2566 v ["i"] = vm.CreateValue (43);
2567 frame.SetValue (p, v);
2568 v = frame.GetValue (p) as StructMirror;
2569 AssertValue (43, v ["i"]);
2571 // argument checking
2574 AssertThrows<ArgumentNullException> (delegate () {
2575 frame.SetValue ((LocalVariable)null, vm.CreateValue (55));
2579 AssertThrows<ArgumentNullException> (delegate () {
2580 l = frame.Method.GetLocal ("i");
2581 frame.SetValue (l, null);
2584 // value of invalid type
2585 AssertThrows<ArgumentException> (delegate () {
2586 l = frame.Method.GetLocal ("i");
2587 frame.SetValue (l, vm.CreateValue (55));
2593 public void Frame_SetValue_Registers () {
2594 Event e = run_until ("locals6_1");
2596 StackFrame frame = e.Thread.GetFrames () [1];
2599 var l = frame.Method.GetLocal ("j");
2600 frame.SetValue (l, vm.CreateValue (99));
2601 AssertValue (99, frame.GetValue (l));
2603 // Check it during execution
2604 e = run_until ("locals6_2");
2605 frame = e.Thread.GetFrames () [0];
2606 AssertValue (99, frame.GetValue (frame.Method.GetParameters ()[0]));
2608 // Set it while in a frame which clobbers its register
2609 e = run_until ("locals6_3");
2610 frame = e.Thread.GetFrames () [1];
2611 frame.SetValue (l, vm.CreateValue (100));
2612 AssertValue (100, frame.GetValue (l));
2614 // Check it during execution
2615 e = run_until ("locals6_4");
2616 frame = e.Thread.GetFrames () [0];
2617 AssertValue (100, frame.GetValue (frame.Method.GetParameters ()[0]));
2619 // Signed byte value
2620 e = run_until ("locals6_5");
2621 frame = e.Thread.GetFrames () [1];
2622 var l2 = frame.Method.GetLocal ("sb");
2623 frame.SetValue (l2, vm.CreateValue ((sbyte)-99));
2624 AssertValue (-99, frame.GetValue (l2));
2626 // Check it during execution
2627 e = run_until ("locals6_6");
2628 frame = e.Thread.GetFrames () [0];
2629 AssertValue (-99, frame.GetValue (frame.Method.GetParameters ()[0]));
2633 public void InvokeRegress () {
2634 Event e = run_until ("invoke1");
2636 StackFrame frame = e.Thread.GetFrames () [0];
2638 TypeMirror t = frame.Method.DeclaringType;
2639 ObjectMirror this_obj = (ObjectMirror)frame.GetThis ();
2641 TypeMirror t2 = frame.Method.GetParameters ()[0].ParameterType;
2647 m = t.GetMethod ("invoke_return_void");
2648 v = this_obj.InvokeMethod (e.Thread, m, null);
2651 // Check that the stack frames remain valid during the invoke
2652 Assert.AreEqual ("Tests", (frame.GetThis () as ObjectMirror).Type.Name);
2654 // do another invoke
2655 m = t.GetMethod ("invoke_return_void");
2656 v = this_obj.InvokeMethod (e.Thread, m, null);
2659 // Try a single step after the invoke
2660 var req = create_step (e);
2661 req.Depth = StepDepth.Into;
2662 req.Size = StepSize.Line;
2668 // Step into invoke2
2670 e = GetNextEvent ();
2671 Assert.IsTrue (e is StepEvent);
2672 Assert.AreEqual ("invoke2", (e as StepEvent).Method.Name);
2676 frame = e.Thread.GetFrames () [0];
2680 public void Exceptions () {
2681 Event e = run_until ("exceptions");
2682 var req = vm.CreateExceptionRequest (null);
2687 e = GetNextEvent ();
2688 Assert.IsInstanceOfType (typeof (ExceptionEvent), e);
2689 Assert.AreEqual ("OverflowException", (e as ExceptionEvent).Exception.Type.Name);
2691 var frames = e.Thread.GetFrames ();
2692 Assert.AreEqual ("exceptions", frames [0].Method.Name);
2695 // exception type filter
2697 req = vm.CreateExceptionRequest (vm.RootDomain.Corlib.GetType ("System.ArgumentException"));
2700 // Skip the throwing of the second OverflowException
2703 e = GetNextEvent ();
2704 Assert.IsInstanceOfType (typeof (ExceptionEvent), e);
2705 Assert.AreEqual ("ArgumentException", (e as ExceptionEvent).Exception.Type.Name);
2708 // exception type filter for subclasses
2709 req = vm.CreateExceptionRequest (vm.RootDomain.Corlib.GetType ("System.Exception"));
2714 e = GetNextEvent ();
2715 Assert.IsInstanceOfType (typeof (ExceptionEvent), e);
2716 Assert.AreEqual ("OverflowException", (e as ExceptionEvent).Exception.Type.Name);
2720 req.IncludeSubclasses = false;
2725 e = GetNextEvent ();
2726 Assert.IsInstanceOfType (typeof (ExceptionEvent), e);
2727 Assert.AreEqual ("Exception", (e as ExceptionEvent).Exception.Type.Name);
2730 // Implicit exceptions
2731 req = vm.CreateExceptionRequest (null);
2736 e = GetNextEvent ();
2737 Assert.IsInstanceOfType (typeof (ExceptionEvent), e);
2738 Assert.AreEqual ("NullReferenceException", (e as ExceptionEvent).Exception.Type.Name);
2741 // Single stepping after an exception
2742 req = vm.CreateExceptionRequest (null);
2747 e = GetNextEvent ();
2748 Assert.IsInstanceOfType (typeof (ExceptionEvent), e);
2749 Assert.AreEqual ("Exception", (e as ExceptionEvent).Exception.Type.Name);
2750 frames = e.Thread.GetFrames ();
2751 Assert.AreEqual ("exceptions2", frames [0].Method.Name);
2754 var sreq = create_step (e);
2755 sreq.Depth = StepDepth.Over;
2756 sreq.Size = StepSize.Line;
2760 e = GetNextEvent ();
2761 Assert.IsInstanceOfType (typeof (StepEvent), e);
2762 frames = e.Thread.GetFrames ();
2763 Assert.AreEqual ("exceptions", frames [0].Method.Name);
2766 // Argument checking
2767 AssertThrows<ArgumentException> (delegate {
2768 vm.CreateExceptionRequest (e.Thread.Type);
2773 public void ExceptionFilter () {
2774 Event e = run_until ("exception_filter");
2776 MethodMirror m = entry_point.DeclaringType.GetMethod ("exception_filter_filter");
2777 Assert.IsNotNull (m);
2779 vm.SetBreakpoint (m, 0);
2783 e = GetNextEvent ();
2784 Assert.AreEqual (EventType.Breakpoint, e.EventType);
2785 Assert.IsTrue (e is BreakpointEvent);
2786 Assert.AreEqual (m.Name, (e as BreakpointEvent).Method.Name);
2788 var frames = e.Thread.GetFrames ();
2790 Assert.IsTrue (frames [0].Location.SourceFile.IndexOf ("dtest-app.cs") != -1);
2791 Assert.AreEqual ("exception_filter_filter", frames [0].Location.Method.Name);
2793 Assert.AreEqual (0, frames [1].Location.Method.MetadataToken);
2794 Assert.AreEqual (0x0f, frames [1].Location.ILOffset);
2796 Assert.AreEqual ("exception_filter_method", frames [2].Location.Method.Name);
2797 Assert.AreEqual (0x06, frames [2].Location.ILOffset);
2799 Assert.AreEqual (0, frames [3].Location.Method.MetadataToken, 0);
2800 Assert.AreEqual (0, frames [3].Location.ILOffset);
2802 Assert.AreEqual ("exception_filter", frames [4].Location.Method.Name);
2806 public void ExceptionFilter2 () {
2809 Start (new string [] { "dtest-excfilter.exe" });
2811 MethodMirror filter_method = entry_point.DeclaringType.GetMethod ("Filter");
2812 Assert.IsNotNull (filter_method);
2814 MethodMirror test_method = entry_point.DeclaringType.GetMethod ("Test");
2815 Assert.IsNotNull (test_method);
2817 vm.SetBreakpoint (filter_method, 0);
2821 var e = GetNextEvent ();
2822 Assert.AreEqual (EventType.Breakpoint, e.EventType);
2823 Assert.IsTrue (e is BreakpointEvent);
2824 Assert.AreEqual (filter_method.Name, (e as BreakpointEvent).Method.Name);
2826 var frames = e.Thread.GetFrames ();
2828 Assert.AreEqual (4, frames.Count ());
2830 Assert.AreEqual (filter_method.Name, frames [0].Location.Method.Name);
2831 Assert.AreEqual (20, frames [0].Location.LineNumber);
2832 Assert.AreEqual (0, frames [0].Location.ILOffset);
2834 Assert.AreEqual (test_method.Name, frames [1].Location.Method.Name);
2835 Assert.AreEqual (37, frames [1].Location.LineNumber);
2836 Assert.AreEqual (0x0b, frames [1].Location.ILOffset);
2838 Assert.AreEqual (test_method.Name, frames [2].Location.Method.Name);
2839 Assert.AreEqual (33, frames [2].Location.LineNumber);
2840 Assert.AreEqual (0x05, frames [2].Location.ILOffset);
2842 Assert.AreEqual (entry_point.Name, frames [3].Location.Method.Name);
2843 Assert.AreEqual (14, frames [3].Location.LineNumber);
2844 Assert.AreEqual (0x00, frames [3].Location.ILOffset);
2852 public void EventSets () {
2854 // Create two filter which both match the same exception
2856 Event e = run_until ("exceptions");
2858 var req = vm.CreateExceptionRequest (null);
2861 var req2 = vm.CreateExceptionRequest (vm.RootDomain.Corlib.GetType ("System.OverflowException"));
2866 var es = vm.GetNextEventSet ();
2867 Assert.AreEqual (2, es.Events.Length);
2870 Assert.IsInstanceOfType (typeof (ExceptionEvent), e);
2871 Assert.AreEqual ("OverflowException", (e as ExceptionEvent).Exception.Type.Name);
2874 Assert.IsInstanceOfType (typeof (ExceptionEvent), e);
2875 Assert.AreEqual ("OverflowException", (e as ExceptionEvent).Exception.Type.Name);
2882 // Test single threaded invokes during processing of nullref exceptions.
2883 // These won't work if the exception handling is done from the sigsegv signal
2884 // handler, since the sigsegv signal is disabled until control returns from the
2888 [Category ("only3")]
2889 public void NullRefExceptionAndSingleThreadedInvoke () {
2890 Event e = run_until ("exceptions");
2891 var req = vm.CreateExceptionRequest (vm.RootDomain.Corlib.GetType ("System.NullReferenceException"));
2896 e = GetNextEvent ();
2897 Assert.IsInstanceOfType (typeof (ExceptionEvent), e);
2898 Assert.AreEqual ("NullReferenceException", (e as ExceptionEvent).Exception.Type.Name);
2900 var ex = (e as ExceptionEvent).Exception;
2901 var tostring_method = vm.RootDomain.Corlib.GetType ("System.Object").GetMethod ("ToString");
2902 ex.InvokeMethod (e.Thread, tostring_method, null, InvokeOptions.SingleThreaded);
2906 public void Domains () {
2909 Start (new string [] { "dtest-app.exe", "domain-test" });
2911 vm.EnableEvents (EventType.AppDomainCreate, EventType.AppDomainUnload, EventType.AssemblyUnload);
2913 Event e = run_until ("domains");
2917 e = GetNextEvent ();
2918 Assert.IsInstanceOfType (typeof (AppDomainCreateEvent), e);
2920 var domain = (e as AppDomainCreateEvent).Domain;
2922 // Check the object type
2923 e = run_until ("domains_2");
2924 var frame = e.Thread.GetFrames ()[0];
2925 var o = frame.GetArgument (0) as ObjectMirror;
2926 Assert.AreEqual ("CrossDomain", o.Type.Name);
2928 // Do a remoting invoke
2929 var cross_domain_type = o.Type;
2930 var v = o.InvokeMethod (e.Thread, cross_domain_type.GetMethod ("invoke_3"), null);
2931 AssertValue (42, v);
2933 // Run until the callback in the domain
2934 MethodMirror m = entry_point.DeclaringType.GetMethod ("invoke_in_domain");
2935 Assert.IsNotNull (m);
2936 vm.SetBreakpoint (m, 0);
2940 e = GetNextEvent ();
2941 if (e is BreakpointEvent)
2945 Assert.AreEqual ("invoke_in_domain", (e as BreakpointEvent).Method.Name);
2947 // d_method is from another domain
2948 MethodMirror d_method = (e as BreakpointEvent).Method;
2949 Assert.IsTrue (m != d_method);
2951 var frames = e.Thread.GetFrames ();
2952 Assert.AreEqual ("invoke_in_domain", frames [0].Method.Name);
2953 Assert.AreEqual (domain, frames [0].Domain);
2954 Assert.AreEqual ("invoke", frames [1].Method.Name);
2955 Assert.AreEqual ("domains", frames [2].Method.Name);
2956 Assert.AreEqual (vm.RootDomain, frames [2].Domain);
2958 // Test breakpoints on already JITted methods in other domains
2959 m = entry_point.DeclaringType.GetMethod ("invoke_in_domain_2");
2960 Assert.IsNotNull (m);
2961 vm.SetBreakpoint (m, 0);
2965 e = GetNextEvent ();
2966 if (e is BreakpointEvent)
2970 Assert.AreEqual ("invoke_in_domain_2", (e as BreakpointEvent).Method.Name);
2972 // This is empty when receiving the AppDomainCreateEvent
2973 Assert.AreEqual ("domain", domain.FriendlyName);
2975 // Run until the unload
2978 e = GetNextEvent ();
2979 if (e is AssemblyUnloadEvent) {
2985 Assert.IsInstanceOfType (typeof (AppDomainUnloadEvent), e);
2986 Assert.AreEqual (domain, (e as AppDomainUnloadEvent).Domain);
2988 // Run past the unload
2989 e = run_until ("domains_3");
2991 // Test access to unloaded types
2992 // FIXME: Add an exception type for this
2993 AssertThrows<Exception> (delegate {
2994 d_method.DeclaringType.GetValue (d_method.DeclaringType.GetField ("static_i"));
2997 // Check that .Domain is accessible for stack frames with native transitions
2998 e = run_until ("called_from_invoke");
2999 ThreadMirror.NativeTransitions = true;
3000 foreach (var f in e.Thread.GetFrames ()) {
3006 public void DynamicMethods () {
3007 Event e = run_until ("dyn_call");
3009 var m = e.Thread.GetFrames ()[1].Method;
3010 Assert.AreEqual ("dyn_method", m.Name);
3012 // Test access to IL
3013 var body = m.GetMethodBody ();
3015 ILInstruction ins = body.Instructions [0];
3016 Assert.AreEqual (OpCodes.Ldstr, ins.OpCode);
3017 Assert.AreEqual ("FOO", ins.Operand);
3021 public void RefEmit () {
3024 Start (new string [] { "dtest-app.exe", "ref-emit-test" });
3026 Event e = run_until ("ref_emit_call");
3028 var m = e.Thread.GetFrames ()[1].Method;
3029 Assert.AreEqual ("ref_emit_method", m.Name);
3031 // Test access to IL
3032 var body = m.GetMethodBody ();
3036 ins = body.Instructions [0];
3037 Assert.AreEqual (OpCodes.Ldstr, ins.OpCode);
3038 Assert.AreEqual ("FOO", ins.Operand);
3040 ins = body.Instructions [1];
3041 Assert.AreEqual (OpCodes.Call, ins.OpCode);
3042 Assert.IsInstanceOfType (typeof (MethodMirror), ins.Operand);
3043 Assert.AreEqual ("ref_emit_call", (ins.Operand as MethodMirror).Name);
3047 public void IsAttached () {
3048 var f = entry_point.DeclaringType.GetField ("is_attached");
3050 Event e = run_until ("Main");
3052 AssertValue (true, entry_point.DeclaringType.GetValue (f));
3056 public void StackTraceInNative () {
3057 // Check that stack traces can be produced for threads in native code
3060 Start (new string [] { "dtest-app.exe", "frames-in-native" });
3062 var e = run_until ("frames_in_native");
3064 // FIXME: This is racy
3071 StackFrame[] frames = e.Thread.GetFrames ();
3073 int frame_index = -1;
3074 for (int i = 0; i < frames.Length; ++i) {
3075 if (frames [i].Method.Name == "Sleep") {
3081 Assert.IsTrue (frame_index != -1);
3082 Assert.AreEqual ("Sleep", frames [frame_index].Method.Name);
3083 Assert.AreEqual ("frames_in_native", frames [frame_index + 1].Method.Name);
3084 Assert.AreEqual ("Main", frames [frame_index + 2].Method.Name);
3086 // Check that invokes are disabled for such threads
3087 TypeMirror t = frames [frame_index + 1].Method.DeclaringType;
3089 var m = t.GetMethod ("invoke_static_return_void");
3090 AssertThrows<InvalidOperationException> (delegate {
3091 t.InvokeMethod (e.Thread, m, null);
3094 // Check that the frame info is invalidated
3095 run_until ("frames_in_native_2");
3097 AssertThrows<InvalidStackFrameException> (delegate {
3098 Console.WriteLine (frames [frame_index].GetThis ());
3103 public void VirtualMachine_CreateEnumMirror () {
3104 var e = run_until ("o1");
3105 var frame = e.Thread.GetFrames () [0];
3107 object val = frame.GetThis ();
3108 Assert.IsTrue (val is ObjectMirror);
3109 Assert.AreEqual ("Tests", (val as ObjectMirror).Type.Name);
3110 ObjectMirror o = (val as ObjectMirror);
3112 FieldInfoMirror field = o.Type.GetField ("field_enum");
3113 Value f = o.GetValue (field);
3114 TypeMirror enumType = (f as EnumMirror).Type;
3116 o.SetValue (field, vm.CreateEnumMirror (enumType, vm.CreateValue (1)));
3117 f = o.GetValue (field);
3118 Assert.AreEqual (1, (f as EnumMirror).Value);
3120 // Argument checking
3121 AssertThrows<ArgumentNullException> (delegate () {
3122 vm.CreateEnumMirror (enumType, null);
3125 AssertThrows<ArgumentNullException> (delegate () {
3126 vm.CreateEnumMirror (null, vm.CreateValue (1));
3130 AssertThrows<ArgumentException> (delegate () {
3131 vm.CreateEnumMirror (enumType, vm.CreateValue (null));
3134 // value of a wrong type
3135 AssertThrows<ArgumentException> (delegate () {
3136 vm.CreateEnumMirror (enumType, vm.CreateValue ((long)1));
3141 public void VirtualMachine_EnableEvents_Breakpoint () {
3142 AssertThrows<ArgumentException> (delegate () {
3143 vm.EnableEvents (EventType.Breakpoint);
3148 public void SingleStepRegress654694 () {
3151 MethodMirror m = entry_point.DeclaringType.GetMethod ("ss_regress_654694");
3152 foreach (Location l in m.Locations) {
3153 if (l.ILOffset > 0 && il_offset == -1)
3154 il_offset = l.ILOffset;
3157 Event e = run_until ("ss_regress_654694");
3159 Assert.IsNotNull (m);
3160 vm.SetBreakpoint (m, il_offset);
3164 e = GetNextEvent ();
3165 Assert.IsTrue (e is BreakpointEvent);
3167 var req = create_step (e);
3168 req.Depth = StepDepth.Over;
3169 req.Size = StepSize.Line;
3174 e = GetNextEvent ();
3175 Assert.IsTrue (e is StepEvent);
3181 public void DebugBreak () {
3182 vm.EnableEvents (EventType.UserBreak);
3187 var e = GetNextEvent ();
3188 Assert.IsTrue (e is UserBreakEvent);
3192 public void DebugLog () {
3193 vm.EnableEvents (EventType.UserLog);
3198 var e = GetNextEvent ();
3199 Assert.IsTrue (e is UserLogEvent);
3200 var le = e as UserLogEvent;
3202 Assert.AreEqual (5, le.Level);
3203 Assert.AreEqual ("A", le.Category);
3204 Assert.AreEqual ("B", le.Message);
3208 public void TypeGetMethodsByNameFlags () {
3210 var assembly = entry_point.DeclaringType.Assembly;
3211 var type = assembly.GetType ("Tests3");
3213 Assert.IsNotNull (type);
3215 mm = type.GetMethodsByNameFlags (null, BindingFlags.Static | BindingFlags.Public, false);
3216 Assert.AreEqual (1, mm.Length, "#1");
3217 Assert.AreEqual ("M1", mm[0].Name, "#2");
3219 mm = type.GetMethodsByNameFlags (null, BindingFlags.Static | BindingFlags.NonPublic, false);
3220 Assert.AreEqual (1, mm.Length, "#3");
3221 Assert.AreEqual ("M2", mm[0].Name, "#4");
3223 mm = type.GetMethodsByNameFlags (null, BindingFlags.Instance | BindingFlags.Public, false);
3224 Assert.AreEqual (7, mm.Length, "#5"); //M3 plus Equals, GetHashCode, GetType, ToString, .ctor
3226 mm = type.GetMethodsByNameFlags (null, BindingFlags.Instance | BindingFlags.Public | BindingFlags.DeclaredOnly, false);
3227 Assert.AreEqual (2, mm.Length, "#7");
3229 mm = type.GetMethodsByNameFlags (null, BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.DeclaredOnly, false);
3230 Assert.AreEqual (1, mm.Length, "#9");
3232 mm = type.GetMethodsByNameFlags (null, BindingFlags.Static | BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.DeclaredOnly, false);
3233 Assert.AreEqual (5, mm.Length, "#11");
3236 mm = type.GetMethodsByNameFlags ("M1", BindingFlags.Static | BindingFlags.Public, false);
3237 Assert.AreEqual (1, mm.Length, "#12");
3238 Assert.AreEqual ("M1", mm[0].Name, "#13");
3240 mm = type.GetMethodsByNameFlags ("m1", BindingFlags.Static | BindingFlags.Public, true);
3241 Assert.AreEqual (1, mm.Length, "#14");
3242 Assert.AreEqual ("M1", mm[0].Name, "#15");
3244 mm = type.GetMethodsByNameFlags ("M1", BindingFlags.Static | BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic, false);
3245 Assert.AreEqual (1, mm.Length, "#16");
3246 Assert.AreEqual ("M1", mm[0].Name, "#17");
3250 [Category ("only88")]
3251 public void TypeLoadSourceFileFilter () {
3252 Event e = run_until ("type_load");
3254 if (!vm.Version.AtLeast (2, 7))
3257 string srcfile = (e as BreakpointEvent).Method.DeclaringType.GetSourceFiles (true)[0];
3259 var req = vm.CreateTypeLoadRequest ();
3260 req.SourceFileFilter = new string [] { srcfile.ToUpper () };
3264 e = GetNextEvent ();
3265 Assert.IsTrue (e is TypeLoadEvent);
3266 Assert.AreEqual ("TypeLoadClass", (e as TypeLoadEvent).Type.FullName);
3270 public void TypeLoadTypeNameFilter () {
3271 Event e = run_until ("type_load");
3273 var req = vm.CreateTypeLoadRequest ();
3274 req.TypeNameFilter = new string [] { "TypeLoadClass2" };
3278 e = GetNextEvent ();
3279 Assert.IsTrue (e is TypeLoadEvent);
3280 Assert.AreEqual ("TypeLoadClass2", (e as TypeLoadEvent).Type.FullName);
3284 public void GetTypesForSourceFile () {
3287 var types = vm.GetTypesForSourceFile ("dtest-app.cs", false);
3288 Assert.IsTrue (types.Any (t => t.FullName == "Tests"));
3289 Assert.IsFalse (types.Any (t => t.FullName == "System.Int32"));
3291 types = vm.GetTypesForSourceFile ("DTEST-app.cs", true);
3292 Assert.IsTrue (types.Any (t => t.FullName == "Tests"));
3293 Assert.IsFalse (types.Any (t => t.FullName == "System.Int32"));
3297 public void GetTypesNamed () {
3300 var types = vm.GetTypes ("Tests", false);
3301 Assert.AreEqual (1, types.Count);
3302 Assert.AreEqual ("Tests", types [0].FullName);
3304 types = vm.GetTypes ("System.Exception", false);
3305 Assert.AreEqual (1, types.Count);
3306 Assert.AreEqual ("System.Exception", types [0].FullName);
3310 public void String_GetChars () {
3314 var e = run_until ("arg2");
3316 var frame = e.Thread.GetFrames () [0];
3318 val = frame.GetArgument (0);
3319 Assert.IsTrue (val is StringMirror);
3320 AssertValue ("FOO", val);
3321 var s = (val as StringMirror);
3322 Assert.AreEqual (3, s.Length);
3324 var c = s.GetChars (0, 2);
3325 Assert.AreEqual (2, c.Length);
3326 Assert.AreEqual ('F', c [0]);
3327 Assert.AreEqual ('O', c [1]);
3329 AssertThrows<ArgumentException> (delegate () {
3335 public void GetInterfaces () {
3336 var e = run_until ("arg2");
3338 var frame = e.Thread.GetFrames () [0];
3340 var cl1 = frame.Method.DeclaringType.Assembly.GetType ("TestIfaces");
3341 var ifaces = cl1.GetInterfaces ();
3342 Assert.AreEqual (1, ifaces.Length);
3343 Assert.AreEqual ("ITest", ifaces [0].Name);
3345 var cl2 = cl1.GetMethod ("Baz").ReturnType;
3346 var ifaces2 = cl2.GetInterfaces ();
3347 Assert.AreEqual (1, ifaces2.Length);
3348 Assert.AreEqual ("ITest`1", ifaces2 [0].Name);
3352 public void GetInterfaceMap () {
3353 var e = run_until ("arg2");
3355 var frame = e.Thread.GetFrames () [0];
3357 var cl1 = frame.Method.DeclaringType.Assembly.GetType ("TestIfaces");
3358 var iface = cl1.Assembly.GetType ("ITest");
3359 var map = cl1.GetInterfaceMap (iface);
3360 Assert.AreEqual (cl1, map.TargetType);
3361 Assert.AreEqual (iface, map.InterfaceType);
3362 Assert.AreEqual (2, map.InterfaceMethods.Length);
3363 Assert.AreEqual (2, map.TargetMethods.Length);
3367 public void StackAlloc_Breakpoints_Regress2775 () {
3368 // Check that breakpoints on arm don't overwrite stackalloc-ed memory
3369 var e = run_until ("regress_2755");
3371 var frame = e.Thread.GetFrames () [0];
3373 // This breaks at the call site
3374 vm.SetBreakpoint (m, m.Locations [2].ILOffset);
3377 var e2 = GetNextEvent ();
3378 Assert.IsTrue (e2 is BreakpointEvent);
3380 e = run_until ("regress_2755_3");
3381 frame = e.Thread.GetFrames () [1];
3382 var res = frame.GetValue (m.GetLocal ("sum"));
3383 AssertValue (0, res);
3387 public void MethodInfo () {
3388 Event e = run_until ("locals2");
3390 StackFrame frame = e.Thread.GetFrames () [0];
3391 var m = frame.Method;
3393 Assert.IsTrue (m.IsGenericMethod);
3394 Assert.IsFalse (m.IsGenericMethodDefinition);
3396 var args = m.GetGenericArguments ();
3397 Assert.AreEqual (1, args.Length);
3398 Assert.AreEqual ("String", args [0].Name);
3400 var gmd = m.GetGenericMethodDefinition ();
3401 Assert.IsTrue (gmd.IsGenericMethod);
3402 Assert.IsTrue (gmd.IsGenericMethodDefinition);
3403 Assert.AreEqual (gmd, gmd.GetGenericMethodDefinition ());
3405 args = gmd.GetGenericArguments ();
3406 Assert.AreEqual (1, args.Length);
3407 Assert.AreEqual ("T", args [0].Name);
3409 var attrs = m.GetCustomAttributes (true);
3410 Assert.AreEqual (1, attrs.Length);
3411 Assert.AreEqual ("StateMachineAttribute", attrs [0].Constructor.DeclaringType.Name);
3415 public void UnhandledException () {
3418 Start (new string [] { "dtest-app.exe", "unhandled-exception" });
3420 var req = vm.CreateExceptionRequest (null, false, true);
3423 var e = run_until ("unhandled_exception");
3426 var e2 = GetNextEvent ();
3427 Assert.IsTrue (e2 is ExceptionEvent);
3434 public void UnhandledException_2 () {
3437 Start (new string [] { "dtest-app.exe", "unhandled-exception-endinvoke" });
3439 var req = vm.CreateExceptionRequest (null, false, true);
3442 MethodMirror m = entry_point.DeclaringType.GetMethod ("unhandled_exception_endinvoke_2");
3443 Assert.IsNotNull (m);
3444 vm.SetBreakpoint (m, m.ILOffsets [0]);
3446 var e = run_until ("unhandled_exception_endinvoke");
3449 var e2 = GetNextEvent ();
3450 Assert.IsFalse (e2 is ExceptionEvent);
3458 public void UnhandledExceptionUserCode () {
3461 // Exceptions caught in non-user code are treated as unhandled
3462 Start (new string [] { "dtest-app.exe", "unhandled-exception-user" });
3464 var req = vm.CreateExceptionRequest (null, false, true);
3465 req.AssemblyFilter = new List<AssemblyMirror> () { entry_point.DeclaringType.Assembly };
3468 var e = run_until ("unhandled_exception_user");
3471 var e2 = GetNextEvent ();
3472 Assert.IsTrue (e2 is ExceptionEvent);
3480 public void GCWhileSuspended () {
3481 // Check that objects are kept alive during suspensions
3482 Event e = run_until ("gc_suspend_1");
3484 MethodMirror m = entry_point.DeclaringType.GetMethod ("gc_suspend_invoke");
3486 var o = entry_point.DeclaringType.GetValue (entry_point.DeclaringType.GetField ("gc_suspend_field")) as ObjectMirror;
3487 //Console.WriteLine (o);
3489 StackFrame frame = e.Thread.GetFrames () [0];
3490 TypeMirror t = frame.Method.DeclaringType;
3491 for (int i = 0; i < 10; ++i)
3492 t.InvokeMethod (e.Thread, m, new Value [] { });
3494 // This throws an exception if the object is collected
3495 long addr = o.Address;
3497 var o2 = entry_point.DeclaringType.GetValue (entry_point.DeclaringType.GetField ("gc_suspend_field")) as ObjectMirror;
3502 public void MakeGenericMethod () {
3503 Event e = run_until ("bp1");
3505 var intm = vm.RootDomain.GetCorrespondingType (typeof (int));
3506 var stringm = vm.RootDomain.GetCorrespondingType (typeof (string));
3507 var gm = entry_point.DeclaringType.GetMethod ("generic_method");
3508 var res = gm.MakeGenericMethod (new TypeMirror [] { stringm });
3509 var args = res.GetGenericArguments ();
3510 Assert.AreEqual (1, args.Length);
3511 Assert.AreEqual (stringm, args [0]);
3514 AssertThrows<ArgumentNullException> (delegate {
3515 gm.MakeGenericMethod (null);
3517 AssertThrows<ArgumentNullException> (delegate {
3518 gm.MakeGenericMethod (new TypeMirror [] { null });
3520 AssertThrows<ArgumentException> (delegate {
3521 gm.MakeGenericMethod (new TypeMirror [] { stringm, stringm });
3523 AssertThrows<InvalidOperationException> (delegate {
3524 gm.MakeGenericMethod (new TypeMirror [] { intm });
3526 AssertThrows<InvalidOperationException> (delegate {
3527 entry_point.DeclaringType.GetMethod ("Main").MakeGenericMethod (new TypeMirror [] { intm });
3532 public void InspectThreadSuspenedOnWaitOne () {
3534 Start (true, "dtest-app.exe", "wait-one" );
3536 ThreadMirror.NativeTransitions = true;
3538 var evt = run_until ("wait_one");
3539 Assert.IsNotNull (evt, "#1");
3541 var thread = evt.Thread;
3542 Assert.AreEqual (ThreadState.Running, thread.ThreadState, "#1.1");
3544 var frames = thread.GetFrames ();
3545 Assert.IsNotNull (frames, "#2");
3546 Assert.AreEqual (2, frames.Length, "#3");
3547 Assert.AreEqual ("wait_one", frames [0].Method.Name, "#4");
3548 Assert.AreEqual ("Main", frames [1].Method.Name, "#5");
3552 Thread.Sleep (500); //FIXME this is racy, maybe single step? or something?
3555 Assert.AreEqual (ThreadState.WaitSleepJoin, thread.ThreadState, "#6");
3557 frames = thread.GetFrames ();
3558 Assert.AreEqual (4, frames.Length, "#7");
3559 Assert.AreEqual ("WaitOne_internal", frames [0].Method.Name, "#8");
3560 Assert.AreEqual ("WaitOne", frames [1].Method.Name, "#8.1");
3561 Assert.AreEqual ("wait_one", frames [2].Method.Name, "#9");
3562 Assert.AreEqual ("Main", frames [3].Method.Name, "#10");
3565 var frame = frames [0];
3566 Assert.IsTrue (frame.IsNativeTransition, "#11.1");
3569 Assert.Fail ("Known limitation - can't get info from m2n frames");
3570 } catch (AbsentInformationException) {}
3573 Assert.IsFalse (frame.IsNativeTransition, "#12.1");
3574 var wait_one_this = frame.GetThis ();
3575 Assert.IsNotNull (wait_one_this, "#12.2");
3578 var locals = frame.GetVisibleVariables ();
3579 Assert.AreEqual (1, locals.Count, "#13.1");
3581 var local_0 = frame.GetValue (locals [0]);
3582 Assert.IsNotNull (local_0, "#13.2");
3584 Assert.AreEqual (wait_one_this, local_0, "#14.2");
3588 public void GetMethodBody () {
3589 var bevent = run_until ("Main");
3591 var m = bevent.Method.DeclaringType.GetMethod ("get_IntProperty");
3592 var body = m.GetMethodBody ();
3593 foreach (var ins in body.Instructions) {
3594 if (ins.OpCode == OpCodes.Ldfld) {
3595 var field = (FieldInfoMirror)ins.Operand;
3596 Assert.AreEqual ("field_i", field.Name);
3602 public void EvaluateMethod () {
3603 var bevent = run_until ("evaluate_method_2");
3605 var m = bevent.Method.DeclaringType.GetMethod ("get_IntProperty");
3607 var this_obj = bevent.Thread.GetFrames ()[0].GetThis ();
3608 var v = m.Evaluate (this_obj, null);
3609 AssertValue (42, v);
3613 public void SetIP () {
3614 var bevent = run_until ("set_ip_1");
3616 var invalid_loc = bevent.Thread.GetFrames ()[0].Location;
3618 var req = create_step (bevent);
3619 var e = step_out ();
3621 var frames = e.Thread.GetFrames ();
3622 var locs = frames [0].Method.Locations;
3623 var next_loc = locs.First (l => (l.LineNumber == frames [0].Location.LineNumber + 2));
3625 e.Thread.SetIP (next_loc);
3627 /* Check that i ++; j = 5; was skipped */
3628 bevent = run_until ("set_ip_2");
3629 var f = bevent.Thread.GetFrames ()[1];
3630 AssertValue (2, f.GetValue (f.Method.GetLocal ("i")));
3631 AssertValue (0, f.GetValue (f.Method.GetLocal ("j")));
3634 AssertThrows<ArgumentNullException> (delegate {
3635 e.Thread.SetIP (null);
3638 AssertThrows<ArgumentException> (delegate {
3639 e.Thread.SetIP (invalid_loc);
3644 public void SetIPSingleStep () {
3645 // Check that single stepping after set-ip steps from the new ip
3646 var bevent = run_until ("set_ip_1");
3648 var invalid_loc = bevent.Thread.GetFrames ()[0].Location;
3650 var req = create_step (bevent);
3651 req.Size = StepSize.Line;
3652 var e = step_out ();
3654 var frames = e.Thread.GetFrames ();
3655 var locs = frames [0].Method.Locations;
3656 var prev_loc = locs.First (l => (l.LineNumber == frames [0].Location.LineNumber - 3));
3657 AssertValue (2, frames [0].GetValue (frames [0].Method.GetLocal ("i")));
3659 // Set back the ip to the first i ++; line
3660 e.Thread.SetIP (prev_loc);
3663 var f = e.Thread.GetFrames ()[0];
3664 AssertValue (3, f.GetValue (f.Method.GetLocal ("i")));
3668 public void NewInstanceNoCtor () {
3669 var bevent = run_until ("Main");
3671 var stype = bevent.Method.DeclaringType.Assembly.GetType ("AStruct");
3672 var obj = stype.NewInstance ();
3673 Assert.IsTrue (obj is ObjectMirror);
3674 Assert.AreEqual ("AStruct", (obj as ObjectMirror).Type.Name);
3678 public void StaticCtorFilterInCctor () {
3679 // Check that single stepping when in a cctor only ignores
3680 // other cctors, not the current one
3681 var bevent = run_until ("step_filters");
3683 var assembly = entry_point.DeclaringType.Assembly;
3684 var type = assembly.GetType ("Tests/ClassWithCctor");
3685 var cctor = type.GetMethod (".cctor");
3686 vm.SetBreakpoint (cctor, 0);
3689 var e = vm.GetNextEvent ();
3690 Assert.IsTrue (e is BreakpointEvent);
3692 var req = create_step (e);
3693 req.Filter = StepFilter.StaticCtor;
3695 // Make sure we are still in the cctor
3696 Assert.AreEqual (".cctor", e.Thread.GetFrames ()[0].Location.Method.Name);