mcs/class/corlib/Test/System.Runtime.ExceptionServices/ExceptionDispatchInfoTest.cs

   1 //
   2 // ExceptionDispatchInfoTest.cs
   3 //
   4 // Authors:
   5 //      Marek Safar  <marek.safar@gmail.com>
   6 //
   7 // Copyright (C) 2011 Xamarin, Inc (http://www.xamarin.com)
   8 //
   9 // Permission is hereby granted, free of charge, to any person obtaining
  10 // a copy of this software and associated documentation files (the
  11 // "Software"), to deal in the Software without restriction, including
  12 // without limitation the rights to use, copy, modify, merge, publish,
  13 // distribute, sublicense, and/or sell copies of the Software, and to
  14 // permit persons to whom the Software is furnished to do so, subject to
  15 // the following conditions:
  16 //
  17 // The above copyright notice and this permission notice shall be
  18 // included in all copies or substantial portions of the Software.
  19 //
  20 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  21 // EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  22 // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  23 // NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
  24 // LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
  25 // OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
  26 // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  27 //
  28
  29 using System;
  30 using NUnit.Framework;
  31 using System.Runtime.ExceptionServices;
  32 using System.Threading.Tasks;
  33
  34 namespace MonoTests.System.Runtime.ExceptionServices
  35 {
  36         [TestFixture]
  37         public class ExceptionDispatchInfoTest
  38         {
  39                 [Test]
  40                 public void Capture_InvalidArguments ()
  41                 {
  42                         try {
  43                                 ExceptionDispatchInfo.Capture (null);
  44                                 Assert.Fail ();
  45                         } catch (ArgumentNullException) {
  46                         }
  47                 }
  48
  49                 [Test]
  50                 public void Capture ()
  51                 {
  52                         var e = new ApplicationException ("test");
  53                         var edi = ExceptionDispatchInfo.Capture (e);
  54                         Assert.AreEqual (e, edi.SourceException);
  55                 }
  56
  57                 [Test]
  58                 public void Throw ()
  59                 {
  60                         Exception orig = null;
  61                         var t = Task.Factory.StartNew (() => {
  62                                 try {
  63                                         throw new ApplicationException ("aaa");
  64                                 } catch (Exception e) {
  65                                         orig = e;
  66                                         return ExceptionDispatchInfo.Capture (e);
  67                                 }
  68                         });
  69
  70                         var ed = t.Result;
  71                         var orig_stack = orig.StackTrace;
  72                         try {
  73                                 ed.Throw ();
  74                                 Assert.Fail ("#0");
  75                         } catch (Exception e) {
  76                                 var s = e.StackTrace.Split ('\n');
  77                                 Assert.AreEqual (4, s.Length, "#1");
  78                                 Assert.AreEqual (orig, e, "#2");
  79                                 Assert.AreNotEqual (orig_stack, e.StackTrace, "#3");
  80                         }
  81                 }
  82
  83                 [Test]
  84                 public void ThrowWithEmptyFrames ()
  85                 {
  86                         var edi = ExceptionDispatchInfo.Capture (new OperationCanceledException ());
  87                         try {
  88                                 edi.Throw ();
  89                                 Assert.Fail ("#0");
  90                         } catch (OperationCanceledException e) {
  91                                 Assert.IsFalse (e.StackTrace.Contains ("---"));
  92                                 Assert.AreEqual (2, e.StackTrace.Split (new[] { Environment.NewLine }, StringSplitOptions.RemoveEmptyEntries).Length);
  93                         }
  94                 }
  95
  96                 [Test]
  97                 public void LastThrowWins ()
  98                 {
  99                         Exception e;
 100                         try {
 101                                 throw new Exception ("test");
 102                         } catch (Exception e2) {
 103                                 e = e2;
 104                         }
 105
 106                         var edi = ExceptionDispatchInfo.Capture (e);
 107
 108                         try {
 109                                 edi.Throw ();
 110                         } catch {
 111                         }
 112
 113                         try {
 114                                 edi.Throw ();
 115                         } catch (Exception ex) {
 116                         }
 117
 118                         try {
 119                                 edi.Throw ();
 120                         } catch (Exception ex) {
 121                                 var split = ex.StackTrace.Split (new[] { Environment.NewLine }, StringSplitOptions.RemoveEmptyEntries);
 122                                 Assert.AreEqual (4, split.Length, "#1");
 123                                 Assert.IsTrue (split [1].Contains ("---"), "#2");
 124                         }
 125                 }
 126
 127                 [Test]
 128                 public void ThrowMultipleCaptures ()
 129                 {
 130                         Exception e;
 131                         try {
 132                                 throw new Exception ("test");
 133                         } catch (Exception e2) {
 134                                 e = e2;
 135                         }
 136
 137                         var edi = ExceptionDispatchInfo.Capture (e);
 138
 139                         try {
 140                                 edi.Throw ();
 141                         } catch (Exception e3) {
 142                                 edi = ExceptionDispatchInfo.Capture (e3);
 143                         }
 144
 145                         try {
 146                                 edi.Throw ();
 147                         } catch (Exception ex) {
 148                                 var split = ex.StackTrace.Split (new[] { Environment.NewLine }, StringSplitOptions.RemoveEmptyEntries);
 149                                 Assert.AreEqual (7, split.Length, "#1");
 150                                 Assert.IsTrue (split [1].Contains ("---"), "#2");
 151                                 Assert.IsTrue (split [4].Contains ("---"), "#3");
 152                         }
 153                 }
 154         }
 155 }
 156