Add unit test for AggregateException.GetBaseException that works on .net but is broke...

[mono.git] / mcs / class / corlib / Test / System / AggregateExceptionTests.cs

diff --git a/mcs/class/corlib/Test/System/AggregateExceptionTests.cs b/mcs/class/corlib/Test/System/AggregateExceptionTests.cs
index fbab26969d42576505cc0151daa205b7fde27158..67cedafbbb4413b53d3f58deea763b533a9b51ea 100644 (file)
--- a/mcs/class/corlib/Test/System/AggregateExceptionTests.cs
+++ b/mcs/class/corlib/Test/System/AggregateExceptionTests.cs
@@ -1,4 +1,3 @@
-#if NET_4_0
 // AggregateExceptionTests.cs
 //
 // Copyright (c) 2008 Jérémie "Garuma" Laval
@@ -23,19 +22,20 @@
 //
 //
 
+#if NET_4_0
+
 using System;
 using System.Linq;
 using System.Threading;
+using System.Collections.Generic;
 
 using NUnit;
-using NUnit.Core;
 using NUnit.Framework;
 
-namespace ParallelFxTests
+namespace MonoTests.System
 {
-       
        [TestFixture()]
-       public class AggregateExceptionTests
+       public class AggregateExceptionTest
        {
                AggregateException e;
                
@@ -44,6 +44,23 @@ namespace ParallelFxTests
                {
                        e = new AggregateException(new Exception("foo"), new AggregateException(new Exception("bar"), new Exception("foobar")));
                }
+
+               [Test]
+               public void SimpleInnerExceptionTestCase ()
+               {
+                       var message = "Foo";
+                       var inner = new ApplicationException (message);
+                       var ex = new AggregateException (inner);
+
+                       Assert.IsNotNull (ex.InnerException);
+                       Assert.IsNotNull (ex.InnerExceptions);
+
+                       Assert.AreEqual (inner, ex.InnerException);
+                       Assert.AreEqual (1, ex.InnerExceptions.Count);
+                       Assert.AreEqual (inner, ex.InnerExceptions[0]);
+                       Assert.AreEqual (message, ex.InnerException.Message);
+                       Assert.AreEqual (inner, ex.GetBaseException ());
+               }
                
                [TestAttribute]
                public void FlattenTestCase()
@@ -53,6 +70,75 @@ namespace ParallelFxTests
                        Assert.AreEqual(3, ex.InnerExceptions.Count, "#1");
                        Assert.AreEqual(3, ex.InnerExceptions.Where((exception) => !(exception is AggregateException)).Count(), "#2");
                }
+
+               [Test, ExpectedException (typeof (ArgumentException))]
+               public void InitializationWithNullInnerValuesTest ()
+               {
+                       var foo = new AggregateException (new Exception[] { new Exception (), null, new ApplicationException ()});
+               }
+
+               [Test]
+               public void InitializationWithNullValuesTest ()
+               {
+                       Throws (typeof (ArgumentNullException), () => new AggregateException ((IEnumerable<Exception>)null));
+                       Throws (typeof (ArgumentNullException), () => new AggregateException ((Exception[])null));
+               }
+
+               [Test]
+               [ExpectedException (typeof (ArgumentNullException))]
+               public void Handle_Invalid ()
+               {
+                       e.Handle (null);
+               }
+
+               [Test]
+               public void Handle_AllHandled ()
+               {
+                       e.Handle (l => true);
+               }
+
+               [Test]
+               public void Handle_Unhandled ()
+               {
+                       try {
+                               e.Handle (l => l is AggregateException);
+                               Assert.Fail ();
+                       } catch (AggregateException e) {
+                               Assert.AreEqual (1, e.InnerExceptions.Count);
+                       }
+               }
+
+               [Test]
+               public void GetBaseWithInner ()
+               {
+                       var ae = new AggregateException ("x", new [] { new ArgumentException (), new ArgumentNullException () });
+                       Assert.AreEqual (ae, ae.GetBaseException (), "#1");
+
+                       var expected = new ArgumentException ();
+                       var ae2 = new AggregateException ("x", new AggregateException (expected, new Exception ()));
+                       Assert.AreEqual (expected, ae2.GetBaseException ().InnerException, "#2");
+               }
+
+               [Test]
+               public void GetBaseException_stops_at_first_inner_exception_that_is_not_AggregateException()
+               {
+                       var inner = new ArgumentNullException();
+                       var outer = new InvalidOperationException("x", inner);
+                       Assert.AreEqual(outer, new AggregateException(outer).GetBaseException());
+               }
+
+               static void Throws (Type t, Action action)
+               {
+                       Exception e = null;
+                       try {
+                               action ();
+                       } catch (Exception ex) {
+                               e = ex;
+                       }
+
+                       if (e == null || e.GetType () != t)
+                               Assert.Fail ();
+               }
        }
 }
 #endif