示例#1
0
        /// <summary>
        /// Verifies that the specified action throws a specific exception type.
        /// </summary>
        /// <typeparam name="T">The exception type.</typeparam>
        /// <param name="action">The exception.</param>
        /// <param name="additionalAssertion">The additional assertion.</param>
        /// <param name="message">A message to display if the assertion fails. This message can
        /// be seen in the unit test results.</param>
        /// <param name="parameters">An array of parameters to use when formatting <paramref name="message"/>.</param>
        /// <exception cref="ArgumentNullException"><paramref name="action"/> or it's value is <see langword="null"/>.</exception>
        public static void Throws <T>(
            this ActualValue <Action> action,
            Action <T> additionalAssertion,
            string message,
            params object[] parameters)
            where T : Exception
        {
            Argument.NotNull(action, nameof(action));
            Argument.NotNull(action.Value, nameof(action));

            try
            {
                action.Value();
            }
            catch (T e)
            {
                try
                {
                    additionalAssertion?.Invoke(e);
                }
                catch (Exception additionalException)
                {
                    Throw(nameof(Throws), additionalException, AdditionalAssertionsFailed(typeof(T)), message, parameters);
                }

                return;
            }
            catch (Exception e)
            {
                Throw(nameof(Throws), UnexpectedException(typeof(T), e.GetType()), message, parameters);
            }

            Throw(nameof(Throws), DidNotThrow(typeof(T)), message, parameters);
        }
示例#2
0
        /// <summary>
        /// Verifies that the specified action throws a specific exception type.
        /// </summary>
        /// <typeparam name="T">The exception type.</typeparam>
        /// <param name="action">The exception.</param>
        /// <exception cref="ArgumentNullException"><paramref name="action"/> or it's value is <see langword="null"/>.</exception>
        public static void Throws <T>(this ActualValue <Action> action)
            where T : Exception
        {
            Argument.NotNull(action, nameof(action));
            Argument.NotNull(action.Value, nameof(action));

            action.Throws <T>(null, null, null);
        }
示例#3
0
        /// <summary>
        /// Verifies that a <see cref="Task" /> completes.
        /// </summary>
        /// <typeparam name="T">The <see cref="Task" /> type.</typeparam>
        /// <param name="task">The task to verify completes.</param>
        /// <param name="message">A message to display if the assertion fails. This message can
        /// be seen in the unit test results.</param>
        /// <remarks>
        /// <para>If this assertion fails you may have a deadlock or the task simply is taking too long
        /// to complete. If you need control over how long to wait before failing use one of the other overloads
        /// of this assertion.</para>
        /// <para>There are no overloads for working with <see cref="Task"/> collections, but you can easily
        /// make assertions by using the <see cref="M:Task.WhenAny"/> or <see cref="M:Task.WhenAll"/> methods.
        /// For example: <code>Assert(Task.WhenAll(tasks)).Complete();</code></para>
        /// </remarks>
        /// <exception cref="ArgumentNullException"><paramref name="task"/> (or it's value) is <c>null</c>.</exception>
        /// <exception cref="AssertionException">The <paramref name="task"/> did not complete in the alloted time.</exception>
        public static void Completes <T>(this ActualValue <T> task, string message)
            where T : Task
        {
            Argument.NotNull(task, nameof(task));
            Argument.NotNull(task.Value, nameof(task));

            task.Completes(DeadlockTimeout, message, null);
        }
示例#4
0
        /// <summary>
        /// Verifies that a <see cref="Task"/> is busy.
        /// </summary>
        /// <typeparam name="T">The <see cref="Task" /> type.</typeparam>
        /// <param name="task">The task to verify is busy.</param>
        /// <param name="message">A message to display if the assertion fails. This message can
        /// be seen in the unit test results.</param>
        /// <param name="parameters">An array of parameters to use when formatting <paramref name="message" />.</param>
        /// <remarks>
        /// <para>This assertion verifies that the task doesn't complete within a specified time.</para>
        /// <para>There are no overloads for working with <see cref="Task"/> collections, but you can easily
        /// make assertions by using the <see cref="M:Task.WhenAny"/> or <see cref="M:Task.WhenAll"/> methods.
        /// For example: <code>Assert(Task.WhenAll(tasks)).Complete();</code></para>
        /// </remarks>
        /// <exception cref="ArgumentNullException"><paramref name="task"/> (or it's value) is <c>null</c>.</exception>
        /// <exception cref="AssertionException">The <paramref name="task"/> did not complete in the alloted time.</exception>
        public static void IsBusy <T>(this ActualValue <T> task, string message, params object[] parameters)
            where T : Task
        {
            Argument.NotNull(task, nameof(task));
            Argument.NotNull(task.Value, nameof(task));

            task.IsBusy(QuickTimeout, message, parameters);
        }
示例#5
0
        /// <summary>
        /// Verifies that a <see cref="Task" /> completes.
        /// </summary>
        /// <typeparam name="T">The <see cref="Task" /> type.</typeparam>
        /// <param name="task">The task to verify completes.</param>
        /// <param name="millisecondsTimeout">The amount of time in milliseconds to wait for the <see cref="Task"/> to complete.</param>
        /// <remarks>
        /// <para>If this assertion fails you may have a deadlock or the task simply is taking too long
        /// to complete.</para>
        /// <para>There are no overloads for working with <see cref="Task"/> collections, but you can easily
        /// make assertions by using the <see cref="M:Task.WhenAny"/> or <see cref="M:Task.WhenAll"/> methods.
        /// For example: <code>Assert(Task.WhenAll(tasks)).Complete();</code></para>
        /// </remarks>
        /// <exception cref="ArgumentNullException"><paramref name="task"/> (or it's value) is <c>null</c>.</exception>
        /// <exception cref="AssertionException">The <paramref name="task"/> did not complete in the alloted time.</exception>
        public static void Completes <T>(this ActualValue <T> task, int millisecondsTimeout)
            where T : Task
        {
            Argument.NotNull(task, nameof(task));
            Argument.NotNull(task.Value, nameof(task));

            task.Completes(millisecondsTimeout, null);
        }
示例#6
0
        /// <summary>
        /// Verifies that a <see cref="Task"/> is busy.
        /// </summary>
        /// <typeparam name="T">The <see cref="Task" /> type.</typeparam>
        /// <param name="task">The task to verify is busy.</param>
        /// <param name="millisecondsTimeout">The amount of time in milliseconds to wait for the <see cref="Task"/>
        /// to complete to consider it busy.</param>
        /// <param name="message">A message to display if the assertion fails. This message can
        /// be seen in the unit test results.</param>
        /// <remarks>
        /// <para>This assertion verifies that the task doesn't complete within a specified time.</para>
        /// <para>There are no overloads for working with <see cref="Task"/> collections, but you can easily
        /// make assertions by using the <see cref="M:Task.WhenAny"/> or <see cref="M:Task.WhenAll"/> methods.
        /// For example: <code>Assert(Task.WhenAll(tasks)).Complete();</code></para>
        /// </remarks>
        /// <exception cref="ArgumentNullException"><paramref name="task"/> (or it's value) is <c>null</c>.</exception>
        /// <exception cref="AssertionException">The <paramref name="task"/> did not complete in the alloted time.</exception>
        public static void IsBusy <T>(this ActualValue <T> task, int millisecondsTimeout, string message)
            where T : Task
        {
            Argument.NotNull(task, nameof(task));
            Argument.NotNull(task.Value, nameof(task));

            task.IsBusy(millisecondsTimeout, message, null);
        }
示例#7
0
        /// <summary>
        /// Verifies that the specified action throws a specific exception type.
        /// </summary>
        /// <typeparam name="T">The exception type.</typeparam>
        /// <param name="action">The exception.</param>
        /// <param name="additionalAssertion">The additional assertion.</param>
        /// <param name="message">A message to display if the assertion fails. This message can
        /// be seen in the unit test results.</param>
        /// <exception cref="ArgumentNullException"><paramref name="action"/> or it's value is <see langword="null"/>.</exception>
        public static void Throws <T>(this ActualValue <Action> action, Action <T> additionalAssertion, string message)
            where T : Exception
        {
            Argument.NotNull(action, nameof(action));
            Argument.NotNull(action.Value, nameof(action));

            action.Throws <T>(additionalAssertion, message, null);
        }
示例#8
0
        /// <summary>
        /// Verifies that a <see cref="Task"/> is busy.
        /// </summary>
        /// <typeparam name="T">The <see cref="Task" /> type.</typeparam>
        /// <param name="task">The task to verify is busy.</param>
        /// <remarks>
        /// <para>This assertion verifies that the task doesn't complete within a specified time.</para>
        /// <para>There are no overloads for working with <see cref="Task"/> collections, but you can easily
        /// make assertions by using the <see cref="M:Task.WhenAny"/> or <see cref="M:Task.WhenAll"/> methods.
        /// For example: <code>Assert(Task.WhenAll(tasks)).Complete();</code></para>
        /// </remarks>
        /// <exception cref="ArgumentNullException"><paramref name="task"/> (or it's value) is <c>null</c>.</exception>
        /// <exception cref="AssertionException">The <paramref name="task"/> did not complete in the alloted time.</exception>
        public static void IsBusy <T>(this ActualValue <T> task)
            where T : Task
        {
            Argument.NotNull(task, nameof(task));
            Argument.NotNull(task.Value, nameof(task));

            task.IsBusy(QuickTimeout, null);
        }
示例#9
0
        /// <summary>
        /// Verifies that the specified action throws a specific exception type.
        /// </summary>
        /// <typeparam name="T">The exception type.</typeparam>
        /// <param name="action">The exception.</param>
        /// <param name="message">A message to display if the assertion fails. This message can
        /// be seen in the unit test results.</param>
        /// <param name="parameters">An array of parameters to use when formatting <paramref name="message"/>.</param>
        /// <exception cref="ArgumentNullException"><paramref name="action"/> or it's value is <see langword="null"/>.</exception>
        public static void Throws <T>(this ActualValue <Action> action, string message, params object[] parameters)
            where T : Exception
        {
            Argument.NotNull(action, nameof(action));
            Argument.NotNull(action.Value, nameof(action));

            action.Throws <T>(null, message, parameters);
        }
示例#10
0
        /// <summary>
        /// Verifies that a <see cref="Task"/> is busy.
        /// </summary>
        /// <typeparam name="T">The <see cref="Task" /> type.</typeparam>
        /// <param name="task">The task to verify is busy.</param>
        /// <param name="millisecondsTimeout">The amount of time in milliseconds to wait for the <see cref="Task"/>
        /// to complete to consider it busy.</param>
        /// <param name="message">A message to display if the assertion fails. This message can
        /// be seen in the unit test results.</param>
        /// <param name="parameters">An array of parameters to use when formatting <paramref name="message" />.</param>
        /// <remarks>
        /// <para>This assertion verifies that the task doesn't complete within a specified time.</para>
        /// <para>There are no overloads for working with <see cref="Task"/> collections, but you can easily
        /// make assertions by using the <see cref="M:Task.WhenAny"/> or <see cref="M:Task.WhenAll"/> methods.
        /// For example: <code>Assert(Task.WhenAll(tasks)).Complete();</code></para>
        /// </remarks>
        /// <exception cref="ArgumentNullException"><paramref name="task"/> (or it's value) is <c>null</c>.</exception>
        /// <exception cref="AssertionException">The <paramref name="task"/> did not complete in the alloted time.</exception>
        public static void IsBusy <T>(this ActualValue <T> task, int millisecondsTimeout, string message, params object[] parameters)
            where T : Task
        {
            Argument.NotNull(task, nameof(task));
            Argument.NotNull(task.Value, nameof(task));

            if (task.Value.WaitForCompletion(millisecondsTimeout))
            {
                Throw(nameof(IsBusy), "Task completed unexpectedly.", message, parameters);
            }
        }
示例#11
0
        /// <summary>
        /// Verifies that a <see cref="Task" /> completes.
        /// </summary>
        /// <typeparam name="T">The <see cref="Task" /> type.</typeparam>
        /// <param name="task">The task to verify completes.</param>
        /// <param name="millisecondsTimeout">The amount of time in milliseconds to wait for the <see cref="Task"/> to complete.</param>
        /// <param name="message">A message to display if the assertion fails. This message can
        /// be seen in the unit test results.</param>
        /// <param name="parameters">An array of parameters to use when formatting <paramref name="message" />.</param>
        /// <remarks>
        /// <para>If this assertion fails you may have a deadlock or the task simply is taking too long
        /// to complete.</para>
        /// <para>There are no overloads for working with <see cref="Task"/> collections, but you can easily
        /// make assertions by using the <see cref="M:Task.WhenAny"/> or <see cref="M:Task.WhenAll"/> methods.
        /// For example: <code>Assert(Task.WhenAll(tasks)).Complete();</code></para>
        /// </remarks>
        /// <exception cref="ArgumentNullException"><paramref name="task"/> (or it's value) is <c>null</c>.</exception>
        /// <exception cref="AssertionException">The <paramref name="task"/> did not complete in the alloted time.</exception>
        public static void Completes <T>(this ActualValue <T> task, int millisecondsTimeout, string message, params object[] parameters)
            where T : Task
        {
            Argument.NotNull(task, nameof(task));
            Argument.NotNull(task.Value, nameof(task));

            if (!task.Value.WaitForCompletion(millisecondsTimeout))
            {
                Throw(nameof(Completes), TaskDidNotComplete(), message, parameters);
            }
        }
示例#12
0
        /// <summary>
        /// Verifies that the specified string matches the regular expression. Displays a message if the assertion
        /// fails, and applies the specified formatting to it.
        /// </summary>
        /// <param name="value">The actual value.</param>
        /// <param name="pattern">The regular expression that <paramref name="value"/> is expected to match.</param>
        /// <param name="message">A message to display if the assertion fails. This message can
        /// be seen in the unit test results.</param>
        /// <param name="parameters">An array of parameters to use when formatting <paramref name="message"/>.</param>
        /// <exception cref="ArgumentNullException"><paramref name="value"/> is <see langword="null"/>.</exception>
        /// <exception cref="AssertionException"><paramref name="value"/> does not match <paramref name="pattern"/>.</exception>
        public static void Matches(this ActualValue <string> value, Regex pattern, string message, params object[] parameters)
        {
            Argument.NotNull(value, nameof(value));

            if (pattern.IsMatch(value.Value))
            {
                return;
            }

            Throw(nameof(Matches), MatchesFailMsg(value.Value, pattern), message, parameters);
        }
示例#13
0
        /// <summary>
        /// Verifies that the string contains the specified substring. Displays a message if the assertion
        /// fails, and applies the specified formatting to it. This method is case sensitive.
        /// </summary>
        /// <param name="value">The actual value.</param>
        /// <param name="substring">The string expected to occur within <paramref name="value"/>.</param>
        /// <param name="message">A message to display if the assertion fails. This message can
        /// be seen in the unit test results.</param>
        /// <param name="parameters">An array of parameters to use when formatting <paramref name="message"/>.</param>
        /// <exception cref="ArgumentNullException"><paramref name="value"/> is <see langword="null"/>.</exception>
        /// <exception cref="AssertionException">
        ///     <paramref name="value"/> does not contain <paramref name="substring"/>.
        /// </exception>
        public static void Contains(this ActualValue <string> value, string substring, string message, params object[] parameters)
        {
            Argument.NotNull(value, nameof(value));

            if (value.Value.IndexOf(substring, StringComparison.Ordinal) >= 0)
            {
                return;
            }

            Throw(nameof(Contains), ContainsFailMsg(value.Value, substring), message, parameters);
        }
示例#14
0
        /// <summary>
        /// Verifies that the specified string starts with the specified substring. Displays a message if the assertion
        /// fails, and applies the specified formatting to it.
        /// </summary>
        /// <param name="value">The actual value.</param>
        /// <param name="substring">The string expected to be a suffix of <paramref name="value"/>.</param>
        /// <param name="message">A message to display if the assertion fails. This message can
        /// be seen in the unit test results.</param>
        /// <param name="parameters">An array of parameters to use when formatting <paramref name="message"/>.</param>
        /// <exception cref="ArgumentNullException"><paramref name="value"/> is <see langword="null"/>.</exception>
        /// <exception cref="AssertionException">
        ///     <paramref name="value"/> does not start with <paramref name="substring"/>.
        /// </exception>
        public static void StartsWith(this ActualValue <string> value, string substring, string message, params object[] parameters)
        {
            Argument.NotNull(value, nameof(value));

            if (value.Value.StartsWith(substring, StringComparison.Ordinal))
            {
                return;
            }

            Throw(nameof(StartsWith), StartsWithFailMsg(value.Value, substring), message, parameters);
        }
示例#15
0
        /// <summary>
        /// Verifies that the specified string ends with the specified substring. Displays a message if the assertion
        /// fails, and applies the specified formatting to it.
        /// </summary>
        /// <param name="value">The actual value.</param>
        /// <param name="substring">The string expected to be a suffix of <paramref name="value"/>.</param>
        /// <exception cref="ArgumentNullException"><paramref name="value"/> is <see langword="null"/>.</exception>
        /// <exception cref="AssertionException">
        ///     <paramref name="value"/> does not end with <paramref name="substring"/>.
        /// </exception>
        public static void EndsWith(this ActualValue <string> value, string substring)
        {
            Argument.NotNull(value, nameof(value));

            value.EndsWith(substring, null, null);
        }
示例#16
0
        /// <summary>
        /// Verifies that the specified string matches the regular expression. Displays a message if the assertion
        /// fails, and applies the specified formatting to it.
        /// </summary>
        /// <param name="value">The actual value.</param>
        /// <param name="pattern">The regular expression that <paramref name="value"/> is expected to match.</param>
        /// <param name="message">A message to display if the assertion fails. This message can
        /// be seen in the unit test results.</param>
        /// <exception cref="ArgumentNullException"><paramref name="value"/> is <see langword="null"/>.</exception>
        /// <exception cref="AssertionException">
        ///     <paramref name="value"/> does not match <paramref name="pattern"/>.
        /// </exception>
        public static void Matches(this ActualValue <string> value, Regex pattern, string message)
        {
            Argument.NotNull(value, nameof(value));

            value.Matches(pattern, message, null);
        }
示例#17
0
        /// <summary>
        /// Verifies that the specified string does not match the regular expression. Displays a message if the
        /// assertion fails, and applies the specified formatting to it.
        /// </summary>
        /// <param name="value">The actual value.</param>
        /// <param name="pattern">The regular expression that <paramref name="value"/> is not expected to match.</param>
        /// <exception cref="ArgumentNullException"><paramref name="value"/> is <see langword="null"/>.</exception>
        /// <exception cref="AssertionException"><paramref name="value"/> matches <paramref name="pattern"/>.</exception>
        public static void DoesNotMatch(this ActualValue <string> value, Regex pattern)
        {
            Argument.NotNull(value, nameof(value));

            value.DoesNotMatch(pattern, null, null);
        }
示例#18
0
        /// <summary>
        /// Verifies that the string contains the specified substring. Displays a message if the assertion
        /// fails, and applies the specified formatting to it. This method is case sensitive.
        /// </summary>
        /// <param name="value">The actual value.</param>
        /// <param name="substring">The string expected to occur within <paramref name="value"/>.</param>
        /// <param name="message">A message to display if the assertion fails. This message can
        /// be seen in the unit test results.</param>
        /// <exception cref="ArgumentNullException"><paramref name="value"/> is <see langword="null"/>.</exception>
        /// <exception cref="AssertionException">
        ///     <paramref name="value"/> does not contain <paramref name="substring"/>.
        /// </exception>
        public static void Contains(this ActualValue <string> value, string substring, string message)
        {
            Argument.NotNull(value, nameof(value));

            value.Contains(substring, message, (object[])null);
        }
示例#19
0
        /// <summary>
        /// Verifies that the specified string starts with the specified substring. Displays a message if the assertion
        /// fails, and applies the specified formatting to it.
        /// </summary>
        /// <param name="value">The actual value.</param>
        /// <param name="substring">The string expected to be a suffix of <paramref name="value"/>.</param>
        /// <param name="message">A message to display if the assertion fails. This message can
        /// be seen in the unit test results.</param>
        /// <exception cref="ArgumentNullException"><paramref name="value"/> is <see langword="null"/>.</exception>
        /// <exception cref="AssertionException">
        ///     <paramref name="value"/> does not start with <paramref name="substring"/>.
        /// </exception>
        public static void StartsWith(this ActualValue <string> value, string substring, string message)
        {
            Argument.NotNull(value, nameof(value));

            value.StartsWith(substring, message, null);
        }