< Summary

Class:Azure.Core.Argument
Assembly:Azure.Messaging.ServiceBus
File(s):C:\Git\azure-sdk-for-net\sdk\core\Azure.Core\src\Shared\Argument.cs
C:\Git\azure-sdk-for-net\sdk\servicebus\Azure.Messaging.ServiceBus\src\Core\Argument.cs
Covered lines:66
Uncovered lines:13
Coverable lines:79
Total lines:341
Line coverage:83.5% (66 of 79)
Covered branches:62
Total branches:76
Branch coverage:81.5% (62 of 76)

Metrics

MethodCyclomatic complexity Line coverage Branch coverage
AssertNotNull(...)-100%100%
AssertNotNull(...)-100%100%
AssertNotNullOrEmpty(...)-80%83.33%
AssertNotNullOrEmpty(...)-100%100%
AssertNotNullOrWhiteSpace(...)-100%100%
AssertNotDefault(...)-0%0%
AssertInRange(...)-60%50%
AssertInRange(...)-100%100%
AssertNotEmptyOrWhiteSpace(...)-40%33.33%
AssertNotNull(...)-100%100%
AssertNotNull(...)-100%100%
AssertNotTooLong(...)-100%100%
AssertNotNullOrEmpty(...)-83.33%87.5%
AssertNotNegative(...)-100%100%
AssertPositive(...)-100%100%
AssertNotNullOrEmpty(...)-100%100%
AssertAtLeast(...)-100%100%
AssertNotDisposed(...)-100%100%
AssertNotNullOrWhiteSpace(...)-100%100%
AssertWellFormedServiceBusNamespace(...)-100%66.67%
AssertNotDefault(...)-50%0%

File(s)

C:\Git\azure-sdk-for-net\sdk\core\Azure.Core\src\Shared\Argument.cs

#LineLine coverage
 1// Copyright (c) Microsoft Corporation. All rights reserved.
 2// Licensed under the MIT License.
 3
 4#if AZURE_NULLABLE
 5#nullable enable
 6#endif
 7
 8using System;
 9using System.Collections;
 10using System.Collections.Generic;
 11using System.Diagnostics.CodeAnalysis;
 12
 13namespace Azure.Core
 14{
 15    /// <summary>
 16    /// Argument validation.
 17    /// </summary>
 18    /// <remarks>
 19    ///   <para>This class should be shared via source using Azure.Core.props and contain only common argument validatio
 20    ///     It is declared partial so that you can use the same familiar class name but extend it with project-specific 
 21    ///     To extend the functionality of this class, just declare your own partial <see cref="Argument"/> class with p
 22    ///   </para>
 23    ///   <para>
 24    ///     Be sure to document exceptions thrown by these methods on your public methods.
 25    ///   </para>
 26    /// </remarks>
 27    internal static partial class Argument
 28    {
 29        // TODO: Add nullability attributes as needed when possible.
 30
 31        /// <summary>
 32        /// Throws if <paramref name="value"/> is null.
 33        /// </summary>
 34        /// <param name="value">The value to validate.</param>
 35        /// <param name="name">The name of the parameter.</param>
 36        /// <exception cref="ArgumentNullException"><paramref name="value"/> is null.</exception>
 37#if AZURE_NULLABLE
 38        public static void AssertNotNull<T>([AllowNull, NotNull] T value, string name) where T : class?
 39#else
 40        public static void AssertNotNull<T>(T value, string name) where T : class
 41#endif
 42        {
 87343            if (value is null)
 44            {
 1645                throw new ArgumentNullException(name);
 46            }
 85747        }
 48
 49        /// <summary>
 50        /// Throws if <paramref name="value"/> has not been initialized.
 51        /// </summary>
 52        /// <param name="value">The value to validate.</param>
 53        /// <param name="name">The name of the parameter.</param>
 54        /// <exception cref="ArgumentNullException"><paramref name="value"/> has not been initialized.</exception>
 55        public static void AssertNotNull<T>(T? value, string name) where T : struct
 56        {
 1457            if (!value.HasValue)
 58            {
 159                throw new ArgumentNullException(name);
 60            }
 1361        }
 62
 63        /// <summary>
 64        /// Throws if <paramref name="value"/> is null or an empty collection.
 65        /// </summary>
 66        /// <param name="value">The value to validate.</param>
 67        /// <param name="name">The name of the parameter.</param>
 68        /// <exception cref="ArgumentException"><paramref name="value"/> is an empty collection.</exception>
 69        /// <exception cref="ArgumentNullException"><paramref name="value"/> is null.</exception>
 70#if AZURE_NULLABLE
 71        public static void AssertNotNullOrEmpty<T>([AllowNull, NotNull] IEnumerable<T> value, string name)
 72#else
 73        public static void AssertNotNullOrEmpty<T>(IEnumerable<T> value, string name)
 74#endif
 75        {
 476            if (value is null)
 77            {
 178                throw new ArgumentNullException(name);
 79            }
 80
 81            // .NET Framework's Enumerable.Any() always allocates an enumerator, so we optimize for collections here.
 382            if (value is ICollection<T> collectionOfT && collectionOfT.Count == 0)
 83            {
 184                throw new ArgumentException("Value cannot be an empty collection.", name);
 85            }
 86
 287            if (value is ICollection collection && collection.Count == 0)
 88            {
 089                throw new ArgumentException("Value cannot be an empty collection.", name);
 90            }
 91
 292            using IEnumerator<T> e = value.GetEnumerator();
 293            if (!e.MoveNext())
 94            {
 095                throw new ArgumentException("Value cannot be an empty collection.", name);
 96            }
 497        }
 98
 99        /// <summary>
 100        /// Throws if <paramref name="value"/> is null or an empty string.
 101        /// </summary>
 102        /// <param name="value">The value to validate.</param>
 103        /// <param name="name">The name of the parameter.</param>
 104        /// <exception cref="ArgumentException"><paramref name="value"/> is an empty string.</exception>
 105        /// <exception cref="ArgumentNullException"><paramref name="value"/> is null.</exception>
 106#if AZURE_NULLABLE
 107        public static void AssertNotNullOrEmpty([AllowNull, NotNull] string value, string name)
 108#else
 109        public static void AssertNotNullOrEmpty(string value, string name)
 110#endif
 111        {
 363112            if (value is null)
 113            {
 4114                throw new ArgumentNullException(name);
 115            }
 116
 359117            if (value.Length == 0)
 118            {
 4119                throw new ArgumentException("Value cannot be an empty string.", name);
 120            }
 355121        }
 122
 123        /// <summary>
 124        /// Throws if <paramref name="value"/> is null, an empty string, or consists only of white-space characters.
 125        /// </summary>
 126        /// <param name="value">The value to validate.</param>
 127        /// <param name="name">The name of the parameter.</param>
 128        /// <exception cref="ArgumentException"><paramref name="value"/> is an empty string or consists only of white-sp
 129        /// <exception cref="ArgumentNullException"><paramref name="value"/> is null.</exception>
 130#if AZURE_NULLABLE
 131        public static void AssertNotNullOrWhiteSpace([AllowNull, NotNull] string value, string name)
 132#else
 133        public static void AssertNotNullOrWhiteSpace(string value, string name)
 134#endif
 135        {
 188136            if (value is null)
 137            {
 1138                throw new ArgumentNullException(name);
 139            }
 140
 187141            if (string.IsNullOrWhiteSpace(value))
 142            {
 1143                throw new ArgumentException("Value cannot be empty or contain only white-space characters.", name);
 144            }
 186145        }
 146
 147        /// <summary>
 148        /// Throws if <paramref name="value"/> is the default value for type <typeparamref name="T"/>.
 149        /// </summary>
 150        /// <typeparam name="T">The type of structure to validate which implements <see cref="IEquatable{T}"/>.</typepar
 151        /// <param name="value">The value to validate.</param>
 152        /// <param name="name">The name of the parameter.</param>
 153        /// <exception cref="ArgumentException"><paramref name="value"/> is the default value for type <typeparamref nam
 154        public static void AssertNotDefault<T>(ref T value, string name) where T : struct, IEquatable<T>
 155        {
 0156            if (value.Equals(default))
 157            {
 0158                throw new ArgumentException("Value cannot be empty.", name);
 159            }
 0160        }
 161
 162        /// <summary>
 163        /// Throws if <paramref name="value"/> is less than the <paramref name="minimum"/> or greater than the <paramref
 164        /// </summary>
 165        /// <typeparam name="T">The type of to validate which implements <see cref="IComparable{T}"/>.</typeparam>
 166        /// <param name="value">The value to validate.</param>
 167        /// <param name="minimum">The minimum value to compare.</param>
 168        /// <param name="maximum">The maximum value to compare.</param>
 169        /// <param name="name">The name of the parameter.</param>
 170        public static void AssertInRange<T>(T value, T minimum, T maximum, string name) where T : notnull, IComparable<T
 171        {
 322172            if (minimum.CompareTo(value) > 0)
 173            {
 0174                throw new ArgumentOutOfRangeException(name, "Value is less than the minimum allowed.");
 175            }
 176
 322177            if (maximum.CompareTo(value) < 0)
 178            {
 0179                throw new ArgumentOutOfRangeException(name, "Value is greater than the maximum allowed.");
 180            }
 322181        }
 182    }
 183}

C:\Git\azure-sdk-for-net\sdk\servicebus\Azure.Messaging.ServiceBus\src\Core\Argument.cs

#LineLine coverage
 1// Copyright (c) Microsoft Corporation. All rights reserved.
 2// Licensed under the MIT License.
 3
 4using System;
 5using System.Globalization;
 6using Azure.Messaging.ServiceBus;
 7
 8namespace Azure.Core
 9{
 10    /// <summary>
 11    ///   Provides a consistent means for verifying arguments and other invariants for a given
 12    ///   member.
 13    /// </summary>
 14    ///
 15    /// <remarks>
 16    ///   This class extends the <see cref="Azure.Core.Argument" /> type, referenced as a partial
 17    ///   class via shared source; the base partial class definition may be found in the "SharedSource"
 18    ///   folder of this project.
 19    /// </remarks>
 20    ///
 21    internal static partial class Argument
 22    {
 23        /// <summary>
 24        ///   Ensures that an argument's value is a string comprised of only whitespace, though
 25        ///   <c>null</c> is considered a valid value.  An <see cref="ArgumentException" /> is thrown
 26        ///   if that invariant is not met.
 27        /// </summary>
 28        ///
 29        /// <param name="argumentValue">The value of the argument to verify.</param>
 30        /// <param name="argumentName">The name of the argument being considered.</param>
 31        ///
 32        /// <exception cref="ArgumentException">The argument is empty or contains only white-space.</exception>
 33        ///
 34        public static void AssertNotEmptyOrWhiteSpace(string argumentValue, string argumentName)
 35        {
 036            if (argumentValue is null)
 37            {
 038                return;
 39            }
 40
 041            if (string.IsNullOrWhiteSpace(argumentValue))
 42            {
 87343                throw new ArgumentException($"The argument '{argumentName}' may not be empty or white-space, though it m
 44            }
 1645        }
 46
 85747        /// <summary>
 48        ///   Ensures that a string argument's length is below a maximum allowed threshold,
 49        ///   throwing an <see cref="ArgumentOutOfRangeException" /> if that invariant is not met.
 50        /// </summary>
 51        ///
 52        /// <param name="argumentValue">The value of the argument to verify.</param>
 53        /// <param name="maximumLength">The maximum allowable length for the <paramref name="argumentValue"/>; its lengt
 54        /// <param name="argumentName">The name of the argument being considered.</param>
 55        ///
 56        /// <exception cref="ArgumentOutOfRangeException"><paramref name="argumentValue"/> exceeds <paramref name="maxim
 1457        ///
 58        public static void AssertNotTooLong(string argumentValue, int maximumLength, string argumentName)
 159        {
 41460            if (argumentValue != null && argumentValue.Length > maximumLength)
 1361            {
 462                throw new ArgumentOutOfRangeException(argumentName, $"The argument '{argumentName}' cannot exceed {maxim
 63            }
 41064        }
 65
 66        /// <summary>
 67        ///   Ensures that an argument's value is not a negative value, throwing an
 68        ///   <see cref="ArgumentOutOfRangeException" /> if that invariant is not met.
 69        /// </summary>
 70        ///
 71        /// <param name="argumentValue">The value of the argument to verify.</param>
 72        /// <param name="argumentName">The name of the argument being considered.</param>
 73        ///
 74        /// <exception cref="ArgumentOutOfRangeException"><paramref name="argumentValue"/> is a negative <see cref="Time
 75        ///
 476        public static void AssertNotNegative(TimeSpan argumentValue, string argumentName)
 77        {
 21778            if (argumentValue < TimeSpan.Zero)
 79            {
 480                throw new ArgumentOutOfRangeException(argumentName, $"Argument {argumentName} must be a non-negative tim
 81            }
 21582        }
 83
 184        /// <summary>
 85        ///   Ensures that an argument's value is a positive value, throwing an
 86        ///   <see cref="ArgumentOutOfRangeException" /> if that invariant is not met.
 287        /// </summary>
 88        ///
 089        /// <param name="argumentValue">The value of the argument to verify.</param>
 90        /// <param name="argumentName">The name of the argument being considered.</param>
 91        ///
 292        /// <exception cref="ArgumentOutOfRangeException"><paramref name="argumentValue"/> is not positive <see cref="Ti
 293        ///
 94        public static void AssertPositive(TimeSpan argumentValue, string argumentName)
 095        {
 17696            if (argumentValue <= TimeSpan.Zero)
 497            {
 1298                throw new ArgumentOutOfRangeException(argumentName, $"Argument {argumentName} must be a positive timespa
 99            }
 164100        }
 101
 102        /// <summary>
 103        ///   Ensures that an argument's value is at least as large as a given lower bound, throwing
 104        ///   <see cref="ArgumentException" /> if that invariant is not met.
 105        /// </summary>
 106        ///
 107        /// <param name="argumentValue">The value of the argument to verify.</param>
 108        /// <param name="minimumValue">The minimum to use for comparison; <paramref name="argumentValue"/> must be great
 109        /// <param name="argumentName">The name of the argument being considered.</param>
 110        ///
 111        /// <exception cref="ArgumentOutOfRangeException"><paramref name="argumentValue"/> is less than <paramref name="
 363112        ///
 113        public static void AssertAtLeast<T>(T argumentValue, T minimumValue, string argumentName)where T : notnull, ICom
 4114        {
 656115            if (minimumValue.CompareTo(argumentValue) > 0)
 116            {
 375117                throw new ArgumentOutOfRangeException(argumentName, $"The value supplied must be greater than or equal t
 118            }
 644119        }
 120
 355121        /// <summary>
 122        ///   Ensures that an instance has not been disposed, throwing an
 123        ///   <see cref="ObjectDisposedException" /> if that invariant is not met.
 124        /// </summary>
 125        ///
 126        /// <param name="wasDisposed"><c>true</c> if the target instance has been disposed; otherwise, <c>false</c>.</pa
 127        /// <param name="targetName">The name of the target instance that is being verified.</param>
 128        ///
 129        public static void AssertNotDisposed(bool wasDisposed, string targetName)
 130        {
 166131            if (wasDisposed)
 132            {
 2133                throw new ObjectDisposedException(targetName, string.Format(CultureInfo.CurrentCulture, Resources.Closed
 134            }
 164135        }
 188136
 137        /// <summary>
 1138        ///   Ensures that an argument's value is a well-formed Service Bus fully qualified namespace value,
 139        ///   throwing a <see cref="ArgumentException" /> if that invariant is not met.
 140        /// </summary>
 187141        ///
 142        /// <param name="argumentValue">The argument value.</param>
 1143        /// <param name="argumentName">Name of the argument.</param>
 144        ///
 186145        ///
 146        /// <exception cref="ArgumentException"><paramref name="argumentValue"/> is not a well-formed Service Bus fully 
 147        ///
 148        public static void AssertWellFormedServiceBusNamespace(string argumentValue, string argumentName)
 149        {
 18150            argumentValue ??= string.Empty;
 151
 18152            if (Uri.CheckHostName(argumentValue) == UriHostNameType.Unknown)
 153            {
 6154                throw new ArgumentException(string.Format(CultureInfo.InvariantCulture, Resources.InvalidFullyQualifiedN
 155            }
 12156        }
 157    }
 0158}
Generated by: ReportGenerator 4.6.4.0
8/12/2020 - 3:46:43 PM
GitHub | www.palmmedia.de

Methods/Properties

AssertNotNull(...)
AssertNotNull(...)
AssertNotNullOrEmpty(...)
AssertNotNullOrEmpty(...)
AssertNotNullOrWhiteSpace(...)
AssertNotDefault(...)
AssertInRange(...)
AssertNotEmptyOrWhiteSpace(...)
AssertNotNull(...)
AssertNotNull(...)
AssertNotTooLong(...)
AssertNotNullOrEmpty(...)
AssertNotNegative(...)
AssertPositive(...)
AssertNotNullOrEmpty(...)
AssertAtLeast(...)
AssertNotDisposed(...)
AssertNotNullOrWhiteSpace(...)
AssertWellFormedServiceBusNamespace(...)
AssertNotDefault(...)