Rename to WireMock.Net

src/WireMock.Net/Validation/Check.cs

@@ -0,0 +1,143 @@
+// Copyright (c) .NET Foundation. All rights reserved.
+// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
+
+using System;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.Diagnostics.CodeAnalysis;
+using System.Linq;
+using System.Reflection;
+using JetBrains.Annotations;
+
+// Copied from https://github.com/aspnet/EntityFramework/blob/dev/src/Shared/Check.cs
+namespace WireMock.Validation
+{
+    [ExcludeFromCodeCoverage]
+    [DebuggerStepThrough]
+    internal static class Check
+    {
+        [ContractAnnotation("value:null => halt")]
+        public static T Condition<T>([NoEnumeration] T value, [NotNull] Predicate<T> condition, [InvokerParameterName] [NotNull] string parameterName)
+        {
+            NotNull(condition, nameof(condition));
+            NotNull(value, nameof(value));
+
+            if (!condition(value))
+            {
+                NotEmpty(parameterName, nameof(parameterName));
+
+                throw new ArgumentOutOfRangeException(parameterName);
+            }
+
+            return value;
+        }
+
+        [ContractAnnotation("value:null => halt")]
+        public static T NotNull<T>([NoEnumeration] T value, [InvokerParameterName] [NotNull] string parameterName)
+        {
+            if (ReferenceEquals(value, null))
+            {
+                NotEmpty(parameterName, nameof(parameterName));
+
+                throw new ArgumentNullException(parameterName);
+            }
+
+            return value;
+        }
+
+        [ContractAnnotation("value:null => halt")]
+        public static T NotNull<T>(
+            [NoEnumeration] T value,
+            [InvokerParameterName] [NotNull] string parameterName,
+            [NotNull] string propertyName)
+        {
+            if (ReferenceEquals(value, null))
+            {
+                NotEmpty(parameterName, nameof(parameterName));
+                NotEmpty(propertyName, nameof(propertyName));
+
+                throw new ArgumentException(CoreStrings.ArgumentPropertyNull(propertyName, parameterName));
+            }
+
+            return value;
+        }
+
+        [ContractAnnotation("value:null => halt")]
+        public static IList<T> NotEmpty<T>(IList<T> value, [InvokerParameterName] [NotNull] string parameterName)
+        {
+            NotNull(value, parameterName);
+
+            if (value.Count == 0)
+            {
+                NotEmpty(parameterName, nameof(parameterName));
+
+                throw new ArgumentException(CoreStrings.CollectionArgumentIsEmpty(parameterName));
+            }
+
+            return value;
+        }
+
+        [ContractAnnotation("value:null => halt")]
+        public static string NotEmpty(string value, [InvokerParameterName] [NotNull] string parameterName)
+        {
+            Exception e = null;
+            if (ReferenceEquals(value, null))
+            {
+                e = new ArgumentNullException(parameterName);
+            }
+            else if (value.Trim().Length == 0)
+            {
+                e = new ArgumentException(CoreStrings.ArgumentIsEmpty(parameterName));
+            }
+
+            if (e != null)
+            {
+                NotEmpty(parameterName, nameof(parameterName));
+
+                throw e;
+            }
+
+            return value;
+        }
+
+        public static string NullButNotEmpty(string value, [InvokerParameterName] [NotNull] string parameterName)
+        {
+            if (!ReferenceEquals(value, null)
+                && (value.Length == 0))
+            {
+                NotEmpty(parameterName, nameof(parameterName));
+
+                throw new ArgumentException(CoreStrings.ArgumentIsEmpty(parameterName));
+            }
+
+            return value;
+        }
+
+        public static IList<T> HasNoNulls<T>(IList<T> value, [InvokerParameterName] [NotNull] string parameterName)
+            where T : class
+        {
+            NotNull(value, parameterName);
+
+            if (value.Any(e => e == null))
+            {
+                NotEmpty(parameterName, nameof(parameterName));
+
+                throw new ArgumentException(parameterName);
+            }
+
+            return value;
+        }
+
+        public static Type ValidEntityType(Type value, [InvokerParameterName] [NotNull] string parameterName)
+        {
+            if (!value.GetTypeInfo().IsClass)
+            {
+                NotEmpty(parameterName, nameof(parameterName));
+
+                throw new ArgumentException(CoreStrings.InvalidEntityType(value, parameterName));
+            }
+
+            return value;
+        }
+    }
+}

src/WireMock.Net/Validation/CoreStrings.cs

@@ -0,0 +1,44 @@
+using System;
+using System.Diagnostics.CodeAnalysis;
+using System.Globalization;
+using JetBrains.Annotations;
+
+// copied from https://github.com/aspnet/EntityFramework/blob/dev/src/Microsoft.EntityFrameworkCore/Properties/CoreStrings.resx
+namespace WireMock.Validation
+{
+    [ExcludeFromCodeCoverage]
+    internal static class CoreStrings
+    {
+        /// <summary>
+        /// The property '{property}' of the argument '{argument}' cannot be null.
+        /// </summary>
+        public static string ArgumentPropertyNull([CanBeNull] string property, [CanBeNull] string argument)
+        {
+            return string.Format(CultureInfo.CurrentCulture, $"The property '{property}' of the argument '{argument}' cannot be null.", property, argument);
+        }
+
+        /// <summary>
+        /// The string argument '{argumentName}' cannot be empty.
+        /// </summary>
+        public static string ArgumentIsEmpty([CanBeNull] string argumentName)
+        {
+            return string.Format(CultureInfo.CurrentCulture, $"The string argument '{argumentName}' cannot be empty.", argumentName);
+        }
+
+        /// <summary>
+        /// The entity type '{type}' provided for the argument '{argumentName}' must be a reference type.
+        /// </summary>
+        public static string InvalidEntityType([CanBeNull] Type type, [CanBeNull] string argumentName)
+        {
+            return string.Format(CultureInfo.CurrentCulture, $"The entity type '{type}' provided for the argument '{argumentName}' must be a reference type.", type, argumentName);
+        }
+
+        /// <summary>
+        /// The collection argument '{argumentName}' must contain at least one element.
+        /// </summary>
+        public static string CollectionArgumentIsEmpty([CanBeNull] string argumentName)
+        {
+            return string.Format(CultureInfo.CurrentCulture, $"The collection argument '{argumentName}' must contain at least one element.", argumentName);
+        }
+    }
+}