class/System.ComponentModel.Composition/Tests/UnitTestFramework/System/UnitTesting/ExceptionAssert.cs

   1 // -----------------------------------------------------------------------
   2 // Copyright (c) Microsoft Corporation.  All rights reserved.
   3 // -----------------------------------------------------------------------
   4 using System;
   5 using Microsoft.VisualStudio.TestTools.UnitTesting;
   6 using System.Runtime.Serialization;
   7
   8 namespace System.UnitTesting
   9 {
  10     public static class ExceptionAssert
  11     {
  12         // NOTE: To catch state corrupting exceptions, it by design that
  13         // the ThrowsXXX methods retry by default. To prevent this in a
  14         // test, simply use one of the overloads that takes a RetryMode.
  15
  16         /// <summary>
  17         ///     Verifies that the exception has the default message generated by the base Exception class.
  18         /// </summary>
  19         public static void HasDefaultMessage(Exception exception)
  20         {
  21             Assert.IsNotNull(exception);
  22
  23             // Exception of type '[typename]' was thrown
  24             StringAssert.Contains(exception.Message, exception.GetType().FullName);
  25         }
  26
  27         /// <summary>
  28         ///     Verifies that the specified action throws a SerializationException.
  29         /// </summary>
  30         public static SerializationException ThrowsSerialization(string memberName, Action action)
  31         {
  32             var exception = Throws<SerializationException>(RetryMode.Retry, action, (actual, retryCount) =>
  33             {
  34                 AssertSerializationMemberName(memberName, actual, retryCount);
  35             });
  36
  37             return exception;
  38         }
  39
  40         /// <summary>
  41         ///     Verifies that the specified action throws an ObjectDisposedException.
  42         /// </summary>
  43         public static ObjectDisposedException ThrowsDisposed(object instance, Action action)
  44         {
  45             var exception = Throws<ObjectDisposedException>(RetryMode.Retry, action, (actual, retryCount) =>
  46             {
  47                 AssertObjectDisposed(instance, actual, retryCount);
  48             });
  49
  50             return exception;
  51         }
  52
  53         /// <summary>
  54         ///     Verifies that the specified action throws an ArgumentNullException.
  55         /// </summary>
  56         public static ArgumentNullException ThrowsArgumentNull(string parameterName, Action action)
  57         {
  58             return ThrowsArgument<ArgumentNullException>(parameterName, action);
  59         }
  60
  61         /// <summary>
  62         ///     Verifies that the specified action throws an ArgumentException.
  63         /// </summary>
  64         public static ArgumentException ThrowsArgument(string parameterName, Action action)
  65         {
  66             return ThrowsArgument<ArgumentException>(parameterName, action);
  67         }
  68
  69         /// <summary>
  70         ///     Verifies that the specified action throws an ArgumentException of type <typeparam name="T"/>.
  71         /// </summary>
  72         public static T ThrowsArgument<T>(string parameterName, Action action)
  73             where T : ArgumentException
  74         {
  75             var exception = Throws<T>(RetryMode.Retry, action, (actual, retryCount) =>
  76             {
  77                 AssertSameParameterName(parameterName, actual, retryCount);
  78             });
  79
  80             return exception;
  81         }
  82
  83         /// <summary>
  84         ///     Verifies that the specified action throws an exception of type <typeparam name="T"/>,
  85         ///     with the specified inner exception of type <typeparam name="TInner"/>.
  86         /// </summary>
  87         public static T Throws<T, TInner>(Action action)
  88             where T : Exception
  89             where TInner : Exception
  90         {
  91             return Throws<T, TInner>(RetryMode.Retry, action);
  92         }
  93
  94         /// <summary>
  95         ///     Verifies that the specified action throws an exception of type <typeparam name="T"/>,
  96         ///     with the specified inner exception of type <typeparam name="TInner"/>, and indicating
  97         ///     whether to retry.
  98         /// </summary>
  99         public static T Throws<T, TInner>(RetryMode retry, Action action)
 100             where T : Exception
 101             where TInner : Exception
 102         {
 103             return Throws<T, TInner>(retry, action, (Action<T, int>)null);
 104         }
 105
 106         /// <summary>
 107         ///     Verifies that the specified action throws an exception of type <typeparam name="T"/>,
 108         ///     with the specified inner exception of type <typeparam name="TInner"/>, indicating
 109         ///     whether to retry and running the specified validator.
 110         /// </summary>
 111         public static T Throws<T, TInner>(RetryMode retry, Action action, Action<T, int> validator)
 112             where T : Exception
 113             where TInner : Exception
 114         {
 115             var exception = Throws<T>(retry, action, (actual, retryCount) =>
 116             {
 117                 AssertIsExactInstanceOfInner(typeof(TInner), actual, retryCount);
 118
 119                 if (validator != null)
 120                 {
 121                     validator(actual, retryCount);
 122                 }
 123             });
 124
 125             return exception;
 126         }
 127
 128         /// <summary>
 129         ///     Verifies that the specified action throws an exception of type <typeparam name="T"/>,
 130         ///     with the specified inner exception.
 131         /// </summary>
 132         public static T Throws<T>(Exception innerException, Action action)
 133             where T : Exception
 134         {
 135             return Throws<T>(innerException, RetryMode.Retry, action, (Action<T, int>)null);
 136         }
 137
 138         /// <summary>
 139         ///     Verifies that the specified action throws an exception of type <typeparam name="T"/>,
 140         ///     with the specified inner exception, and indicating whether to retry.
 141         /// </summary>
 142         public static T Throws<T>(Exception innerException, RetryMode retry, Action action)
 143             where T : Exception
 144         {
 145             return Throws<T>(innerException, RetryMode.Retry, action, (Action<T, int>)null);
 146         }
 147
 148         /// <summary>
 149         ///     Verifies that the specified action throws an exception of type <typeparam name="T"/>,
 150         ///     with the specified inner exception, indicating whether to retry and running the
 151         ///     specified validator.
 152         /// </summary>
 153         public static T Throws<T>(Exception innerException, RetryMode retry, Action action, Action<T, int> validator)
 154             where T : Exception
 155         {
 156             T exception = Throws<T>(retry, action, (actual, retryCount) =>
 157             {
 158                 AssertSameInner(innerException, actual, retryCount);
 159
 160                 if (validator != null)
 161                 {
 162                     validator(actual, retryCount);
 163                 }
 164             });
 165
 166             return exception;
 167         }
 168
 169         /// <summary>
 170         ///     Verifies that the specified action throws an exception of type <typeparam name="T"/>.
 171         /// </summary>
 172         public static T Throws<T>(Action action)
 173             where T : Exception
 174         {
 175             return Throws<T>(RetryMode.Retry, action, (Action<T, int>)null);
 176         }
 177
 178         /// <summary>
 179         ///     Verifies that the specified action throws an exception of type <typeparam name="T"/>,
 180         ///     indicating whether to retry.
 181         /// </summary>
 182         public static T Throws<T>(RetryMode retry, Action action)
 183             where T : Exception
 184         {
 185             return Throws<T>(retry, action, (Action<T, int>)null);
 186         }
 187
 188         /// <summary>
 189         ///     Verifies that the specified action throws an exception of type <typeparam name="T"/>,
 190         ///     indicating whether to retry and running the specified validator.
 191         /// </summary>
 192         public static T Throws<T>(RetryMode retry, Action action, Action<T, int> validator)
 193             where T : Exception
 194         {
 195             var exception = (T)Run(retry, action, (actual, retryCount) =>
 196             {
 197                 AssertIsExactInstanceOf(typeof(T), actual, retryCount);
 198
 199                 if (validator != null)
 200                 {
 201                     validator((T)actual, retryCount);
 202                 }
 203             });
 204
 205             return exception;
 206         }
 207
 208         /// <summary>
 209         ///     Verifies that the specified action throws the specified exception.
 210         /// </summary>
 211         public static void Throws(Exception expected, Action action)
 212         {
 213             Throws(expected, RetryMode.Retry, action);
 214         }
 215
 216         /// <summary>
 217         ///     Verifies that the specified action throws the specified exception,
 218         ///     indicating whether to retry.
 219         /// </summary>
 220         public static void Throws(Exception expected, RetryMode retry, Action action)
 221         {
 222             Throws(expected, retry, action, (Action<Exception, int>)null);
 223         }
 224
 225         /// <summary>
 226         ///     Verifies that the specified action throws the specified exception,
 227         ///     indicating whether to retry and running the specified validator.
 228         /// </summary>
 229         public static void Throws(Exception expected, RetryMode retry, Action action, Action<Exception, int> validator)
 230         {
 231             Run(retry, action, (actual, retryCount) =>
 232             {
 233                 AssertSame(expected, actual, retryCount);
 234
 235                 if (validator != null)
 236                 {
 237                     validator(actual, retryCount);
 238                 }
 239             });
 240         }
 241
 242         private static Exception Run(RetryMode retry, Action action, Action<Exception, int> validator)
 243         {
 244             Exception exception = null;
 245
 246             for (int i = -1; i < (int)retry; i++)
 247             {
 248                 exception = Run(action);
 249
 250                 validator(exception, i + 2);
 251             }
 252
 253             return exception;
 254         }
 255
 256         private static Exception Run(Action action)
 257         {
 258             try
 259             {
 260                 action();
 261                 return null;
 262             }
 263             catch (Exception ex)
 264             {
 265                 return ex;
 266             }
 267         }
 268
 269         private static void AssertSerializationMemberName(string memberName, SerializationException actual, int retryCount)
 270         {
 271             // Unfortunately, SerializationException does not provide a way to get our hands on the
 272             // the actual member that was missing from the SerializationInfo, so we need to grok the
 273             // message string.
 274
 275             // Member '[memberName]' was not found.
 276             StringAssert.Contains(actual.Message, "'" + memberName + "'", "Retry Count {0}: Expected SerializationException MemberName to be '{1}'", retryCount, memberName);
 277         }
 278
 279         private static void AssertObjectDisposed(object instance, ObjectDisposedException actual, int retryCount)
 280         {
 281             string objectName = instance.GetType().FullName;
 282
 283             Assert.AreEqual(objectName, actual.ObjectName, "Retry Count {0}: Expected {1}.ObjectName to be '{2}', however, '{3}' is.", retryCount, actual.GetType().Name, objectName, actual.ObjectName);
 284         }
 285
 286         private static void AssertSameParameterName(string parameterName, ArgumentException actual, int retryCount)
 287         {
 288 #if !SILVERLIGHT
 289             Assert.AreEqual(parameterName, actual.ParamName, "Retry Count {0}: Expected {1}.ParamName to be '{2}', however, '{3}' is.", retryCount, actual.GetType().Name, parameterName, actual.ParamName);
 290 #else
 291             // Silverlight doesn't have ArgumentException.ParamName
 292             StringAssert.Contains(actual.Message, parameterName, "Retry Count {0}: Expected {1}.ParamName to be '{2}'", retryCount, actual.GetType().Name, parameterName);
 293 #endif
 294         }
 295
 296         private static void AssertSame(Exception expected, Exception actual, int retryCount)
 297         {
 298             Assert.AreSame(expected, actual, "Retry Count {0}: Expected '{1}' to be thrown, however, '{2}' was thrown.", retryCount, expected, actual);
 299         }
 300
 301         private static void AssertSameInner(Exception innerException, Exception actual, int retryCount)
 302         {
 303             Assert.AreSame(innerException, actual.InnerException, "Retry Count {0}: Expected '{1}' to be the inner exception, however, '{2}' is.", retryCount, innerException, actual.InnerException);
 304         }
 305
 306         private static void AssertIsExactInstanceOf(Type expectedType, Exception actual, int retryCount)
 307         {
 308             if (actual == null)
 309                 Assert.Fail("Retry Count {0}: Expected '{1}' to be thrown", retryCount, expectedType);
 310
 311             Type actualType = actual.GetType();
 312
 313             Assert.AreSame(expectedType, actualType, "Retry Count {0}: Expected '{1}' to be thrown, however, '{2}' was thrown.", retryCount, expectedType, actualType);
 314         }
 315
 316         private static void AssertIsExactInstanceOfInner(Type expectedType, Exception actual, int retryCount)
 317         {
 318             if (actual.InnerException == null)
 319                 Assert.Fail("Retry Count {0}: Expected '{1}' be the inner exception, however, it is null.", retryCount, expectedType);
 320
 321             Type actualType = actual.InnerException.GetType();
 322
 323             Assert.AreSame(expectedType, actualType, "Retry Count {0}: Expected '{1}' to be the inner exception, however, '{2}' is.", retryCount, expectedType, actualType);
 324         }
 325     }
 326 }