Merge pull request #498 from Unroll-Me/master

[mono.git] / mcs / class / Mono.Debugger.Soft / Test / dtest.cs

diff --git a/mcs/class/Mono.Debugger.Soft/Test/dtest.cs b/mcs/class/Mono.Debugger.Soft/Test/dtest.cs
index 5a3a47adad7e97d1cdd92871721ae4902a421588..ead271375b165287671f02994238cced868b8315 100644 (file)
--- a/mcs/class/Mono.Debugger.Soft/Test/dtest.cs
+++ b/mcs/class/Mono.Debugger.Soft/Test/dtest.cs
@@ -195,7 +195,7 @@ public class DebuggerTests
                // Argument checking
                AssertThrows<ArgumentException> (delegate {
                                // Invalid IL offset
-                               vm.SetBreakpoint (m, 1);
+                               vm.SetBreakpoint (m, 2);
                        });
        }
 
@@ -1621,7 +1621,32 @@ public class DebuggerTests
        }
 
        [Test]
-       [Category("only88")]
+       public void ColumnNumbers () {
+               Event e = run_until ("line_numbers");
+
+               // FIXME: Merge this with LineNumbers () when its fixed
+
+               step_req = vm.CreateStepRequest (e.Thread);
+               step_req.Depth = StepDepth.Into;
+               step_req.Enable ();
+
+               Location l;
+               
+               vm.Resume ();
+
+               e = GetNextEvent ();
+               Assert.IsTrue (e is StepEvent);
+
+               l = e.Thread.GetFrames ()[0].Location;
+
+               Assert.AreEqual (3, l.ColumnNumber);
+
+               step_req.Disable ();
+       }
+
+       [Test]
+       // Broken by mcs+runtime changes (#5438)
+       [Category("NotWorking")]
        public void LineNumbers () {
                Event e = run_until ("line_numbers");
 
@@ -2117,6 +2142,44 @@ public class DebuggerTests
                Assert.AreEqual (EventType.TypeLoad, e.EventType);
        }
 
+       List<Value> invoke_results;
+
+       [Test]
+       public void InvokeMultiple () {
+               Event e = run_until ("invoke1");
+
+               StackFrame frame = e.Thread.GetFrames () [0];
+
+               TypeMirror t = frame.Method.DeclaringType;
+               ObjectMirror this_obj = (ObjectMirror)frame.GetThis ();
+
+               TypeMirror t2 = frame.Method.GetParameters ()[0].ParameterType;
+
+               var methods = new MethodMirror [2];
+               methods [0] = t.GetMethod ("invoke_return_ref");
+               methods [1] = t.GetMethod ("invoke_return_primitive");
+
+               invoke_results = new List<Value> ();
+
+               var r = this_obj.BeginInvokeMultiple (e.Thread, methods, null, InvokeOptions.SingleThreaded, invoke_multiple_cb, this_obj);
+               WaitHandle.WaitAll (new WaitHandle[] { r.AsyncWaitHandle });
+               this_obj.EndInvokeMultiple (r);
+               // The callback might still be running
+               while (invoke_results.Count < 2) {
+                       Thread.Sleep (100);
+               }
+               AssertValue ("ABC", invoke_results [0]);
+               AssertValue (42, invoke_results [1]);
+       }
+
+       void invoke_multiple_cb (IAsyncResult ar) {
+               ObjectMirror this_obj = (ObjectMirror)ar.AsyncState;
+
+               var res = this_obj.EndInvokeMethod (ar);
+               lock (invoke_results)
+                       invoke_results.Add (res);
+       }
+
        [Test]
        public void GetThreads () {
                vm.GetThreads ();
@@ -2527,10 +2590,10 @@ public class DebuggerTests
                e = run_until ("domains_2");
                var frame = e.Thread.GetFrames ()[0];
                var o = frame.GetArgument (0) as ObjectMirror;
-               Assert.AreEqual ("TransparentProxy", o.Type.Name);
+               Assert.AreEqual ("CrossDomain", o.Type.Name);
 
                // Do a remoting invoke
-               var cross_domain_type = (e.Thread.GetFrames ()[0].GetArgument (1) as ObjectMirror).Type;
+               var cross_domain_type = o.Type;
                var v = o.InvokeMethod (e.Thread, cross_domain_type.GetMethod ("invoke_3"), null);
                AssertValue (42, v);
 
@@ -2994,7 +3057,53 @@ public class DebuggerTests
                args = gmd.GetGenericArguments ();
                Assert.AreEqual (1, args.Length);
                Assert.AreEqual ("T", args [0].Name);
+
+               var attrs = m.GetCustomAttributes (true);
+               Assert.AreEqual (1, attrs.Length);
+               Assert.AreEqual ("StateMachineAttribute", attrs [0].Constructor.DeclaringType.Name);
+       }
+
+       [Test]
+       public void UnhandledException () {
+               vm.Detach ();
+
+               Start (new string [] { "dtest-app.exe", "unhandled-exception" });
+
+               var req = vm.CreateExceptionRequest (null, false, true);
+               req.Enable ();
+
+               var e = run_until ("unhandled_exception");
+               vm.Resume ();
+
+               var e2 = GetNextEvent ();
+               Assert.IsTrue (e2 is ExceptionEvent);
+
+               vm.Exit (0);
+               vm = null;
+       }
+
+#if NET_4_5
+       [Test]
+       public void UnhandledExceptionUserCode () {
+               vm.Detach ();
+
+               // Exceptions caught in non-user code are treated as unhandled
+               Start (new string [] { "dtest-app.exe", "unhandled-exception-user" });
+
+               var req = vm.CreateExceptionRequest (null, false, true);
+               req.AssemblyFilter = new List<AssemblyMirror> () { entry_point.DeclaringType.Assembly };
+               req.Enable ();
+
+               var e = run_until ("unhandled_exception_user");
+               vm.Resume ();
+
+               var e2 = GetNextEvent ();
+               Assert.IsTrue (e2 is ExceptionEvent);
+
+               vm.Exit (0);
+               vm = null;
        }
+#endif
 }
 
 }
\ No newline at end of file