diff --git a/appveyor.yml b/appveyor.yml index 7346875..0552d70 100644 --- a/appveyor.yml +++ b/appveyor.yml @@ -1,6 +1,6 @@ # configuration for "non-master" branches - - image: Visual Studio 2017 + image: Visual Studio 2019 branches: except: - master @@ -26,7 +26,7 @@ # configuration for "master" branch - - image: Visual Studio 2017 + image: Visual Studio 2019 branches: only: - master @@ -52,4 +52,4 @@ - path: '**/*.binlog' test: off on_failure: - - ps: Get-ChildItem *.binlog -recurse | % { Push-AppveyorArtifact $_.FullName -FileName $_.Name } \ No newline at end of file + - ps: Get-ChildItem *.binlog -recurse | % { Push-AppveyorArtifact $_.FullName -FileName $_.Name } diff --git a/src/ApiGeneratorGlobalSuppressions.cs b/src/ApiGeneratorGlobalSuppressions.cs index 867404d..4b4ecb1 100644 --- a/src/ApiGeneratorGlobalSuppressions.cs +++ b/src/ApiGeneratorGlobalSuppressions.cs @@ -1,6 +1,5 @@ -// Copyright (c) 2019 .NET Foundation and Contributors. All rights reserved. -// Licensed to the .NET Foundation under one or more agreements. -// The .NET Foundation licenses this file to you under the MIT license. +// Copyright (c) 2019 dpvreony and Contributors. All rights reserved. +// This file is licensed to you under the MIT license. // See the LICENSE file in the project root for full license information. [assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("StyleCop.CSharp.LayoutRules", "SA1503:Braces should not be omitted", Justification = "NuGet Inclusion", Scope = "member", Target = "~M:PublicApiGenerator.ApiGenerator.AddCtorToTypeDeclaration(System.CodeDom.CodeTypeDeclaration,Mono.Cecil.MethodDefinition,System.Collections.Generic.HashSet{System.String})")] diff --git a/src/Directory.build.props b/src/Directory.build.props index 3ba022f..dddd0c2 100644 --- a/src/Directory.build.props +++ b/src/Directory.build.props @@ -33,7 +33,7 @@ - + @@ -45,11 +45,11 @@ - + - + diff --git a/src/NetTestRegimentation.Moq/ITestAsyncMethodWithMoqNullableParameters.cs b/src/NetTestRegimentation.Moq/ITestAsyncMethodWithMoqNullableParameters.cs index 4729ffc..849799e 100644 --- a/src/NetTestRegimentation.Moq/ITestAsyncMethodWithMoqNullableParameters.cs +++ b/src/NetTestRegimentation.Moq/ITestAsyncMethodWithMoqNullableParameters.cs @@ -1,12 +1,18 @@ -namespace NetTestRegimentation.Moq +// Copyright (c) 2019 dpvreony and Contributors. All rights reserved. +// This file is licensed to you under the MIT license. +// See the LICENSE file in the project root for full license information. + +namespace NetTestRegimentation.Moq { +#pragma warning disable SA1402 // File may only contain a single type + /// public interface ITestAsyncMethodWithMoqNullableParameters : ITestAsyncMethodWithNullableParameters> where TArg : class { - } + /// public interface ITestAsyncMethodWithMoqNullableParameters< TArg1, TArg2> @@ -16,9 +22,9 @@ public interface ITestAsyncMethodWithMoqNullableParameters< where TArg1 : class where TArg2 : class { - } + /// public interface ITestAsyncMethodWithMoqNullableParameters< TArg1, TArg2, @@ -31,9 +37,9 @@ public interface ITestAsyncMethodWithMoqNullableParameters< where TArg2 : class where TArg3 : class { - } + /// public interface ITestAsyncMethodWithMoqNullableParameters< TArg1, TArg2, @@ -49,9 +55,9 @@ public interface ITestAsyncMethodWithMoqNullableParameters< where TArg3 : class where TArg4 : class { - } + /// public interface ITestAsyncMethodWithMoqNullableParameters< TArg1, TArg2, @@ -70,9 +76,9 @@ public interface ITestAsyncMethodWithMoqNullableParameters< where TArg4 : class where TArg5 : class { - } + /// public interface ITestAsyncMethodWithMoqNullableParameters< TArg1, TArg2, @@ -94,9 +100,9 @@ public interface ITestAsyncMethodWithMoqNullableParameters< where TArg5 : class where TArg6 : class { - } + /// public interface ITestAsyncMethodWithMoqNullableParameters< TArg1, TArg2, @@ -121,9 +127,9 @@ public interface ITestAsyncMethodWithMoqNullableParameters< where TArg6 : class where TArg7 : class { - } + /// public interface ITestAsyncMethodWithMoqNullableParameters< TArg1, TArg2, @@ -151,9 +157,9 @@ public interface ITestAsyncMethodWithMoqNullableParameters< where TArg7 : class where TArg8 : class { - } + /// public interface ITestAsyncMethodWithMoqNullableParameters< TArg1, TArg2, @@ -184,9 +190,9 @@ public interface ITestAsyncMethodWithMoqNullableParameters< where TArg8 : class where TArg9 : class { - } + /// public interface ITestAsyncMethodWithMoqNullableParameters< TArg1, TArg2, @@ -220,9 +226,9 @@ public interface ITestAsyncMethodWithMoqNullableParameters< where TArg9 : class where TArg10 : class { - } + /// public interface ITestAsyncMethodWithMoqNullableParameters< TArg1, TArg2, @@ -259,9 +265,9 @@ public interface ITestAsyncMethodWithMoqNullableParameters< where TArg10 : class where TArg11 : class { - } + /// public interface ITestAsyncMethodWithMoqNullableParameters< TArg1, TArg2, @@ -301,9 +307,9 @@ public interface ITestAsyncMethodWithMoqNullableParameters< where TArg11 : class where TArg12 : class { - } + /// public interface ITestAsyncMethodWithMoqNullableParameters< TArg1, TArg2, @@ -346,9 +352,9 @@ public interface ITestAsyncMethodWithMoqNullableParameters< where TArg12 : class where TArg13 : class { - } + /// public interface ITestAsyncMethodWithMoqNullableParameters< TArg1, TArg2, @@ -394,9 +400,9 @@ public interface ITestAsyncMethodWithMoqNullableParameters< where TArg13 : class where TArg14 : class { - } + /// public interface ITestAsyncMethodWithMoqNullableParameters< TArg1, TArg2, @@ -445,9 +451,9 @@ public interface ITestAsyncMethodWithMoqNullableParameters< where TArg14 : class where TArg15 : class { - } + /// public interface ITestAsyncMethodWithMoqNullableParameters< TArg1, TArg2, @@ -497,8 +503,8 @@ public interface ITestAsyncMethodWithMoqNullableParameters< where TArg13 : class where TArg14 : class where TArg15 : class - where TArg16: class + where TArg16 : class { - } -} \ No newline at end of file +#pragma warning restore SA1402 // File may only contain a single type +} diff --git a/src/NetTestRegimentation.Moq/ITestAsyncMethodWithMoqParameterValidation.cs b/src/NetTestRegimentation.Moq/ITestAsyncMethodWithMoqParameterValidation.cs index 2df4747..c2a5151 100644 --- a/src/NetTestRegimentation.Moq/ITestAsyncMethodWithMoqParameterValidation.cs +++ b/src/NetTestRegimentation.Moq/ITestAsyncMethodWithMoqParameterValidation.cs @@ -1,7 +1,510 @@ -namespace NetTestRegimentation.Moq +// Copyright (c) 2019 dpvreony and Contributors. All rights reserved. +// This file is licensed to you under the MIT license. +// See the LICENSE file in the project root for full license information. + +namespace NetTestRegimentation.Moq { - public interface ITestAsyncMethodWithMoqParameterValidation +#pragma warning disable SA1402 // File may only contain a single type + /// + public interface ITestAsyncMethodWithMoqParameterValidation + : ITestAsyncMethodWithParameterValidation> + where TArg : class { - } -} \ No newline at end of file + + /// + public interface ITestAsyncMethodWithMoqParameterValidation< + TArg1, + TArg2> + : ITestAsyncMethodWithParameterValidation< + global::Moq.Mock, + global::Moq.Mock> + where TArg1 : class + where TArg2 : class + { + } + + /// + public interface ITestAsyncMethodWithMoqParameterValidation< + TArg1, + TArg2, + TArg3> + : ITestAsyncMethodWithParameterValidation< + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock> + where TArg1 : class + where TArg2 : class + where TArg3 : class + { + } + + /// + public interface ITestAsyncMethodWithMoqParameterValidation< + TArg1, + TArg2, + TArg3, + TArg4> + : ITestAsyncMethodWithParameterValidation< + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock> + where TArg1 : class + where TArg2 : class + where TArg3 : class + where TArg4 : class + { + } + + /// + public interface ITestAsyncMethodWithMoqParameterValidation< + TArg1, + TArg2, + TArg3, + TArg4, + TArg5> + : ITestAsyncMethodWithParameterValidation< + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock> + where TArg1 : class + where TArg2 : class + where TArg3 : class + where TArg4 : class + where TArg5 : class + { + } + + /// + public interface ITestAsyncMethodWithMoqParameterValidation< + TArg1, + TArg2, + TArg3, + TArg4, + TArg5, + TArg6> + : ITestAsyncMethodWithParameterValidation< + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock> + where TArg1 : class + where TArg2 : class + where TArg3 : class + where TArg4 : class + where TArg5 : class + where TArg6 : class + { + } + + /// + public interface ITestAsyncMethodWithMoqParameterValidation< + TArg1, + TArg2, + TArg3, + TArg4, + TArg5, + TArg6, + TArg7> + : ITestAsyncMethodWithParameterValidation< + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock> + where TArg1 : class + where TArg2 : class + where TArg3 : class + where TArg4 : class + where TArg5 : class + where TArg6 : class + where TArg7 : class + { + } + + /// + public interface ITestAsyncMethodWithMoqParameterValidation< + TArg1, + TArg2, + TArg3, + TArg4, + TArg5, + TArg6, + TArg7, + TArg8> + : ITestAsyncMethodWithParameterValidation< + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock> + where TArg1 : class + where TArg2 : class + where TArg3 : class + where TArg4 : class + where TArg5 : class + where TArg6 : class + where TArg7 : class + where TArg8 : class + { + } + + /// + public interface ITestAsyncMethodWithMoqParameterValidation< + TArg1, + TArg2, + TArg3, + TArg4, + TArg5, + TArg6, + TArg7, + TArg8, + TArg9> + : ITestAsyncMethodWithParameterValidation< + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock> + where TArg1 : class + where TArg2 : class + where TArg3 : class + where TArg4 : class + where TArg5 : class + where TArg6 : class + where TArg7 : class + where TArg8 : class + where TArg9 : class + { + } + + /// + public interface ITestAsyncMethodWithMoqParameterValidation< + TArg1, + TArg2, + TArg3, + TArg4, + TArg5, + TArg6, + TArg7, + TArg8, + TArg9, + TArg10> + : ITestAsyncMethodWithParameterValidation< + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock> + where TArg1 : class + where TArg2 : class + where TArg3 : class + where TArg4 : class + where TArg5 : class + where TArg6 : class + where TArg7 : class + where TArg8 : class + where TArg9 : class + where TArg10 : class + { + } + + /// + public interface ITestAsyncMethodWithMoqParameterValidation< + TArg1, + TArg2, + TArg3, + TArg4, + TArg5, + TArg6, + TArg7, + TArg8, + TArg9, + TArg10, + TArg11> + : ITestAsyncMethodWithParameterValidation< + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock> + where TArg1 : class + where TArg2 : class + where TArg3 : class + where TArg4 : class + where TArg5 : class + where TArg6 : class + where TArg7 : class + where TArg8 : class + where TArg9 : class + where TArg10 : class + where TArg11 : class + { + } + + /// + public interface ITestAsyncMethodWithMoqParameterValidation< + TArg1, + TArg2, + TArg3, + TArg4, + TArg5, + TArg6, + TArg7, + TArg8, + TArg9, + TArg10, + TArg11, + TArg12> + : ITestAsyncMethodWithParameterValidation< + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock> + where TArg1 : class + where TArg2 : class + where TArg3 : class + where TArg4 : class + where TArg5 : class + where TArg6 : class + where TArg7 : class + where TArg8 : class + where TArg9 : class + where TArg10 : class + where TArg11 : class + where TArg12 : class + { + } + + /// + public interface ITestAsyncMethodWithMoqParameterValidation< + TArg1, + TArg2, + TArg3, + TArg4, + TArg5, + TArg6, + TArg7, + TArg8, + TArg9, + TArg10, + TArg11, + TArg12, + TArg13> + : ITestAsyncMethodWithParameterValidation< + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock> + where TArg1 : class + where TArg2 : class + where TArg3 : class + where TArg4 : class + where TArg5 : class + where TArg6 : class + where TArg7 : class + where TArg8 : class + where TArg9 : class + where TArg10 : class + where TArg11 : class + where TArg12 : class + where TArg13 : class + { + } + + /// + public interface ITestAsyncMethodWithMoqParameterValidation< + TArg1, + TArg2, + TArg3, + TArg4, + TArg5, + TArg6, + TArg7, + TArg8, + TArg9, + TArg10, + TArg11, + TArg12, + TArg13, + TArg14> + : ITestAsyncMethodWithParameterValidation< + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock> + where TArg1 : class + where TArg2 : class + where TArg3 : class + where TArg4 : class + where TArg5 : class + where TArg6 : class + where TArg7 : class + where TArg8 : class + where TArg9 : class + where TArg10 : class + where TArg11 : class + where TArg12 : class + where TArg13 : class + where TArg14 : class + { + } + + /// + public interface ITestAsyncMethodWithMoqParameterValidation< + TArg1, + TArg2, + TArg3, + TArg4, + TArg5, + TArg6, + TArg7, + TArg8, + TArg9, + TArg10, + TArg11, + TArg12, + TArg13, + TArg14, + TArg15> + : ITestAsyncMethodWithParameterValidation< + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock> + where TArg1 : class + where TArg2 : class + where TArg3 : class + where TArg4 : class + where TArg5 : class + where TArg6 : class + where TArg7 : class + where TArg8 : class + where TArg9 : class + where TArg10 : class + where TArg11 : class + where TArg12 : class + where TArg13 : class + where TArg14 : class + where TArg15 : class + { + } + + /// + public interface ITestAsyncMethodWithMoqParameterValidation< + TArg1, + TArg2, + TArg3, + TArg4, + TArg5, + TArg6, + TArg7, + TArg8, + TArg9, + TArg10, + TArg11, + TArg12, + TArg13, + TArg14, + TArg15, + TArg16> + : ITestAsyncMethodWithParameterValidation< + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock> + where TArg1 : class + where TArg2 : class + where TArg3 : class + where TArg4 : class + where TArg5 : class + where TArg6 : class + where TArg7 : class + where TArg8 : class + where TArg9 : class + where TArg10 : class + where TArg11 : class + where TArg12 : class + where TArg13 : class + where TArg14 : class + where TArg15 : class + where TArg16 : class + { + } +#pragma warning restore SA1402 // File may only contain a single type +} diff --git a/src/NetTestRegimentation.Moq/ITestAsyncMethodWithMoqRangeParameters.cs b/src/NetTestRegimentation.Moq/ITestAsyncMethodWithMoqRangeParameters.cs index df83fb4..dc8cb5b 100644 --- a/src/NetTestRegimentation.Moq/ITestAsyncMethodWithMoqRangeParameters.cs +++ b/src/NetTestRegimentation.Moq/ITestAsyncMethodWithMoqRangeParameters.cs @@ -1,7 +1,510 @@ -namespace NetTestRegimentation.Moq +// Copyright (c) 2019 dpvreony and Contributors. All rights reserved. +// This file is licensed to you under the MIT license. +// See the LICENSE file in the project root for full license information. + +namespace NetTestRegimentation.Moq { - public interface ITestAsyncMethodWithMoqRangeParameters +#pragma warning disable SA1402 // File may only contain a single type + /// + public interface ITestAsyncMethodWithMoqRangeParameters + : ITestAsyncMethodWithRangeParameters> + where TArg : class { - } -} \ No newline at end of file + + /// + public interface ITestAsyncMethodWithMoqRangeParameters< + TArg1, + TArg2> + : ITestAsyncMethodWithRangeParameters< + global::Moq.Mock, + global::Moq.Mock> + where TArg1 : class + where TArg2 : class + { + } + + /// + public interface ITestAsyncMethodWithMoqRangeParameters< + TArg1, + TArg2, + TArg3> + : ITestAsyncMethodWithRangeParameters< + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock> + where TArg1 : class + where TArg2 : class + where TArg3 : class + { + } + + /// + public interface ITestAsyncMethodWithMoqRangeParameters< + TArg1, + TArg2, + TArg3, + TArg4> + : ITestAsyncMethodWithRangeParameters< + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock> + where TArg1 : class + where TArg2 : class + where TArg3 : class + where TArg4 : class + { + } + + /// + public interface ITestAsyncMethodWithMoqRangeParameters< + TArg1, + TArg2, + TArg3, + TArg4, + TArg5> + : ITestAsyncMethodWithRangeParameters< + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock> + where TArg1 : class + where TArg2 : class + where TArg3 : class + where TArg4 : class + where TArg5 : class + { + } + + /// + public interface ITestAsyncMethodWithMoqRangeParameters< + TArg1, + TArg2, + TArg3, + TArg4, + TArg5, + TArg6> + : ITestAsyncMethodWithRangeParameters< + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock> + where TArg1 : class + where TArg2 : class + where TArg3 : class + where TArg4 : class + where TArg5 : class + where TArg6 : class + { + } + + /// + public interface ITestAsyncMethodWithMoqRangeParameters< + TArg1, + TArg2, + TArg3, + TArg4, + TArg5, + TArg6, + TArg7> + : ITestAsyncMethodWithRangeParameters< + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock> + where TArg1 : class + where TArg2 : class + where TArg3 : class + where TArg4 : class + where TArg5 : class + where TArg6 : class + where TArg7 : class + { + } + + /// + public interface ITestAsyncMethodWithMoqRangeParameters< + TArg1, + TArg2, + TArg3, + TArg4, + TArg5, + TArg6, + TArg7, + TArg8> + : ITestAsyncMethodWithRangeParameters< + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock> + where TArg1 : class + where TArg2 : class + where TArg3 : class + where TArg4 : class + where TArg5 : class + where TArg6 : class + where TArg7 : class + where TArg8 : class + { + } + + /// + public interface ITestAsyncMethodWithMoqRangeParameters< + TArg1, + TArg2, + TArg3, + TArg4, + TArg5, + TArg6, + TArg7, + TArg8, + TArg9> + : ITestAsyncMethodWithRangeParameters< + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock> + where TArg1 : class + where TArg2 : class + where TArg3 : class + where TArg4 : class + where TArg5 : class + where TArg6 : class + where TArg7 : class + where TArg8 : class + where TArg9 : class + { + } + + /// + public interface ITestAsyncMethodWithMoqRangeParameters< + TArg1, + TArg2, + TArg3, + TArg4, + TArg5, + TArg6, + TArg7, + TArg8, + TArg9, + TArg10> + : ITestAsyncMethodWithRangeParameters< + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock> + where TArg1 : class + where TArg2 : class + where TArg3 : class + where TArg4 : class + where TArg5 : class + where TArg6 : class + where TArg7 : class + where TArg8 : class + where TArg9 : class + where TArg10 : class + { + } + + /// + public interface ITestAsyncMethodWithMoqRangeParameters< + TArg1, + TArg2, + TArg3, + TArg4, + TArg5, + TArg6, + TArg7, + TArg8, + TArg9, + TArg10, + TArg11> + : ITestAsyncMethodWithRangeParameters< + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock> + where TArg1 : class + where TArg2 : class + where TArg3 : class + where TArg4 : class + where TArg5 : class + where TArg6 : class + where TArg7 : class + where TArg8 : class + where TArg9 : class + where TArg10 : class + where TArg11 : class + { + } + + /// + public interface ITestAsyncMethodWithMoqRangeParameters< + TArg1, + TArg2, + TArg3, + TArg4, + TArg5, + TArg6, + TArg7, + TArg8, + TArg9, + TArg10, + TArg11, + TArg12> + : ITestAsyncMethodWithRangeParameters< + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock> + where TArg1 : class + where TArg2 : class + where TArg3 : class + where TArg4 : class + where TArg5 : class + where TArg6 : class + where TArg7 : class + where TArg8 : class + where TArg9 : class + where TArg10 : class + where TArg11 : class + where TArg12 : class + { + } + + /// + public interface ITestAsyncMethodWithMoqRangeParameters< + TArg1, + TArg2, + TArg3, + TArg4, + TArg5, + TArg6, + TArg7, + TArg8, + TArg9, + TArg10, + TArg11, + TArg12, + TArg13> + : ITestAsyncMethodWithRangeParameters< + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock> + where TArg1 : class + where TArg2 : class + where TArg3 : class + where TArg4 : class + where TArg5 : class + where TArg6 : class + where TArg7 : class + where TArg8 : class + where TArg9 : class + where TArg10 : class + where TArg11 : class + where TArg12 : class + where TArg13 : class + { + } + + /// + public interface ITestAsyncMethodWithMoqRangeParameters< + TArg1, + TArg2, + TArg3, + TArg4, + TArg5, + TArg6, + TArg7, + TArg8, + TArg9, + TArg10, + TArg11, + TArg12, + TArg13, + TArg14> + : ITestAsyncMethodWithRangeParameters< + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock> + where TArg1 : class + where TArg2 : class + where TArg3 : class + where TArg4 : class + where TArg5 : class + where TArg6 : class + where TArg7 : class + where TArg8 : class + where TArg9 : class + where TArg10 : class + where TArg11 : class + where TArg12 : class + where TArg13 : class + where TArg14 : class + { + } + + /// + public interface ITestAsyncMethodWithMoqRangeParameters< + TArg1, + TArg2, + TArg3, + TArg4, + TArg5, + TArg6, + TArg7, + TArg8, + TArg9, + TArg10, + TArg11, + TArg12, + TArg13, + TArg14, + TArg15> + : ITestAsyncMethodWithRangeParameters< + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock> + where TArg1 : class + where TArg2 : class + where TArg3 : class + where TArg4 : class + where TArg5 : class + where TArg6 : class + where TArg7 : class + where TArg8 : class + where TArg9 : class + where TArg10 : class + where TArg11 : class + where TArg12 : class + where TArg13 : class + where TArg14 : class + where TArg15 : class + { + } + + /// + public interface ITestAsyncMethodWithMoqRangeParameters< + TArg1, + TArg2, + TArg3, + TArg4, + TArg5, + TArg6, + TArg7, + TArg8, + TArg9, + TArg10, + TArg11, + TArg12, + TArg13, + TArg14, + TArg15, + TArg16> + : ITestAsyncMethodWithRangeParameters< + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock> + where TArg1 : class + where TArg2 : class + where TArg3 : class + where TArg4 : class + where TArg5 : class + where TArg6 : class + where TArg7 : class + where TArg8 : class + where TArg9 : class + where TArg10 : class + where TArg11 : class + where TArg12 : class + where TArg13 : class + where TArg14 : class + where TArg15 : class + where TArg16 : class + { + } +#pragma warning restore SA1402 // File may only contain a single type +} diff --git a/src/NetTestRegimentation.Moq/ITestMethodWithMoqNullableParameters.cs b/src/NetTestRegimentation.Moq/ITestMethodWithMoqNullableParameters.cs index a9a00b5..e49985c 100644 --- a/src/NetTestRegimentation.Moq/ITestMethodWithMoqNullableParameters.cs +++ b/src/NetTestRegimentation.Moq/ITestMethodWithMoqNullableParameters.cs @@ -1,7 +1,510 @@ -namespace NetTestRegimentation.Moq +// Copyright (c) 2019 dpvreony and Contributors. All rights reserved. +// This file is licensed to you under the MIT license. +// See the LICENSE file in the project root for full license information. + +namespace NetTestRegimentation.Moq { - public interface ITestMethodWithMoqNullableParameters +#pragma warning disable SA1402 // File may only contain a single type + /// + public interface ITestMethodWithMoqNullableParameters + : ITestMethodWithNullableParameters> + where TArg : class { - } -} \ No newline at end of file + + /// + public interface ITestMethodWithMoqNullableParameters< + TArg1, + TArg2> + : ITestMethodWithNullableParameters< + global::Moq.Mock, + global::Moq.Mock> + where TArg1 : class + where TArg2 : class + { + } + + /// + public interface ITestMethodWithMoqNullableParameters< + TArg1, + TArg2, + TArg3> + : ITestMethodWithNullableParameters< + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock> + where TArg1 : class + where TArg2 : class + where TArg3 : class + { + } + + /// + public interface ITestMethodWithMoqNullableParameters< + TArg1, + TArg2, + TArg3, + TArg4> + : ITestMethodWithNullableParameters< + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock> + where TArg1 : class + where TArg2 : class + where TArg3 : class + where TArg4 : class + { + } + + /// + public interface ITestMethodWithMoqNullableParameters< + TArg1, + TArg2, + TArg3, + TArg4, + TArg5> + : ITestMethodWithNullableParameters< + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock> + where TArg1 : class + where TArg2 : class + where TArg3 : class + where TArg4 : class + where TArg5 : class + { + } + + /// + public interface ITestMethodWithMoqNullableParameters< + TArg1, + TArg2, + TArg3, + TArg4, + TArg5, + TArg6> + : ITestMethodWithNullableParameters< + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock> + where TArg1 : class + where TArg2 : class + where TArg3 : class + where TArg4 : class + where TArg5 : class + where TArg6 : class + { + } + + /// + public interface ITestMethodWithMoqNullableParameters< + TArg1, + TArg2, + TArg3, + TArg4, + TArg5, + TArg6, + TArg7> + : ITestMethodWithNullableParameters< + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock> + where TArg1 : class + where TArg2 : class + where TArg3 : class + where TArg4 : class + where TArg5 : class + where TArg6 : class + where TArg7 : class + { + } + + /// + public interface ITestMethodWithMoqNullableParameters< + TArg1, + TArg2, + TArg3, + TArg4, + TArg5, + TArg6, + TArg7, + TArg8> + : ITestMethodWithNullableParameters< + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock> + where TArg1 : class + where TArg2 : class + where TArg3 : class + where TArg4 : class + where TArg5 : class + where TArg6 : class + where TArg7 : class + where TArg8 : class + { + } + + /// + public interface ITestMethodWithMoqNullableParameters< + TArg1, + TArg2, + TArg3, + TArg4, + TArg5, + TArg6, + TArg7, + TArg8, + TArg9> + : ITestMethodWithNullableParameters< + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock> + where TArg1 : class + where TArg2 : class + where TArg3 : class + where TArg4 : class + where TArg5 : class + where TArg6 : class + where TArg7 : class + where TArg8 : class + where TArg9 : class + { + } + + /// + public interface ITestMethodWithMoqNullableParameters< + TArg1, + TArg2, + TArg3, + TArg4, + TArg5, + TArg6, + TArg7, + TArg8, + TArg9, + TArg10> + : ITestMethodWithNullableParameters< + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock> + where TArg1 : class + where TArg2 : class + where TArg3 : class + where TArg4 : class + where TArg5 : class + where TArg6 : class + where TArg7 : class + where TArg8 : class + where TArg9 : class + where TArg10 : class + { + } + + /// + public interface ITestMethodWithMoqNullableParameters< + TArg1, + TArg2, + TArg3, + TArg4, + TArg5, + TArg6, + TArg7, + TArg8, + TArg9, + TArg10, + TArg11> + : ITestMethodWithNullableParameters< + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock> + where TArg1 : class + where TArg2 : class + where TArg3 : class + where TArg4 : class + where TArg5 : class + where TArg6 : class + where TArg7 : class + where TArg8 : class + where TArg9 : class + where TArg10 : class + where TArg11 : class + { + } + + /// + public interface ITestMethodWithMoqNullableParameters< + TArg1, + TArg2, + TArg3, + TArg4, + TArg5, + TArg6, + TArg7, + TArg8, + TArg9, + TArg10, + TArg11, + TArg12> + : ITestMethodWithNullableParameters< + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock> + where TArg1 : class + where TArg2 : class + where TArg3 : class + where TArg4 : class + where TArg5 : class + where TArg6 : class + where TArg7 : class + where TArg8 : class + where TArg9 : class + where TArg10 : class + where TArg11 : class + where TArg12 : class + { + } + + /// + public interface ITestMethodWithMoqNullableParameters< + TArg1, + TArg2, + TArg3, + TArg4, + TArg5, + TArg6, + TArg7, + TArg8, + TArg9, + TArg10, + TArg11, + TArg12, + TArg13> + : ITestMethodWithNullableParameters< + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock> + where TArg1 : class + where TArg2 : class + where TArg3 : class + where TArg4 : class + where TArg5 : class + where TArg6 : class + where TArg7 : class + where TArg8 : class + where TArg9 : class + where TArg10 : class + where TArg11 : class + where TArg12 : class + where TArg13 : class + { + } + + /// + public interface ITestMethodWithMoqNullableParameters< + TArg1, + TArg2, + TArg3, + TArg4, + TArg5, + TArg6, + TArg7, + TArg8, + TArg9, + TArg10, + TArg11, + TArg12, + TArg13, + TArg14> + : ITestMethodWithNullableParameters< + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock> + where TArg1 : class + where TArg2 : class + where TArg3 : class + where TArg4 : class + where TArg5 : class + where TArg6 : class + where TArg7 : class + where TArg8 : class + where TArg9 : class + where TArg10 : class + where TArg11 : class + where TArg12 : class + where TArg13 : class + where TArg14 : class + { + } + + /// + public interface ITestMethodWithMoqNullableParameters< + TArg1, + TArg2, + TArg3, + TArg4, + TArg5, + TArg6, + TArg7, + TArg8, + TArg9, + TArg10, + TArg11, + TArg12, + TArg13, + TArg14, + TArg15> + : ITestMethodWithNullableParameters< + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock> + where TArg1 : class + where TArg2 : class + where TArg3 : class + where TArg4 : class + where TArg5 : class + where TArg6 : class + where TArg7 : class + where TArg8 : class + where TArg9 : class + where TArg10 : class + where TArg11 : class + where TArg12 : class + where TArg13 : class + where TArg14 : class + where TArg15 : class + { + } + + /// + public interface ITestMethodWithMoqNullableParameters< + TArg1, + TArg2, + TArg3, + TArg4, + TArg5, + TArg6, + TArg7, + TArg8, + TArg9, + TArg10, + TArg11, + TArg12, + TArg13, + TArg14, + TArg15, + TArg16> + : ITestMethodWithNullableParameters< + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock> + where TArg1 : class + where TArg2 : class + where TArg3 : class + where TArg4 : class + where TArg5 : class + where TArg6 : class + where TArg7 : class + where TArg8 : class + where TArg9 : class + where TArg10 : class + where TArg11 : class + where TArg12 : class + where TArg13 : class + where TArg14 : class + where TArg15 : class + where TArg16 : class + { + } +#pragma warning restore SA1402 // File may only contain a single type +} diff --git a/src/NetTestRegimentation.Moq/ITestMethodWithMoqParameterValidation.cs b/src/NetTestRegimentation.Moq/ITestMethodWithMoqParameterValidation.cs index d0fdc0a..ac89866 100644 --- a/src/NetTestRegimentation.Moq/ITestMethodWithMoqParameterValidation.cs +++ b/src/NetTestRegimentation.Moq/ITestMethodWithMoqParameterValidation.cs @@ -1,7 +1,510 @@ -namespace NetTestRegimentation.Moq +// Copyright (c) 2019 dpvreony and Contributors. All rights reserved. +// This file is licensed to you under the MIT license. +// See the LICENSE file in the project root for full license information. + +namespace NetTestRegimentation.Moq { - public interface ITestMethodWithMoqParameterValidation +#pragma warning disable SA1402 // File may only contain a single type + /// + public interface ITestMethodWithMoqParameterValidation + : ITestMethodWithParameterValidation> + where TArg : class { - } -} \ No newline at end of file + + /// + public interface ITestMethodWithMoqParameterValidation< + TArg1, + TArg2> + : ITestMethodWithParameterValidation< + global::Moq.Mock, + global::Moq.Mock> + where TArg1 : class + where TArg2 : class + { + } + + /// + public interface ITestMethodWithMoqParameterValidation< + TArg1, + TArg2, + TArg3> + : ITestMethodWithParameterValidation< + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock> + where TArg1 : class + where TArg2 : class + where TArg3 : class + { + } + + /// + public interface ITestMethodWithMoqParameterValidation< + TArg1, + TArg2, + TArg3, + TArg4> + : ITestMethodWithParameterValidation< + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock> + where TArg1 : class + where TArg2 : class + where TArg3 : class + where TArg4 : class + { + } + + /// + public interface ITestMethodWithMoqParameterValidation< + TArg1, + TArg2, + TArg3, + TArg4, + TArg5> + : ITestMethodWithParameterValidation< + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock> + where TArg1 : class + where TArg2 : class + where TArg3 : class + where TArg4 : class + where TArg5 : class + { + } + + /// + public interface ITestMethodWithMoqParameterValidation< + TArg1, + TArg2, + TArg3, + TArg4, + TArg5, + TArg6> + : ITestMethodWithParameterValidation< + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock> + where TArg1 : class + where TArg2 : class + where TArg3 : class + where TArg4 : class + where TArg5 : class + where TArg6 : class + { + } + + /// + public interface ITestMethodWithMoqParameterValidation< + TArg1, + TArg2, + TArg3, + TArg4, + TArg5, + TArg6, + TArg7> + : ITestMethodWithParameterValidation< + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock> + where TArg1 : class + where TArg2 : class + where TArg3 : class + where TArg4 : class + where TArg5 : class + where TArg6 : class + where TArg7 : class + { + } + + /// + public interface ITestMethodWithMoqParameterValidation< + TArg1, + TArg2, + TArg3, + TArg4, + TArg5, + TArg6, + TArg7, + TArg8> + : ITestMethodWithParameterValidation< + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock> + where TArg1 : class + where TArg2 : class + where TArg3 : class + where TArg4 : class + where TArg5 : class + where TArg6 : class + where TArg7 : class + where TArg8 : class + { + } + + /// + public interface ITestMethodWithMoqParameterValidation< + TArg1, + TArg2, + TArg3, + TArg4, + TArg5, + TArg6, + TArg7, + TArg8, + TArg9> + : ITestMethodWithParameterValidation< + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock> + where TArg1 : class + where TArg2 : class + where TArg3 : class + where TArg4 : class + where TArg5 : class + where TArg6 : class + where TArg7 : class + where TArg8 : class + where TArg9 : class + { + } + + /// + public interface ITestMethodWithMoqParameterValidation< + TArg1, + TArg2, + TArg3, + TArg4, + TArg5, + TArg6, + TArg7, + TArg8, + TArg9, + TArg10> + : ITestMethodWithParameterValidation< + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock> + where TArg1 : class + where TArg2 : class + where TArg3 : class + where TArg4 : class + where TArg5 : class + where TArg6 : class + where TArg7 : class + where TArg8 : class + where TArg9 : class + where TArg10 : class + { + } + + /// + public interface ITestMethodWithMoqParameterValidation< + TArg1, + TArg2, + TArg3, + TArg4, + TArg5, + TArg6, + TArg7, + TArg8, + TArg9, + TArg10, + TArg11> + : ITestMethodWithParameterValidation< + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock> + where TArg1 : class + where TArg2 : class + where TArg3 : class + where TArg4 : class + where TArg5 : class + where TArg6 : class + where TArg7 : class + where TArg8 : class + where TArg9 : class + where TArg10 : class + where TArg11 : class + { + } + + /// + public interface ITestMethodWithMoqParameterValidation< + TArg1, + TArg2, + TArg3, + TArg4, + TArg5, + TArg6, + TArg7, + TArg8, + TArg9, + TArg10, + TArg11, + TArg12> + : ITestMethodWithParameterValidation< + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock> + where TArg1 : class + where TArg2 : class + where TArg3 : class + where TArg4 : class + where TArg5 : class + where TArg6 : class + where TArg7 : class + where TArg8 : class + where TArg9 : class + where TArg10 : class + where TArg11 : class + where TArg12 : class + { + } + + /// + public interface ITestMethodWithMoqParameterValidation< + TArg1, + TArg2, + TArg3, + TArg4, + TArg5, + TArg6, + TArg7, + TArg8, + TArg9, + TArg10, + TArg11, + TArg12, + TArg13> + : ITestMethodWithParameterValidation< + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock> + where TArg1 : class + where TArg2 : class + where TArg3 : class + where TArg4 : class + where TArg5 : class + where TArg6 : class + where TArg7 : class + where TArg8 : class + where TArg9 : class + where TArg10 : class + where TArg11 : class + where TArg12 : class + where TArg13 : class + { + } + + /// + public interface ITestMethodWithMoqParameterValidation< + TArg1, + TArg2, + TArg3, + TArg4, + TArg5, + TArg6, + TArg7, + TArg8, + TArg9, + TArg10, + TArg11, + TArg12, + TArg13, + TArg14> + : ITestMethodWithParameterValidation< + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock> + where TArg1 : class + where TArg2 : class + where TArg3 : class + where TArg4 : class + where TArg5 : class + where TArg6 : class + where TArg7 : class + where TArg8 : class + where TArg9 : class + where TArg10 : class + where TArg11 : class + where TArg12 : class + where TArg13 : class + where TArg14 : class + { + } + + /// + public interface ITestMethodWithMoqParameterValidation< + TArg1, + TArg2, + TArg3, + TArg4, + TArg5, + TArg6, + TArg7, + TArg8, + TArg9, + TArg10, + TArg11, + TArg12, + TArg13, + TArg14, + TArg15> + : ITestMethodWithParameterValidation< + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock> + where TArg1 : class + where TArg2 : class + where TArg3 : class + where TArg4 : class + where TArg5 : class + where TArg6 : class + where TArg7 : class + where TArg8 : class + where TArg9 : class + where TArg10 : class + where TArg11 : class + where TArg12 : class + where TArg13 : class + where TArg14 : class + where TArg15 : class + { + } + + /// + public interface ITestMethodWithMoqParameterValidation< + TArg1, + TArg2, + TArg3, + TArg4, + TArg5, + TArg6, + TArg7, + TArg8, + TArg9, + TArg10, + TArg11, + TArg12, + TArg13, + TArg14, + TArg15, + TArg16> + : ITestMethodWithParameterValidation< + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock> + where TArg1 : class + where TArg2 : class + where TArg3 : class + where TArg4 : class + where TArg5 : class + where TArg6 : class + where TArg7 : class + where TArg8 : class + where TArg9 : class + where TArg10 : class + where TArg11 : class + where TArg12 : class + where TArg13 : class + where TArg14 : class + where TArg15 : class + where TArg16 : class + { + } +#pragma warning restore SA1402 // File may only contain a single type +} diff --git a/src/NetTestRegimentation.Moq/ITestMethodWithMoqRangeParameters.cs b/src/NetTestRegimentation.Moq/ITestMethodWithMoqRangeParameters.cs index 6dcb018..44fb37c 100644 --- a/src/NetTestRegimentation.Moq/ITestMethodWithMoqRangeParameters.cs +++ b/src/NetTestRegimentation.Moq/ITestMethodWithMoqRangeParameters.cs @@ -1,7 +1,510 @@ -namespace NetTestRegimentation.Moq +// Copyright (c) 2019 dpvreony and Contributors. All rights reserved. +// This file is licensed to you under the MIT license. +// See the LICENSE file in the project root for full license information. + +namespace NetTestRegimentation.Moq { - public interface ITestMethodWithMoqRangeParameters +#pragma warning disable SA1402 // File may only contain a single type + /// + public interface ITestMethodWithMoqRangeParameters + : ITestMethodWithRangeParameters> + where TArg : class { - } -} \ No newline at end of file + + /// + public interface ITestMethodWithMoqRangeParameters< + TArg1, + TArg2> + : ITestMethodWithRangeParameters< + global::Moq.Mock, + global::Moq.Mock> + where TArg1 : class + where TArg2 : class + { + } + + /// + public interface ITestMethodWithMoqRangeParameters< + TArg1, + TArg2, + TArg3> + : ITestMethodWithRangeParameters< + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock> + where TArg1 : class + where TArg2 : class + where TArg3 : class + { + } + + /// + public interface ITestMethodWithMoqRangeParameters< + TArg1, + TArg2, + TArg3, + TArg4> + : ITestMethodWithRangeParameters< + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock> + where TArg1 : class + where TArg2 : class + where TArg3 : class + where TArg4 : class + { + } + + /// + public interface ITestMethodWithMoqRangeParameters< + TArg1, + TArg2, + TArg3, + TArg4, + TArg5> + : ITestMethodWithRangeParameters< + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock> + where TArg1 : class + where TArg2 : class + where TArg3 : class + where TArg4 : class + where TArg5 : class + { + } + + /// + public interface ITestMethodWithMoqRangeParameters< + TArg1, + TArg2, + TArg3, + TArg4, + TArg5, + TArg6> + : ITestMethodWithRangeParameters< + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock> + where TArg1 : class + where TArg2 : class + where TArg3 : class + where TArg4 : class + where TArg5 : class + where TArg6 : class + { + } + + /// + public interface ITestMethodWithMoqRangeParameters< + TArg1, + TArg2, + TArg3, + TArg4, + TArg5, + TArg6, + TArg7> + : ITestMethodWithRangeParameters< + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock> + where TArg1 : class + where TArg2 : class + where TArg3 : class + where TArg4 : class + where TArg5 : class + where TArg6 : class + where TArg7 : class + { + } + + /// + public interface ITestMethodWithMoqRangeParameters< + TArg1, + TArg2, + TArg3, + TArg4, + TArg5, + TArg6, + TArg7, + TArg8> + : ITestMethodWithRangeParameters< + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock> + where TArg1 : class + where TArg2 : class + where TArg3 : class + where TArg4 : class + where TArg5 : class + where TArg6 : class + where TArg7 : class + where TArg8 : class + { + } + + /// + public interface ITestMethodWithMoqRangeParameters< + TArg1, + TArg2, + TArg3, + TArg4, + TArg5, + TArg6, + TArg7, + TArg8, + TArg9> + : ITestMethodWithRangeParameters< + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock> + where TArg1 : class + where TArg2 : class + where TArg3 : class + where TArg4 : class + where TArg5 : class + where TArg6 : class + where TArg7 : class + where TArg8 : class + where TArg9 : class + { + } + + /// + public interface ITestMethodWithMoqRangeParameters< + TArg1, + TArg2, + TArg3, + TArg4, + TArg5, + TArg6, + TArg7, + TArg8, + TArg9, + TArg10> + : ITestMethodWithRangeParameters< + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock> + where TArg1 : class + where TArg2 : class + where TArg3 : class + where TArg4 : class + where TArg5 : class + where TArg6 : class + where TArg7 : class + where TArg8 : class + where TArg9 : class + where TArg10 : class + { + } + + /// + public interface ITestMethodWithMoqRangeParameters< + TArg1, + TArg2, + TArg3, + TArg4, + TArg5, + TArg6, + TArg7, + TArg8, + TArg9, + TArg10, + TArg11> + : ITestMethodWithRangeParameters< + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock> + where TArg1 : class + where TArg2 : class + where TArg3 : class + where TArg4 : class + where TArg5 : class + where TArg6 : class + where TArg7 : class + where TArg8 : class + where TArg9 : class + where TArg10 : class + where TArg11 : class + { + } + + /// + public interface ITestMethodWithMoqRangeParameters< + TArg1, + TArg2, + TArg3, + TArg4, + TArg5, + TArg6, + TArg7, + TArg8, + TArg9, + TArg10, + TArg11, + TArg12> + : ITestMethodWithRangeParameters< + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock> + where TArg1 : class + where TArg2 : class + where TArg3 : class + where TArg4 : class + where TArg5 : class + where TArg6 : class + where TArg7 : class + where TArg8 : class + where TArg9 : class + where TArg10 : class + where TArg11 : class + where TArg12 : class + { + } + + /// + public interface ITestMethodWithMoqRangeParameters< + TArg1, + TArg2, + TArg3, + TArg4, + TArg5, + TArg6, + TArg7, + TArg8, + TArg9, + TArg10, + TArg11, + TArg12, + TArg13> + : ITestMethodWithRangeParameters< + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock> + where TArg1 : class + where TArg2 : class + where TArg3 : class + where TArg4 : class + where TArg5 : class + where TArg6 : class + where TArg7 : class + where TArg8 : class + where TArg9 : class + where TArg10 : class + where TArg11 : class + where TArg12 : class + where TArg13 : class + { + } + + /// + public interface ITestMethodWithMoqRangeParameters< + TArg1, + TArg2, + TArg3, + TArg4, + TArg5, + TArg6, + TArg7, + TArg8, + TArg9, + TArg10, + TArg11, + TArg12, + TArg13, + TArg14> + : ITestMethodWithRangeParameters< + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock> + where TArg1 : class + where TArg2 : class + where TArg3 : class + where TArg4 : class + where TArg5 : class + where TArg6 : class + where TArg7 : class + where TArg8 : class + where TArg9 : class + where TArg10 : class + where TArg11 : class + where TArg12 : class + where TArg13 : class + where TArg14 : class + { + } + + /// + public interface ITestMethodWithMoqRangeParameters< + TArg1, + TArg2, + TArg3, + TArg4, + TArg5, + TArg6, + TArg7, + TArg8, + TArg9, + TArg10, + TArg11, + TArg12, + TArg13, + TArg14, + TArg15> + : ITestMethodWithRangeParameters< + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock> + where TArg1 : class + where TArg2 : class + where TArg3 : class + where TArg4 : class + where TArg5 : class + where TArg6 : class + where TArg7 : class + where TArg8 : class + where TArg9 : class + where TArg10 : class + where TArg11 : class + where TArg12 : class + where TArg13 : class + where TArg14 : class + where TArg15 : class + { + } + + /// + public interface ITestMethodWithMoqRangeParameters< + TArg1, + TArg2, + TArg3, + TArg4, + TArg5, + TArg6, + TArg7, + TArg8, + TArg9, + TArg10, + TArg11, + TArg12, + TArg13, + TArg14, + TArg15, + TArg16> + : ITestMethodWithRangeParameters< + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock, + global::Moq.Mock> + where TArg1 : class + where TArg2 : class + where TArg3 : class + where TArg4 : class + where TArg5 : class + where TArg6 : class + where TArg7 : class + where TArg8 : class + where TArg9 : class + where TArg10 : class + where TArg11 : class + where TArg12 : class + where TArg13 : class + where TArg14 : class + where TArg15 : class + where TArg16 : class + { + } +#pragma warning restore SA1402 // File may only contain a single type +} diff --git a/src/NetTestRegimentation.UnitTests/ArgumentHelpers.cs b/src/NetTestRegimentation.UnitTests/ArgumentHelpers.cs index e434bd9..fe33544 100644 --- a/src/NetTestRegimentation.UnitTests/ArgumentHelpers.cs +++ b/src/NetTestRegimentation.UnitTests/ArgumentHelpers.cs @@ -1,4 +1,8 @@ -using System; +// Copyright (c) 2019 dpvreony and Contributors. All rights reserved. +// This file is licensed to you under the MIT license. +// See the LICENSE file in the project root for full license information. + +using System; using System.Collections.Generic; using System.Diagnostics.CodeAnalysis; using System.Text; @@ -6,104 +10,170 @@ namespace NetTestRegimentation.UnitTests { + /// + /// Helpers for running unit test validation. + /// [ExcludeFromCodeCoverage] public static class ArgumentHelpers { - - public static async Task ThrowIfNullAsync( - T arg, - string paramName) + /// + /// Check to ensure nullable parameters throw . + /// + /// Type for the argument. + /// The nullable argument. + /// + /// A representing the asynchronous operation. + /// + public static async Task ThrowIfNullAsync(TArg arg) { - await Task.Run(() => ThrowIfNull( - arg, - paramName)); + await Task.Run(() => ThrowIfNull(arg)).ConfigureAwait(false); } + /// + /// Check to ensure nullable parameters throw . + /// + /// Type for the 1st argument. + /// Type for the 2nd argument. + /// The 1st nullable argument. + /// The 2nd nullable argument. + /// + /// A representing the asynchronous operation. + /// public static async Task ThrowIfNullAsync< - T1, - T2>( - T1 arg1, - T2 arg2, - string paramName) + TArg1, + TArg2>( + TArg1 arg1, + TArg2 arg2) { await Task.Run(() => ThrowIfNull( arg1, - arg2, - paramName)); + arg2)).ConfigureAwait(false); } + /// + /// Check to ensure nullable parameters throw . + /// + /// Type for the 1st argument. + /// Type for the 2nd argument. + /// Type for the 3rd argument. + /// The 1st nullable argument. + /// The 2nd nullable argument. + /// The 3rd nullable argument. + /// + /// A representing the asynchronous operation. + /// public static async Task ThrowIfNullAsync< - T1, - T2, - T3>( - T1 arg1, - T2 arg2, - T3 arg3, - string paramName) + TArg1, + TArg2, + TArg3>( + TArg1 arg1, + TArg2 arg2, + TArg3 arg3) { await Task.Run(() => ThrowIfNull( arg1, arg2, - arg3, - paramName)); + arg3)).ConfigureAwait(false); } + /// + /// Check to ensure nullable parameters throw . + /// + /// Type for the 1st argument. + /// Type for the 2nd argument. + /// Type for the 3rd argument. + /// Type for the 4th argument. + /// The 1st nullable argument. + /// The 2nd nullable argument. + /// The 3rd nullable argument. + /// The 4th nullable argument. + /// + /// A representing the asynchronous operation. + /// public static async Task ThrowIfNullAsync< - T1, - T2, - T3, - T4>( - T1 arg1, - T2 arg2, - T3 arg3, - T4 arg4, - string paramName) + TArg1, + TArg2, + TArg3, + TArg4>( + TArg1 arg1, + TArg2 arg2, + TArg3 arg3, + TArg4 arg4) { await Task.Run(() => ThrowIfNull( arg1, arg2, arg3, - arg4, - paramName)); + arg4)).ConfigureAwait(false); } - + /// + /// Check to ensure nullable parameters throw . + /// + /// Type for the 1st argument. + /// Type for the 2nd argument. + /// Type for the 3rd argument. + /// Type for the 4th argument. + /// Type for the 5th argument. + /// The 1st nullable argument. + /// The 2nd nullable argument. + /// The 3rd nullable argument. + /// The 4th nullable argument. + /// The 5th nullable argument. + /// + /// A representing the asynchronous operation. + /// public static async Task ThrowIfNullAsync< - T1, - T2, - T3, - T4, - T5>( - T1 arg1, - T2 arg2, - T3 arg3, - T4 arg4, - T5 arg5, - string paramName) + TArg1, + TArg2, + TArg3, + TArg4, + TArg5>( + TArg1 arg1, + TArg2 arg2, + TArg3 arg3, + TArg4 arg4, + TArg5 arg5) { await Task.Run(() => ThrowIfNull( arg1, arg2, arg3, arg4, - arg5, - paramName)); + arg5)).ConfigureAwait(false); } + /// + /// Check to ensure nullable parameters throw . + /// + /// Type for the 1st argument. + /// Type for the 2nd argument. + /// Type for the 3rd argument. + /// Type for the 4th argument. + /// Type for the 5th argument. + /// Type for the 6th argument. + /// The 1st nullable argument. + /// The 2nd nullable argument. + /// The 3rd nullable argument. + /// The 4th nullable argument. + /// The 5th nullable argument. + /// The 6th nullable argument. + /// + /// A representing the asynchronous operation. + /// public static async Task ThrowIfNullAsync< - T1, - T2, - T3, - T4, - T5, - T6>( - T1 arg1, - T2 arg2, - T3 arg3, - T4 arg4, - T5 arg5, - T6 arg6, - string paramName) + TArg1, + TArg2, + TArg3, + TArg4, + TArg5, + TArg6>( + TArg1 arg1, + TArg2 arg2, + TArg3 arg3, + TArg4 arg4, + TArg5 arg5, + TArg6 arg6) { await Task.Run(() => ThrowIfNull( arg1, @@ -111,26 +181,44 @@ await Task.Run(() => ThrowIfNull( arg3, arg4, arg5, - arg6, - paramName)); + arg6)).ConfigureAwait(false); } + /// + /// Check to ensure nullable parameters throw . + /// + /// Type for the 1st argument. + /// Type for the 2nd argument. + /// Type for the 3rd argument. + /// Type for the 4th argument. + /// Type for the 5th argument. + /// Type for the 6th argument. + /// Type for the 7th argument. + /// The 1st nullable argument. + /// The 2nd nullable argument. + /// The 3rd nullable argument. + /// The 4th nullable argument. + /// The 5th nullable argument. + /// The 6th nullable argument. + /// The 7th nullable argument. + /// + /// A representing the asynchronous operation. + /// public static async Task ThrowIfNullAsync< - T1, - T2, - T3, - T4, - T5, - T6, - T7>( - T1 arg1, - T2 arg2, - T3 arg3, - T4 arg4, - T5 arg5, - T6 arg6, - T7 arg7, - string paramName) + TArg1, + TArg2, + TArg3, + TArg4, + TArg5, + TArg6, + TArg7>( + TArg1 arg1, + TArg2 arg2, + TArg3 arg3, + TArg4 arg4, + TArg5 arg5, + TArg6 arg6, + TArg7 arg7) { await Task.Run(() => ThrowIfNull( arg1, @@ -139,29 +227,48 @@ await Task.Run(() => ThrowIfNull( arg4, arg5, arg6, - arg7, - paramName)); + arg7)).ConfigureAwait(false); } - + /// + /// Check to ensure nullable parameters throw . + /// + /// Type for the 1st argument. + /// Type for the 2nd argument. + /// Type for the 3rd argument. + /// Type for the 4th argument. + /// Type for the 5th argument. + /// Type for the 6th argument. + /// Type for the 7th argument. + /// Type for the 8th argument. + /// The 1st nullable argument. + /// The 2nd nullable argument. + /// The 3rd nullable argument. + /// The 4th nullable argument. + /// The 5th nullable argument. + /// The 6th nullable argument. + /// The 7th nullable argument. + /// The 8th nullable argument. + /// + /// A representing the asynchronous operation. + /// public static async Task ThrowIfNullAsync< - T1, - T2, - T3, - T4, - T5, - T6, - T7, - T8>( - T1 arg1, - T2 arg2, - T3 arg3, - T4 arg4, - T5 arg5, - T6 arg6, - T7 arg7, - T8 arg8, - string paramName) + TArg1, + TArg2, + TArg3, + TArg4, + TArg5, + TArg6, + TArg7, + TArg8>( + TArg1 arg1, + TArg2 arg2, + TArg3 arg3, + TArg4 arg4, + TArg5 arg5, + TArg6 arg6, + TArg7 arg7, + TArg8 arg8) { await Task.Run(() => ThrowIfNull( arg1, @@ -171,30 +278,52 @@ await Task.Run(() => ThrowIfNull( arg5, arg6, arg7, - arg8, - paramName)); + arg8)).ConfigureAwait(false); } + /// + /// Check to ensure nullable parameters throw . + /// + /// Type for the 1st argument. + /// Type for the 2nd argument. + /// Type for the 3rd argument. + /// Type for the 4th argument. + /// Type for the 5th argument. + /// Type for the 6th argument. + /// Type for the 7th argument. + /// Type for the 8th argument. + /// Type for the 9th argument. + /// The 1st nullable argument. + /// The 2nd nullable argument. + /// The 3rd nullable argument. + /// The 4th nullable argument. + /// The 5th nullable argument. + /// The 6th nullable argument. + /// The 7th nullable argument. + /// The 8th nullable argument. + /// The 9th nullable argument. + /// + /// A representing the asynchronous operation. + /// public static async Task ThrowIfNullAsync< - T1, - T2, - T3, - T4, - T5, - T6, - T7, - T8, - T9>( - T1 arg1, - T2 arg2, - T3 arg3, - T4 arg4, - T5 arg5, - T6 arg6, - T7 arg7, - T8 arg8, - T9 arg9, - string paramName) + TArg1, + TArg2, + TArg3, + TArg4, + TArg5, + TArg6, + TArg7, + TArg8, + TArg9>( + TArg1 arg1, + TArg2 arg2, + TArg3 arg3, + TArg4 arg4, + TArg5 arg5, + TArg6 arg6, + TArg7 arg7, + TArg8 arg8, + TArg9 arg9) { await Task.Run(() => ThrowIfNull( arg1, @@ -205,33 +334,56 @@ await Task.Run(() => ThrowIfNull( arg6, arg7, arg8, - arg9, - paramName)); + arg9)).ConfigureAwait(false); } - + /// + /// Check to ensure nullable parameters throw . + /// + /// Type for the 1st argument. + /// Type for the 2nd argument. + /// Type for the 3rd argument. + /// Type for the 4th argument. + /// Type for the 5th argument. + /// Type for the 6th argument. + /// Type for the 7th argument. + /// Type for the 8th argument. + /// Type for the 9th argument. + /// Type for the 10th argument. + /// The 1st nullable argument. + /// The 2nd nullable argument. + /// The 3rd nullable argument. + /// The 4th nullable argument. + /// The 5th nullable argument. + /// The 6th nullable argument. + /// The 7th nullable argument. + /// The 8th nullable argument. + /// The 9th nullable argument. + /// The 10th nullable argument. + /// + /// A representing the asynchronous operation. + /// public static async Task ThrowIfNullAsync< - T1, - T2, - T3, - T4, - T5, - T6, - T7, - T8, - T9, - T10>( - T1 arg1, - T2 arg2, - T3 arg3, - T4 arg4, - T5 arg5, - T6 arg6, - T7 arg7, - T8 arg8, - T9 arg9, - T10 arg10, - string paramName) + TArg1, + TArg2, + TArg3, + TArg4, + TArg5, + TArg6, + TArg7, + TArg8, + TArg9, + TArg10>( + TArg1 arg1, + TArg2 arg2, + TArg3 arg3, + TArg4 arg4, + TArg5 arg5, + TArg6 arg6, + TArg7 arg7, + TArg8 arg8, + TArg9 arg9, + TArg10 arg10) { await Task.Run(() => ThrowIfNull( arg1, @@ -243,35 +395,60 @@ await Task.Run(() => ThrowIfNull( arg7, arg8, arg9, - arg10, - paramName)); + arg10)).ConfigureAwait(false); } - + /// + /// Check to ensure nullable parameters throw . + /// + /// Type for the 1st argument. + /// Type for the 2nd argument. + /// Type for the 3rd argument. + /// Type for the 4th argument. + /// Type for the 5th argument. + /// Type for the 6th argument. + /// Type for the 7th argument. + /// Type for the 8th argument. + /// Type for the 9th argument. + /// Type for the 10th argument. + /// Type for the 11th argument. + /// The 1st nullable argument. + /// The 2nd nullable argument. + /// The 3rd nullable argument. + /// The 4th nullable argument. + /// The 5th nullable argument. + /// The 6th nullable argument. + /// The 7th nullable argument. + /// The 8th nullable argument. + /// The 9th nullable argument. + /// The 10th nullable argument. + /// The 11th nullable argument. + /// + /// A representing the asynchronous operation. + /// public static async Task ThrowIfNullAsync< - T1, - T2, - T3, - T4, - T5, - T6, - T7, - T8, - T9, - T10, - T11>( - T1 arg1, - T2 arg2, - T3 arg3, - T4 arg4, - T5 arg5, - T6 arg6, - T7 arg7, - T8 arg8, - T9 arg9, - T10 arg10, - T11 arg11, - string paramName) + TArg1, + TArg2, + TArg3, + TArg4, + TArg5, + TArg6, + TArg7, + TArg8, + TArg9, + TArg10, + TArg11>( + TArg1 arg1, + TArg2 arg2, + TArg3 arg3, + TArg4 arg4, + TArg5 arg5, + TArg6 arg6, + TArg7 arg7, + TArg8 arg8, + TArg9 arg9, + TArg10 arg10, + TArg11 arg11) { await Task.Run(() => ThrowIfNull( arg1, @@ -284,36 +461,64 @@ await Task.Run(() => ThrowIfNull( arg8, arg9, arg10, - arg11, - paramName)); + arg11)).ConfigureAwait(false); } + /// + /// Check to ensure nullable parameters throw . + /// + /// Type for the 1st argument. + /// Type for the 2nd argument. + /// Type for the 3rd argument. + /// Type for the 4th argument. + /// Type for the 5th argument. + /// Type for the 6th argument. + /// Type for the 7th argument. + /// Type for the 8th argument. + /// Type for the 9th argument. + /// Type for the 10th argument. + /// Type for the 11th argument. + /// Type for the 12th argument. + /// The 1st nullable argument. + /// The 2nd nullable argument. + /// The 3rd nullable argument. + /// The 4th nullable argument. + /// The 5th nullable argument. + /// The 6th nullable argument. + /// The 7th nullable argument. + /// The 8th nullable argument. + /// The 9th nullable argument. + /// The 10th nullable argument. + /// The 11th nullable argument. + /// The 12th nullable argument. + /// + /// A representing the asynchronous operation. + /// public static async Task ThrowIfNullAsync< - T1, - T2, - T3, - T4, - T5, - T6, - T7, - T8, - T9, - T10, - T11, - T12>( - T1 arg1, - T2 arg2, - T3 arg3, - T4 arg4, - T5 arg5, - T6 arg6, - T7 arg7, - T8 arg8, - T9 arg9, - T10 arg10, - T11 arg11, - T12 arg12, - string paramName) + TArg1, + TArg2, + TArg3, + TArg4, + TArg5, + TArg6, + TArg7, + TArg8, + TArg9, + TArg10, + TArg11, + TArg12>( + TArg1 arg1, + TArg2 arg2, + TArg3 arg3, + TArg4 arg4, + TArg5 arg5, + TArg6 arg6, + TArg7 arg7, + TArg8 arg8, + TArg9 arg9, + TArg10 arg10, + TArg11 arg11, + TArg12 arg12) { await Task.Run(() => ThrowIfNull( arg1, @@ -327,39 +532,68 @@ await Task.Run(() => ThrowIfNull( arg9, arg10, arg11, - arg12, - paramName)); + arg12)).ConfigureAwait(false); } - + /// + /// Check to ensure nullable parameters throw . + /// + /// Type for the 1st argument. + /// Type for the 2nd argument. + /// Type for the 3rd argument. + /// Type for the 4th argument. + /// Type for the 5th argument. + /// Type for the 6th argument. + /// Type for the 7th argument. + /// Type for the 8th argument. + /// Type for the 9th argument. + /// Type for the 10th argument. + /// Type for the 11th argument. + /// Type for the 12th argument. + /// Type for the 13th argument. + /// The 1st nullable argument. + /// The 2nd nullable argument. + /// The 3rd nullable argument. + /// The 4th nullable argument. + /// The 5th nullable argument. + /// The 6th nullable argument. + /// The 7th nullable argument. + /// The 8th nullable argument. + /// The 9th nullable argument. + /// The 10th nullable argument. + /// The 11th nullable argument. + /// The 12th nullable argument. + /// The 13th nullable argument. + /// + /// A representing the asynchronous operation. + /// public static async Task ThrowIfNullAsync< - T1, - T2, - T3, - T4, - T5, - T6, - T7, - T8, - T9, - T10, - T11, - T12, - T13>( - T1 arg1, - T2 arg2, - T3 arg3, - T4 arg4, - T5 arg5, - T6 arg6, - T7 arg7, - T8 arg8, - T9 arg9, - T10 arg10, - T11 arg11, - T12 arg12, - T13 arg13, - string paramName) + TArg1, + TArg2, + TArg3, + TArg4, + TArg5, + TArg6, + TArg7, + TArg8, + TArg9, + TArg10, + TArg11, + TArg12, + TArg13>( + TArg1 arg1, + TArg2 arg2, + TArg3 arg3, + TArg4 arg4, + TArg5 arg5, + TArg6 arg6, + TArg7 arg7, + TArg8 arg8, + TArg9 arg9, + TArg10 arg10, + TArg11 arg11, + TArg12 arg12, + TArg13 arg13) { await Task.Run(() => ThrowIfNull( arg1, @@ -374,41 +608,72 @@ await Task.Run(() => ThrowIfNull( arg10, arg11, arg12, - arg13, - paramName)); + arg13)).ConfigureAwait(false); } - + /// + /// Check to ensure nullable parameters throw . + /// + /// Type for the 1st argument. + /// Type for the 2nd argument. + /// Type for the 3rd argument. + /// Type for the 4th argument. + /// Type for the 5th argument. + /// Type for the 6th argument. + /// Type for the 7th argument. + /// Type for the 8th argument. + /// Type for the 9th argument. + /// Type for the 10th argument. + /// Type for the 11th argument. + /// Type for the 12th argument. + /// Type for the 13th argument. + /// Type for the 14th argument. + /// The 1st nullable argument. + /// The 2nd nullable argument. + /// The 3rd nullable argument. + /// The 4th nullable argument. + /// The 5th nullable argument. + /// The 6th nullable argument. + /// The 7th nullable argument. + /// The 8th nullable argument. + /// The 9th nullable argument. + /// The 10th nullable argument. + /// The 11th nullable argument. + /// The 12th nullable argument. + /// The 13th nullable argument. + /// The 14th nullable argument. + /// + /// A representing the asynchronous operation. + /// public static async Task ThrowIfNullAsync< - T1, - T2, - T3, - T4, - T5, - T6, - T7, - T8, - T9, - T10, - T11, - T12, - T13, - T14>( - T1 arg1, - T2 arg2, - T3 arg3, - T4 arg4, - T5 arg5, - T6 arg6, - T7 arg7, - T8 arg8, - T9 arg9, - T10 arg10, - T11 arg11, - T12 arg12, - T13 arg13, - T14 arg14, - string paramName) + TArg1, + TArg2, + TArg3, + TArg4, + TArg5, + TArg6, + TArg7, + TArg8, + TArg9, + TArg10, + TArg11, + TArg12, + TArg13, + TArg14>( + TArg1 arg1, + TArg2 arg2, + TArg3 arg3, + TArg4 arg4, + TArg5 arg5, + TArg6 arg6, + TArg7 arg7, + TArg8 arg8, + TArg9 arg9, + TArg10 arg10, + TArg11 arg11, + TArg12 arg12, + TArg13 arg13, + TArg14 arg14) { await Task.Run(() => ThrowIfNull( arg1, @@ -424,42 +689,76 @@ await Task.Run(() => ThrowIfNull( arg11, arg12, arg13, - arg14, - paramName)); + arg14)).ConfigureAwait(false); } + /// + /// Check to ensure nullable parameters throw . + /// + /// Type for the 1st argument. + /// Type for the 2nd argument. + /// Type for the 3rd argument. + /// Type for the 4th argument. + /// Type for the 5th argument. + /// Type for the 6th argument. + /// Type for the 7th argument. + /// Type for the 8th argument. + /// Type for the 9th argument. + /// Type for the 10th argument. + /// Type for the 11th argument. + /// Type for the 12th argument. + /// Type for the 13th argument. + /// Type for the 14th argument. + /// Type for the 15th argument. + /// The 1st nullable argument. + /// The 2nd nullable argument. + /// The 3rd nullable argument. + /// The 4th nullable argument. + /// The 5th nullable argument. + /// The 6th nullable argument. + /// The 7th nullable argument. + /// The 8th nullable argument. + /// The 9th nullable argument. + /// The 10th nullable argument. + /// The 11th nullable argument. + /// The 12th nullable argument. + /// The 13th nullable argument. + /// The 14th nullable argument. + /// The 15th nullable argument. + /// + /// A representing the asynchronous operation. + /// public static async Task ThrowIfNullAsync< - T1, - T2, - T3, - T4, - T5, - T6, - T7, - T8, - T9, - T10, - T11, - T12, - T13, - T14, - T15>( - T1 arg1, - T2 arg2, - T3 arg3, - T4 arg4, - T5 arg5, - T6 arg6, - T7 arg7, - T8 arg8, - T9 arg9, - T10 arg10, - T11 arg11, - T12 arg12, - T13 arg13, - T14 arg14, - T15 arg15, - string paramName) + TArg1, + TArg2, + TArg3, + TArg4, + TArg5, + TArg6, + TArg7, + TArg8, + TArg9, + TArg10, + TArg11, + TArg12, + TArg13, + TArg14, + TArg15>( + TArg1 arg1, + TArg2 arg2, + TArg3 arg3, + TArg4 arg4, + TArg5 arg5, + TArg6 arg6, + TArg7 arg7, + TArg8 arg8, + TArg9 arg9, + TArg10 arg10, + TArg11 arg11, + TArg12 arg12, + TArg13 arg13, + TArg14 arg14, + TArg15 arg15) { await Task.Run(() => ThrowIfNull( arg1, @@ -476,44 +775,80 @@ await Task.Run(() => ThrowIfNull( arg12, arg13, arg14, - arg15, - paramName)); + arg15)).ConfigureAwait(false); } + /// + /// Check to ensure nullable parameters throw . + /// + /// Type for the 1st argument. + /// Type for the 2nd argument. + /// Type for the 3rd argument. + /// Type for the 4th argument. + /// Type for the 5th argument. + /// Type for the 6th argument. + /// Type for the 7th argument. + /// Type for the 8th argument. + /// Type for the 9th argument. + /// Type for the 10th argument. + /// Type for the 11th argument. + /// Type for the 12th argument. + /// Type for the 13th argument. + /// Type for the 14th argument. + /// Type for the 15th argument. + /// Type for the 16th argument. + /// The 1st nullable argument. + /// The 2nd nullable argument. + /// The 3rd nullable argument. + /// The 4th nullable argument. + /// The 5th nullable argument. + /// The 6th nullable argument. + /// The 7th nullable argument. + /// The 8th nullable argument. + /// The 9th nullable argument. + /// The 10th nullable argument. + /// The 11th nullable argument. + /// The 12th nullable argument. + /// The 13th nullable argument. + /// The 14th nullable argument. + /// The 15th nullable argument. + /// The 16th nullable argument. + /// + /// A representing the asynchronous operation. + /// public static async Task ThrowIfNullAsync< - T1, - T2, - T3, - T4, - T5, - T6, - T7, - T8, - T9, - T10, - T11, - T12, - T13, - T14, - T15, - T16>( - T1 arg1, - T2 arg2, - T3 arg3, - T4 arg4, - T5 arg5, - T6 arg6, - T7 arg7, - T8 arg8, - T9 arg9, - T10 arg10, - T11 arg11, - T12 arg12, - T13 arg13, - T14 arg14, - T15 arg15, - T16 arg16, - string paramName) + TArg1, + TArg2, + TArg3, + TArg4, + TArg5, + TArg6, + TArg7, + TArg8, + TArg9, + TArg10, + TArg11, + TArg12, + TArg13, + TArg14, + TArg15, + TArg16>( + TArg1 arg1, + TArg2 arg2, + TArg3 arg3, + TArg4 arg4, + TArg5 arg5, + TArg6 arg6, + TArg7 arg7, + TArg8 arg8, + TArg9 arg9, + TArg10 arg10, + TArg11 arg11, + TArg12 arg12, + TArg13 arg13, + TArg14 arg14, + TArg15 arg15, + TArg16 arg16) { await Task.Run(() => ThrowIfNull( arg1, @@ -531,42 +866,67 @@ await Task.Run(() => ThrowIfNull( arg13, arg14, arg15, - arg16, - paramName)); + arg16)).ConfigureAwait(false); } - public static void ThrowIfNull(T arg, string paramName) - + /// + /// Check to ensure nullable parameters throw . + /// + /// Type for the argument. + /// The nullable argument. + public static void ThrowIfNull(TArg arg) { - if (arg == null) - { - throw new ArgumentNullException(paramName); - } + ThrowIfNull(arg, nameof(arg)); } + /// + /// Check to ensure nullable parameters throw . + /// + /// Type for the 1st argument. + /// Type for the 2nd argument. + /// The 1st nullable argument. + /// The 2nd nullable argument. public static void ThrowIfNull( TArg1 arg1, - TArg2 arg2, - string paramName) + TArg2 arg2) { ThrowIfNull(arg1, nameof(arg1)); ThrowIfNull(arg2, nameof(arg2)); } + /// + /// Check to ensure nullable parameters throw . + /// + /// Type for the 1st argument. + /// Type for the 2nd argument. + /// Type for the 3rd argument. + /// The 1st nullable argument. + /// The 2nd nullable argument. + /// The 3rd nullable argument. public static void ThrowIfNull< TArg1, TArg2, TArg3>( TArg1 arg1, TArg2 arg2, - TArg3 arg3, - string paramName) + TArg3 arg3) { ThrowIfNull(arg1, nameof(arg1)); ThrowIfNull(arg2, nameof(arg2)); ThrowIfNull(arg3, nameof(arg3)); } + /// + /// Check to ensure nullable parameters throw . + /// + /// Type for the 1st argument. + /// Type for the 2nd argument. + /// Type for the 3rd argument. + /// Type for the 4th argument. + /// The 1st nullable argument. + /// The 2nd nullable argument. + /// The 3rd nullable argument. + /// The 4th nullable argument. public static void ThrowIfNull< TArg1, TArg2, @@ -575,8 +935,7 @@ public static void ThrowIfNull< TArg1 arg1, TArg2 arg2, TArg3 arg3, - TArg4 arg4, - string paramName) + TArg4 arg4) { ThrowIfNull(arg1, nameof(arg1)); ThrowIfNull(arg2, nameof(arg2)); @@ -584,6 +943,19 @@ public static void ThrowIfNull< ThrowIfNull(arg4, nameof(arg4)); } + /// + /// Check to ensure nullable parameters throw . + /// + /// Type for the 1st argument. + /// Type for the 2nd argument. + /// Type for the 3rd argument. + /// Type for the 4th argument. + /// Type for the 5th argument. + /// The 1st nullable argument. + /// The 2nd nullable argument. + /// The 3rd nullable argument. + /// The 4th nullable argument. + /// The 5th nullable argument. public static void ThrowIfNull< TArg1, TArg2, @@ -594,8 +966,7 @@ public static void ThrowIfNull< TArg2 arg2, TArg3 arg3, TArg4 arg4, - TArg5 arg5, - string paramName) + TArg5 arg5) { ThrowIfNull(arg1, nameof(arg1)); ThrowIfNull(arg2, nameof(arg2)); @@ -604,6 +975,21 @@ public static void ThrowIfNull< ThrowIfNull(arg5, nameof(arg5)); } + /// + /// Check to ensure nullable parameters throw . + /// + /// Type for the 1st argument. + /// Type for the 2nd argument. + /// Type for the 3rd argument. + /// Type for the 4th argument. + /// Type for the 5th argument. + /// Type for the 6th argument. + /// The 1st nullable argument. + /// The 2nd nullable argument. + /// The 3rd nullable argument. + /// The 4th nullable argument. + /// The 5th nullable argument. + /// The 6th nullable argument. public static void ThrowIfNull< TArg1, TArg2, @@ -616,8 +1002,7 @@ public static void ThrowIfNull< TArg3 arg3, TArg4 arg4, TArg5 arg5, - TArg6 arg6, - string paramName) + TArg6 arg6) { ThrowIfNull(arg1, nameof(arg1)); ThrowIfNull(arg2, nameof(arg2)); @@ -627,6 +1012,23 @@ public static void ThrowIfNull< ThrowIfNull(arg6, nameof(arg6)); } + /// + /// Check to ensure nullable parameters throw . + /// + /// Type for the 1st argument. + /// Type for the 2nd argument. + /// Type for the 3rd argument. + /// Type for the 4th argument. + /// Type for the 5th argument. + /// Type for the 6th argument. + /// Type for the 7th argument. + /// The 1st nullable argument. + /// The 2nd nullable argument. + /// The 3rd nullable argument. + /// The 4th nullable argument. + /// The 5th nullable argument. + /// The 6th nullable argument. + /// The 7th nullable argument. public static void ThrowIfNull< TArg1, TArg2, @@ -641,8 +1043,7 @@ public static void ThrowIfNull< TArg4 arg4, TArg5 arg5, TArg6 arg6, - TArg7 arg7, - string paramName) + TArg7 arg7) { ThrowIfNull(arg1, nameof(arg1)); ThrowIfNull(arg2, nameof(arg2)); @@ -653,6 +1054,25 @@ public static void ThrowIfNull< ThrowIfNull(arg7, nameof(arg7)); } + /// + /// Check to ensure nullable parameters throw . + /// + /// Type for the 1st argument. + /// Type for the 2nd argument. + /// Type for the 3rd argument. + /// Type for the 4th argument. + /// Type for the 5th argument. + /// Type for the 6th argument. + /// Type for the 7th argument. + /// Type for the 8th argument. + /// The 1st nullable argument. + /// The 2nd nullable argument. + /// The 3rd nullable argument. + /// The 4th nullable argument. + /// The 5th nullable argument. + /// The 6th nullable argument. + /// The 7th nullable argument. + /// The 8th nullable argument. public static void ThrowIfNull< TArg1, TArg2, @@ -669,8 +1089,7 @@ public static void ThrowIfNull< TArg5 arg5, TArg6 arg6, TArg7 arg7, - TArg8 arg8, - string paramName) + TArg8 arg8) { ThrowIfNull(arg1, nameof(arg1)); ThrowIfNull(arg2, nameof(arg2)); @@ -682,6 +1101,27 @@ public static void ThrowIfNull< ThrowIfNull(arg8, nameof(arg8)); } + /// + /// Check to ensure nullable parameters throw . + /// + /// Type for the 1st argument. + /// Type for the 2nd argument. + /// Type for the 3rd argument. + /// Type for the 4th argument. + /// Type for the 5th argument. + /// Type for the 6th argument. + /// Type for the 7th argument. + /// Type for the 8th argument. + /// Type for the 9th argument. + /// The 1st nullable argument. + /// The 2nd nullable argument. + /// The 3rd nullable argument. + /// The 4th nullable argument. + /// The 5th nullable argument. + /// The 6th nullable argument. + /// The 7th nullable argument. + /// The 8th nullable argument. + /// The 9th nullable argument. public static void ThrowIfNull< TArg1, TArg2, @@ -700,8 +1140,7 @@ public static void ThrowIfNull< TArg6 arg6, TArg7 arg7, TArg8 arg8, - TArg9 arg9, - string paramName) + TArg9 arg9) { ThrowIfNull(arg1, nameof(arg1)); ThrowIfNull(arg2, nameof(arg2)); @@ -714,6 +1153,29 @@ public static void ThrowIfNull< ThrowIfNull(arg9, nameof(arg9)); } + /// + /// Check to ensure nullable parameters throw . + /// + /// Type for the 1st argument. + /// Type for the 2nd argument. + /// Type for the 3rd argument. + /// Type for the 4th argument. + /// Type for the 5th argument. + /// Type for the 6th argument. + /// Type for the 7th argument. + /// Type for the 8th argument. + /// Type for the 9th argument. + /// Type for the 10th argument. + /// The 1st nullable argument. + /// The 2nd nullable argument. + /// The 3rd nullable argument. + /// The 4th nullable argument. + /// The 5th nullable argument. + /// The 6th nullable argument. + /// The 7th nullable argument. + /// The 8th nullable argument. + /// The 9th nullable argument. + /// The 10th nullable argument. public static void ThrowIfNull< TArg1, TArg2, @@ -734,8 +1196,7 @@ public static void ThrowIfNull< TArg7 arg7, TArg8 arg8, TArg9 arg9, - TArg10 arg10, - string paramName) + TArg10 arg10) { ThrowIfNull(arg1, nameof(arg1)); ThrowIfNull(arg2, nameof(arg2)); @@ -749,6 +1210,31 @@ public static void ThrowIfNull< ThrowIfNull(arg10, nameof(arg10)); } + /// + /// Check to ensure nullable parameters throw . + /// + /// Type for the 1st argument. + /// Type for the 2nd argument. + /// Type for the 3rd argument. + /// Type for the 4th argument. + /// Type for the 5th argument. + /// Type for the 6th argument. + /// Type for the 7th argument. + /// Type for the 8th argument. + /// Type for the 9th argument. + /// Type for the 10th argument. + /// Type for the 11th argument. + /// The 1st nullable argument. + /// The 2nd nullable argument. + /// The 3rd nullable argument. + /// The 4th nullable argument. + /// The 5th nullable argument. + /// The 6th nullable argument. + /// The 7th nullable argument. + /// The 8th nullable argument. + /// The 9th nullable argument. + /// The 10th nullable argument. + /// The 11th nullable argument. public static void ThrowIfNull< TArg1, TArg2, @@ -771,8 +1257,7 @@ public static void ThrowIfNull< TArg8 arg8, TArg9 arg9, TArg10 arg10, - TArg11 arg11, - string paramName) + TArg11 arg11) { ThrowIfNull(arg1, nameof(arg1)); ThrowIfNull(arg2, nameof(arg2)); @@ -787,6 +1272,33 @@ public static void ThrowIfNull< ThrowIfNull(arg11, nameof(arg11)); } + /// + /// Check to ensure nullable parameters throw . + /// + /// Type for the 1st argument. + /// Type for the 2nd argument. + /// Type for the 3rd argument. + /// Type for the 4th argument. + /// Type for the 5th argument. + /// Type for the 6th argument. + /// Type for the 7th argument. + /// Type for the 8th argument. + /// Type for the 9th argument. + /// Type for the 10th argument. + /// Type for the 11th argument. + /// Type for the 12th argument. + /// The 1st nullable argument. + /// The 2nd nullable argument. + /// The 3rd nullable argument. + /// The 4th nullable argument. + /// The 5th nullable argument. + /// The 6th nullable argument. + /// The 7th nullable argument. + /// The 8th nullable argument. + /// The 9th nullable argument. + /// The 10th nullable argument. + /// The 11th nullable argument. + /// The 12th nullable argument. public static void ThrowIfNull< TArg1, TArg2, @@ -811,8 +1323,7 @@ public static void ThrowIfNull< TArg9 arg9, TArg10 arg10, TArg11 arg11, - TArg12 arg12, - string paramName) + TArg12 arg12) { ThrowIfNull(arg1, nameof(arg1)); ThrowIfNull(arg2, nameof(arg2)); @@ -828,6 +1339,35 @@ public static void ThrowIfNull< ThrowIfNull(arg12, nameof(arg12)); } + /// + /// Check to ensure nullable parameters throw . + /// + /// Type for the 1st argument. + /// Type for the 2nd argument. + /// Type for the 3rd argument. + /// Type for the 4th argument. + /// Type for the 5th argument. + /// Type for the 6th argument. + /// Type for the 7th argument. + /// Type for the 8th argument. + /// Type for the 9th argument. + /// Type for the 10th argument. + /// Type for the 11th argument. + /// Type for the 12th argument. + /// Type for the 13th argument. + /// The 1st nullable argument. + /// The 2nd nullable argument. + /// The 3rd nullable argument. + /// The 4th nullable argument. + /// The 5th nullable argument. + /// The 6th nullable argument. + /// The 7th nullable argument. + /// The 8th nullable argument. + /// The 9th nullable argument. + /// The 10th nullable argument. + /// The 11th nullable argument. + /// The 12th nullable argument. + /// The 13th nullable argument. public static void ThrowIfNull< TArg1, TArg2, @@ -854,8 +1394,7 @@ public static void ThrowIfNull< TArg10 arg10, TArg11 arg11, TArg12 arg12, - TArg13 arg13, - string paramName) + TArg13 arg13) { ThrowIfNull(arg1, nameof(arg1)); ThrowIfNull(arg2, nameof(arg2)); @@ -872,6 +1411,37 @@ public static void ThrowIfNull< ThrowIfNull(arg13, nameof(arg13)); } + /// + /// Check to ensure nullable parameters throw . + /// + /// Type for the 1st argument. + /// Type for the 2nd argument. + /// Type for the 3rd argument. + /// Type for the 4th argument. + /// Type for the 5th argument. + /// Type for the 6th argument. + /// Type for the 7th argument. + /// Type for the 8th argument. + /// Type for the 9th argument. + /// Type for the 10th argument. + /// Type for the 11th argument. + /// Type for the 12th argument. + /// Type for the 13th argument. + /// Type for the 14th argument. + /// The 1st nullable argument. + /// The 2nd nullable argument. + /// The 3rd nullable argument. + /// The 4th nullable argument. + /// The 5th nullable argument. + /// The 6th nullable argument. + /// The 7th nullable argument. + /// The 8th nullable argument. + /// The 9th nullable argument. + /// The 10th nullable argument. + /// The 11th nullable argument. + /// The 12th nullable argument. + /// The 13th nullable argument. + /// The 14th nullable argument. public static void ThrowIfNull< TArg1, TArg2, @@ -900,8 +1470,7 @@ public static void ThrowIfNull< TArg11 arg11, TArg12 arg12, TArg13 arg13, - TArg14 arg14, - string paramName) + TArg14 arg14) { ThrowIfNull(arg1, nameof(arg1)); ThrowIfNull(arg2, nameof(arg2)); @@ -919,6 +1488,39 @@ public static void ThrowIfNull< ThrowIfNull(arg14, nameof(arg14)); } + /// + /// Check to ensure nullable parameters throw . + /// + /// Type for the 1st argument. + /// Type for the 2nd argument. + /// Type for the 3rd argument. + /// Type for the 4th argument. + /// Type for the 5th argument. + /// Type for the 6th argument. + /// Type for the 7th argument. + /// Type for the 8th argument. + /// Type for the 9th argument. + /// Type for the 10th argument. + /// Type for the 11th argument. + /// Type for the 12th argument. + /// Type for the 13th argument. + /// Type for the 14th argument. + /// Type for the 15th argument. + /// The 1st nullable argument. + /// The 2nd nullable argument. + /// The 3rd nullable argument. + /// The 4th nullable argument. + /// The 5th nullable argument. + /// The 6th nullable argument. + /// The 7th nullable argument. + /// The 8th nullable argument. + /// The 9th nullable argument. + /// The 10th nullable argument. + /// The 11th nullable argument. + /// The 12th nullable argument. + /// The 13th nullable argument. + /// The 14th nullable argument. + /// The 15th nullable argument. public static void ThrowIfNull< TArg1, TArg2, @@ -949,8 +1551,7 @@ public static void ThrowIfNull< TArg12 arg12, TArg13 arg13, TArg14 arg14, - TArg15 arg15, - string paramName) + TArg15 arg15) { ThrowIfNull(arg1, nameof(arg1)); ThrowIfNull(arg2, nameof(arg2)); @@ -969,6 +1570,41 @@ public static void ThrowIfNull< ThrowIfNull(arg15, nameof(arg15)); } + /// + /// Check to ensure nullable parameters throw . + /// + /// Type for the 1st argument. + /// Type for the 2nd argument. + /// Type for the 3rd argument. + /// Type for the 4th argument. + /// Type for the 5th argument. + /// Type for the 6th argument. + /// Type for the 7th argument. + /// Type for the 8th argument. + /// Type for the 9th argument. + /// Type for the 10th argument. + /// Type for the 11th argument. + /// Type for the 12th argument. + /// Type for the 13th argument. + /// Type for the 14th argument. + /// Type for the 15th argument. + /// Type for the 16th argument. + /// The 1st nullable argument. + /// The 2nd nullable argument. + /// The 3rd nullable argument. + /// The 4th nullable argument. + /// The 5th nullable argument. + /// The 6th nullable argument. + /// The 7th nullable argument. + /// The 8th nullable argument. + /// The 9th nullable argument. + /// The 10th nullable argument. + /// The 11th nullable argument. + /// The 12th nullable argument. + /// The 13th nullable argument. + /// The 14th nullable argument. + /// The 15th nullable argument. + /// The 16th nullable argument. public static void ThrowIfNull< TArg1, TArg2, @@ -1001,8 +1637,7 @@ public static void ThrowIfNull< TArg13 arg13, TArg14 arg14, TArg15 arg15, - TArg16 arg16, - string paramName) + TArg16 arg16) { ThrowIfNull(arg1, nameof(arg1)); ThrowIfNull(arg2, nameof(arg2)); @@ -1021,5 +1656,14 @@ public static void ThrowIfNull< ThrowIfNull(arg15, nameof(arg15)); ThrowIfNull(arg16, nameof(arg16)); } + + // ReSharper disable once ParameterOnlyUsedForPreconditionCheck.Local + private static void ThrowIfNull(TArg arg, string paramName) + { + if (arg == null) + { + throw new ArgumentNullException(paramName); + } + } } } diff --git a/src/NetTestRegimentation.UnitTests/FakeObject.cs b/src/NetTestRegimentation.UnitTests/FakeObject.cs index d89efc8..59ba3e3 100644 --- a/src/NetTestRegimentation.UnitTests/FakeObject.cs +++ b/src/NetTestRegimentation.UnitTests/FakeObject.cs @@ -1,13 +1,17 @@ -using System; +// Copyright (c) 2019 dpvreony and Contributors. All rights reserved. +// This file is licensed to you under the MIT license. +// See the LICENSE file in the project root for full license information. + +using System; using System.Collections.Generic; using System.Text; namespace NetTestRegimentation.UnitTests { + /// + /// Fake object for testing. + /// public class FakeObject : IFakeObject { } - public interface IFakeObject - { - } } diff --git a/src/NetTestRegimentation.UnitTests/IFakeObject.cs b/src/NetTestRegimentation.UnitTests/IFakeObject.cs new file mode 100644 index 0000000..83a3c0c --- /dev/null +++ b/src/NetTestRegimentation.UnitTests/IFakeObject.cs @@ -0,0 +1,15 @@ +// Copyright (c) 2019 dpvreony and Contributors. All rights reserved. +// This file is licensed to you under the MIT license. +// See the LICENSE file in the project root for full license information. + +namespace NetTestRegimentation.UnitTests +{ + /// + /// Represents a fake object. + /// +#pragma warning disable CA1040 // Avoid empty interfaces + public interface IFakeObject +#pragma warning restore CA1040 // Avoid empty interfaces + { + } +} diff --git a/src/NetTestRegimentation.UnitTests/ITestAsyncMethodWithNullableParametersT10Test.cs b/src/NetTestRegimentation.UnitTests/ITestAsyncMethodWithNullableParametersT10Test.cs index 64d21a5..2c26671 100644 --- a/src/NetTestRegimentation.UnitTests/ITestAsyncMethodWithNullableParametersT10Test.cs +++ b/src/NetTestRegimentation.UnitTests/ITestAsyncMethodWithNullableParametersT10Test.cs @@ -1,4 +1,8 @@ -using System; +// Copyright (c) 2019 dpvreony and Contributors. All rights reserved. +// This file is licensed to you under the MIT license. +// See the LICENSE file in the project root for full license information. + +using System; using System.Collections.Generic; using System.Diagnostics.CodeAnalysis; using System.Threading.Tasks; @@ -6,9 +10,14 @@ namespace NetTestRegimentation.UnitTests { + /// + /// Unit Tests for 10 nullable parameters. + /// [ExcludeFromCodeCoverage] public static class ITestAsyncMethodWithNullableParametersT10Test { +#pragma warning disable CA1034 // Nested types should not be visible + /// public sealed class Throws : ITestAsyncMethodWithNullableParameters< FakeObject, FakeObject, @@ -21,8 +30,12 @@ public sealed class Throws : ITestAsyncMethodWithNullableParameters< FakeObject, FakeObject> { - public static IEnumerable ThrowsArgumentNullExceptionAsyncTestSource = ObjectArrayHelper.GetArgObjectArrayOfArray(10); + /// + /// Gets the Test Data Source for the method. + /// + public static IEnumerable ThrowsArgumentNullExceptionAsyncTestSource => ObjectArrayHelper.GetArgObjectArrayOfArray(10); + /// [Theory] [MemberData(nameof(ThrowsArgumentNullExceptionAsyncTestSource))] public async Task ThrowsArgumentNullExceptionAsync( @@ -48,10 +61,10 @@ public async Task ThrowsArgumentNullExceptionAsync( arg7, arg8, arg9, - arg10, - expectedParameterNameForException)); + arg10)).ConfigureAwait(false); Assert.Equal(expectedParameterNameForException, exception.ParamName); } } +#pragma warning restore CA1034 // Nested types should not be visible } -} \ No newline at end of file +} diff --git a/src/NetTestRegimentation.UnitTests/ITestAsyncMethodWithNullableParametersT11Test.cs b/src/NetTestRegimentation.UnitTests/ITestAsyncMethodWithNullableParametersT11Test.cs index c71b594..023eadf 100644 --- a/src/NetTestRegimentation.UnitTests/ITestAsyncMethodWithNullableParametersT11Test.cs +++ b/src/NetTestRegimentation.UnitTests/ITestAsyncMethodWithNullableParametersT11Test.cs @@ -1,4 +1,8 @@ -using System; +// Copyright (c) 2019 dpvreony and Contributors. All rights reserved. +// This file is licensed to you under the MIT license. +// See the LICENSE file in the project root for full license information. + +using System; using System.Collections.Generic; using System.Diagnostics.CodeAnalysis; using System.Threading.Tasks; @@ -6,9 +10,14 @@ namespace NetTestRegimentation.UnitTests { + /// + /// Unit Tests for 11 nullable parameters. + /// [ExcludeFromCodeCoverage] public static class ITestAsyncMethodWithNullableParametersT11Test { +#pragma warning disable CA1034 // Nested types should not be visible + /// public sealed class Throws : ITestAsyncMethodWithNullableParameters< FakeObject, FakeObject, @@ -22,8 +31,12 @@ public sealed class Throws : ITestAsyncMethodWithNullableParameters< FakeObject, FakeObject> { - public static IEnumerable ThrowsArgumentNullExceptionAsyncTestSource = ObjectArrayHelper.GetArgObjectArrayOfArray(11); + /// + /// Gets the Test Data Source for the method. + /// + public static IEnumerable ThrowsArgumentNullExceptionAsyncTestSource => ObjectArrayHelper.GetArgObjectArrayOfArray(11); + /// [Theory] [MemberData(nameof(ThrowsArgumentNullExceptionAsyncTestSource))] public async Task ThrowsArgumentNullExceptionAsync( @@ -51,10 +64,10 @@ public async Task ThrowsArgumentNullExceptionAsync( arg8, arg9, arg10, - arg11, - expectedParameterNameForException)); + arg11)).ConfigureAwait(false); Assert.Equal(expectedParameterNameForException, exception.ParamName); } } +#pragma warning restore CA1034 // Nested types should not be visible } -} \ No newline at end of file +} diff --git a/src/NetTestRegimentation.UnitTests/ITestAsyncMethodWithNullableParametersT12Test.cs b/src/NetTestRegimentation.UnitTests/ITestAsyncMethodWithNullableParametersT12Test.cs index 9ae7532..d99e416 100644 --- a/src/NetTestRegimentation.UnitTests/ITestAsyncMethodWithNullableParametersT12Test.cs +++ b/src/NetTestRegimentation.UnitTests/ITestAsyncMethodWithNullableParametersT12Test.cs @@ -1,4 +1,8 @@ -using System; +// Copyright (c) 2019 dpvreony and Contributors. All rights reserved. +// This file is licensed to you under the MIT license. +// See the LICENSE file in the project root for full license information. + +using System; using System.Collections.Generic; using System.Diagnostics.CodeAnalysis; using System.Threading.Tasks; @@ -6,9 +10,14 @@ namespace NetTestRegimentation.UnitTests { + /// + /// Unit Tests for 12 nullable parameters. + /// [ExcludeFromCodeCoverage] public static class ITestAsyncMethodWithNullableParametersT12Test { +#pragma warning disable CA1034 // Nested types should not be visible + /// public sealed class Throws : ITestAsyncMethodWithNullableParameters< FakeObject, FakeObject, @@ -23,8 +32,12 @@ public sealed class Throws : ITestAsyncMethodWithNullableParameters< FakeObject, FakeObject> { - public static IEnumerable ThrowsArgumentNullExceptionAsyncTestSource = ObjectArrayHelper.GetArgObjectArrayOfArray(12); + /// + /// Gets the Test Data Source for the method. + /// + public static IEnumerable ThrowsArgumentNullExceptionAsyncTestSource => ObjectArrayHelper.GetArgObjectArrayOfArray(12); + /// [Theory] [MemberData(nameof(ThrowsArgumentNullExceptionAsyncTestSource))] public async Task ThrowsArgumentNullExceptionAsync( @@ -54,10 +67,10 @@ public async Task ThrowsArgumentNullExceptionAsync( arg9, arg10, arg11, - arg12, - expectedParameterNameForException)); + arg12)).ConfigureAwait(false); Assert.Equal(expectedParameterNameForException, exception.ParamName); } } +#pragma warning restore CA1034 // Nested types should not be visible } -} \ No newline at end of file +} diff --git a/src/NetTestRegimentation.UnitTests/ITestAsyncMethodWithNullableParametersT13Test.cs b/src/NetTestRegimentation.UnitTests/ITestAsyncMethodWithNullableParametersT13Test.cs index c1f1e8b..4e5996b 100644 --- a/src/NetTestRegimentation.UnitTests/ITestAsyncMethodWithNullableParametersT13Test.cs +++ b/src/NetTestRegimentation.UnitTests/ITestAsyncMethodWithNullableParametersT13Test.cs @@ -1,4 +1,8 @@ -using System; +// Copyright (c) 2019 dpvreony and Contributors. All rights reserved. +// This file is licensed to you under the MIT license. +// See the LICENSE file in the project root for full license information. + +using System; using System.Collections.Generic; using System.Diagnostics.CodeAnalysis; using System.Threading.Tasks; @@ -6,9 +10,14 @@ namespace NetTestRegimentation.UnitTests { + /// + /// Unit Tests for 13 nullable parameters. + /// [ExcludeFromCodeCoverage] public static class ITestAsyncMethodWithNullableParametersT13Test { +#pragma warning disable CA1034 // Nested types should not be visible + /// public sealed class Throws : ITestAsyncMethodWithNullableParameters< FakeObject, FakeObject, @@ -24,8 +33,12 @@ public sealed class Throws : ITestAsyncMethodWithNullableParameters< FakeObject, FakeObject> { - public static IEnumerable ThrowsArgumentNullExceptionAsyncTestSource = ObjectArrayHelper.GetArgObjectArrayOfArray(13); + /// + /// Gets the Test Data Source for the method. + /// + public static IEnumerable ThrowsArgumentNullExceptionAsyncTestSource => ObjectArrayHelper.GetArgObjectArrayOfArray(13); + /// [Theory] [MemberData(nameof(ThrowsArgumentNullExceptionAsyncTestSource))] public async Task ThrowsArgumentNullExceptionAsync( @@ -57,10 +70,10 @@ public async Task ThrowsArgumentNullExceptionAsync( arg10, arg11, arg12, - arg13, - expectedParameterNameForException)); + arg13)).ConfigureAwait(false); Assert.Equal(expectedParameterNameForException, exception.ParamName); } } +#pragma warning restore CA1034 // Nested types should not be visible } -} \ No newline at end of file +} diff --git a/src/NetTestRegimentation.UnitTests/ITestAsyncMethodWithNullableParametersT14Test.cs b/src/NetTestRegimentation.UnitTests/ITestAsyncMethodWithNullableParametersT14Test.cs index 3000a71..5802cec 100644 --- a/src/NetTestRegimentation.UnitTests/ITestAsyncMethodWithNullableParametersT14Test.cs +++ b/src/NetTestRegimentation.UnitTests/ITestAsyncMethodWithNullableParametersT14Test.cs @@ -1,4 +1,8 @@ -using System; +// Copyright (c) 2019 dpvreony and Contributors. All rights reserved. +// This file is licensed to you under the MIT license. +// See the LICENSE file in the project root for full license information. + +using System; using System.Collections.Generic; using System.Diagnostics.CodeAnalysis; using System.Threading.Tasks; @@ -6,9 +10,14 @@ namespace NetTestRegimentation.UnitTests { + /// + /// Unit Tests for 14 nullable parameters. + /// [ExcludeFromCodeCoverage] public static class ITestAsyncMethodWithNullableParametersT14Test { +#pragma warning disable CA1034 // Nested types should not be visible + /// public sealed class Throws : ITestAsyncMethodWithNullableParameters< FakeObject, FakeObject, @@ -25,8 +34,12 @@ public sealed class Throws : ITestAsyncMethodWithNullableParameters< FakeObject, FakeObject> { - public static IEnumerable ThrowsArgumentNullExceptionAsyncTestSource = ObjectArrayHelper.GetArgObjectArrayOfArray(14); + /// + /// Gets the Test Data Source for the method. + /// + public static IEnumerable ThrowsArgumentNullExceptionAsyncTestSource => ObjectArrayHelper.GetArgObjectArrayOfArray(14); + /// [Theory] [MemberData(nameof(ThrowsArgumentNullExceptionAsyncTestSource))] public async Task ThrowsArgumentNullExceptionAsync( @@ -60,10 +73,10 @@ public async Task ThrowsArgumentNullExceptionAsync( arg11, arg12, arg13, - arg14, - expectedParameterNameForException)); + arg14)).ConfigureAwait(false); Assert.Equal(expectedParameterNameForException, exception.ParamName); } } +#pragma warning restore CA1034 // Nested types should not be visible } -} \ No newline at end of file +} diff --git a/src/NetTestRegimentation.UnitTests/ITestAsyncMethodWithNullableParametersT15Test.cs b/src/NetTestRegimentation.UnitTests/ITestAsyncMethodWithNullableParametersT15Test.cs index 7eb78e0..f82066a 100644 --- a/src/NetTestRegimentation.UnitTests/ITestAsyncMethodWithNullableParametersT15Test.cs +++ b/src/NetTestRegimentation.UnitTests/ITestAsyncMethodWithNullableParametersT15Test.cs @@ -1,4 +1,8 @@ -using System; +// Copyright (c) 2019 dpvreony and Contributors. All rights reserved. +// This file is licensed to you under the MIT license. +// See the LICENSE file in the project root for full license information. + +using System; using System.Collections.Generic; using System.Diagnostics.CodeAnalysis; using System.Threading.Tasks; @@ -6,9 +10,14 @@ namespace NetTestRegimentation.UnitTests { + /// + /// Unit Tests for 15 nullable parameters. + /// [ExcludeFromCodeCoverage] public static class ITestAsyncMethodWithNullableParametersT15Test { +#pragma warning disable CA1034 // Nested types should not be visible + /// public sealed class Throws : ITestAsyncMethodWithNullableParameters< FakeObject, FakeObject, @@ -26,8 +35,12 @@ public sealed class Throws : ITestAsyncMethodWithNullableParameters< FakeObject, FakeObject> { - public static IEnumerable ThrowsArgumentNullExceptionAsyncTestSource = ObjectArrayHelper.GetArgObjectArrayOfArray(15); + /// + /// Gets the Test Data Source for the method. + /// + public static IEnumerable ThrowsArgumentNullExceptionAsyncTestSource => ObjectArrayHelper.GetArgObjectArrayOfArray(15); + /// [Theory] [MemberData(nameof(ThrowsArgumentNullExceptionAsyncTestSource))] public async Task ThrowsArgumentNullExceptionAsync( @@ -63,10 +76,10 @@ public async Task ThrowsArgumentNullExceptionAsync( arg12, arg13, arg14, - arg15, - expectedParameterNameForException)); + arg15)).ConfigureAwait(false); Assert.Equal(expectedParameterNameForException, exception.ParamName); } } +#pragma warning restore CA1034 // Nested types should not be visible } -} \ No newline at end of file +} diff --git a/src/NetTestRegimentation.UnitTests/ITestAsyncMethodWithNullableParametersT16Test.cs b/src/NetTestRegimentation.UnitTests/ITestAsyncMethodWithNullableParametersT16Test.cs index ce55d73..308fd3a 100644 --- a/src/NetTestRegimentation.UnitTests/ITestAsyncMethodWithNullableParametersT16Test.cs +++ b/src/NetTestRegimentation.UnitTests/ITestAsyncMethodWithNullableParametersT16Test.cs @@ -1,4 +1,8 @@ -using System; +// Copyright (c) 2019 dpvreony and Contributors. All rights reserved. +// This file is licensed to you under the MIT license. +// See the LICENSE file in the project root for full license information. + +using System; using System.Collections.Generic; using System.Diagnostics.CodeAnalysis; using System.Threading.Tasks; @@ -6,9 +10,14 @@ namespace NetTestRegimentation.UnitTests { + /// + /// Unit Tests for 16 nullable parameters. + /// [ExcludeFromCodeCoverage] public static class ITestAsyncMethodWithNullableParametersT16Test { +#pragma warning disable CA1034 // Nested types should not be visible + /// public sealed class Throws : ITestAsyncMethodWithNullableParameters< FakeObject, FakeObject, @@ -27,8 +36,12 @@ public sealed class Throws : ITestAsyncMethodWithNullableParameters< FakeObject, FakeObject> { - public static IEnumerable ThrowsArgumentNullExceptionAsyncTestSource = ObjectArrayHelper.GetArgObjectArrayOfArray(16); + /// + /// Gets the Test Data Source for the method. + /// + public static IEnumerable ThrowsArgumentNullExceptionAsyncTestSource => ObjectArrayHelper.GetArgObjectArrayOfArray(16); + /// [Theory] [MemberData(nameof(ThrowsArgumentNullExceptionAsyncTestSource))] public async Task ThrowsArgumentNullExceptionAsync( @@ -66,10 +79,10 @@ public async Task ThrowsArgumentNullExceptionAsync( arg13, arg14, arg15, - arg16, - expectedParameterNameForException)); + arg16)).ConfigureAwait(false); Assert.Equal(expectedParameterNameForException, exception.ParamName); } } +#pragma warning restore CA1034 // Nested types should not be visible } -} \ No newline at end of file +} diff --git a/src/NetTestRegimentation.UnitTests/ITestAsyncMethodWithNullableParametersT1Test.cs b/src/NetTestRegimentation.UnitTests/ITestAsyncMethodWithNullableParametersT1Test.cs index d42a077..466602d 100644 --- a/src/NetTestRegimentation.UnitTests/ITestAsyncMethodWithNullableParametersT1Test.cs +++ b/src/NetTestRegimentation.UnitTests/ITestAsyncMethodWithNullableParametersT1Test.cs @@ -1,4 +1,8 @@ -using System; +// Copyright (c) 2019 dpvreony and Contributors. All rights reserved. +// This file is licensed to you under the MIT license. +// See the LICENSE file in the project root for full license information. + +using System; using System.Collections.Generic; using System.Diagnostics.CodeAnalysis; using System.Threading.Tasks; @@ -6,22 +10,32 @@ namespace NetTestRegimentation.UnitTests { + /// + /// Unit Tests for 1 nullable parameter. + /// [ExcludeFromCodeCoverage] public static class ITestAsyncMethodWithNullableParametersT1Test { +#pragma warning disable CA1034 // Nested types should not be visible + /// public sealed class Throws : ITestAsyncMethodWithNullableParameters { - public static IEnumerable ThrowsArgumentNullExceptionAsyncTestSource = ObjectArrayHelper.GetArgObjectArrayOfArray(1); + /// + /// Gets the Test Data Source for the method. + /// + public static IEnumerable ThrowsArgumentNullExceptionAsyncTestSource => ObjectArrayHelper.GetArgObjectArrayOfArray(1); + /// [Theory] [MemberData(nameof(ThrowsArgumentNullExceptionAsyncTestSource))] public async Task ThrowsArgumentNullExceptionAsync( FakeObject arg, string expectedParameterNameForException) { - var exception = await Assert.ThrowsAsync(() => ArgumentHelpers.ThrowIfNullAsync(arg, expectedParameterNameForException)); + var exception = await Assert.ThrowsAsync(() => ArgumentHelpers.ThrowIfNullAsync(arg)).ConfigureAwait(false); Assert.Equal(expectedParameterNameForException, exception.ParamName); } } +#pragma warning restore CA1034 // Nested types should not be visible } } diff --git a/src/NetTestRegimentation.UnitTests/ITestAsyncMethodWithNullableParametersT2Test.cs b/src/NetTestRegimentation.UnitTests/ITestAsyncMethodWithNullableParametersT2Test.cs index dfdbb9a..902a46e 100644 --- a/src/NetTestRegimentation.UnitTests/ITestAsyncMethodWithNullableParametersT2Test.cs +++ b/src/NetTestRegimentation.UnitTests/ITestAsyncMethodWithNullableParametersT2Test.cs @@ -1,4 +1,8 @@ -using System; +// Copyright (c) 2019 dpvreony and Contributors. All rights reserved. +// This file is licensed to you under the MIT license. +// See the LICENSE file in the project root for full license information. + +using System; using System.Collections.Generic; using System.Diagnostics.CodeAnalysis; using System.Threading.Tasks; @@ -6,15 +10,24 @@ namespace NetTestRegimentation.UnitTests { + /// + /// Unit Tests for 2 nullable parameters. + /// [ExcludeFromCodeCoverage] public static class ITestAsyncMethodWithNullableParametersT2Test { +#pragma warning disable CA1034 // Nested types should not be visible + /// public sealed class Throws : ITestAsyncMethodWithNullableParameters< FakeObject, FakeObject> { - public static IEnumerable ThrowsArgumentNullExceptionAsyncTestSource = ObjectArrayHelper.GetArgObjectArrayOfArray(2); + /// + /// Gets the Test Data Source for the method. + /// + public static IEnumerable ThrowsArgumentNullExceptionAsyncTestSource => ObjectArrayHelper.GetArgObjectArrayOfArray(2); + /// [Theory] [MemberData(nameof(ThrowsArgumentNullExceptionAsyncTestSource))] public async Task ThrowsArgumentNullExceptionAsync( @@ -24,10 +37,10 @@ public async Task ThrowsArgumentNullExceptionAsync( { var exception = await Assert.ThrowsAsync(() => ArgumentHelpers.ThrowIfNullAsync( arg1, - arg2, - expectedParameterNameForException)); + arg2)).ConfigureAwait(false); Assert.Equal(expectedParameterNameForException, exception.ParamName); } } +#pragma warning restore CA1034 // Nested types should not be visible } } diff --git a/src/NetTestRegimentation.UnitTests/ITestAsyncMethodWithNullableParametersT3Test.cs b/src/NetTestRegimentation.UnitTests/ITestAsyncMethodWithNullableParametersT3Test.cs index 917e0fb..5be2f52 100644 --- a/src/NetTestRegimentation.UnitTests/ITestAsyncMethodWithNullableParametersT3Test.cs +++ b/src/NetTestRegimentation.UnitTests/ITestAsyncMethodWithNullableParametersT3Test.cs @@ -1,4 +1,8 @@ -using System; +// Copyright (c) 2019 dpvreony and Contributors. All rights reserved. +// This file is licensed to you under the MIT license. +// See the LICENSE file in the project root for full license information. + +using System; using System.Collections.Generic; using System.Diagnostics.CodeAnalysis; using System.Threading.Tasks; @@ -6,16 +10,25 @@ namespace NetTestRegimentation.UnitTests { + /// + /// Unit Tests for 3 nullable parameters. + /// [ExcludeFromCodeCoverage] public static class ITestAsyncMethodWithNullableParametersT3Test { +#pragma warning disable CA1034 // Nested types should not be visible + /// public sealed class Throws : ITestAsyncMethodWithNullableParameters< FakeObject, FakeObject, FakeObject> { - public static IEnumerable ThrowsArgumentNullExceptionAsyncTestSource = ObjectArrayHelper.GetArgObjectArrayOfArray(3); + /// + /// Gets the Test Data Source for the method. + /// + public static IEnumerable ThrowsArgumentNullExceptionAsyncTestSource => ObjectArrayHelper.GetArgObjectArrayOfArray(3); + /// [Theory] [MemberData(nameof(ThrowsArgumentNullExceptionAsyncTestSource))] public async Task ThrowsArgumentNullExceptionAsync( @@ -27,10 +40,10 @@ public async Task ThrowsArgumentNullExceptionAsync( var exception = await Assert.ThrowsAsync(() => ArgumentHelpers.ThrowIfNullAsync( arg1, arg2, - arg3, - expectedParameterNameForException)); + arg3)).ConfigureAwait(false); Assert.Equal(expectedParameterNameForException, exception.ParamName); } } +#pragma warning restore CA1034 // Nested types should not be visible } -} \ No newline at end of file +} diff --git a/src/NetTestRegimentation.UnitTests/ITestAsyncMethodWithNullableParametersT4Test.cs b/src/NetTestRegimentation.UnitTests/ITestAsyncMethodWithNullableParametersT4Test.cs index 4f1dd79..a60834a 100644 --- a/src/NetTestRegimentation.UnitTests/ITestAsyncMethodWithNullableParametersT4Test.cs +++ b/src/NetTestRegimentation.UnitTests/ITestAsyncMethodWithNullableParametersT4Test.cs @@ -1,4 +1,8 @@ -using System; +// Copyright (c) 2019 dpvreony and Contributors. All rights reserved. +// This file is licensed to you under the MIT license. +// See the LICENSE file in the project root for full license information. + +using System; using System.Collections.Generic; using System.Diagnostics.CodeAnalysis; using System.Threading.Tasks; @@ -6,17 +10,26 @@ namespace NetTestRegimentation.UnitTests { + /// + /// Unit Tests for 4 nullable parameters. + /// [ExcludeFromCodeCoverage] public static class ITestAsyncMethodWithNullableParametersT4Test { +#pragma warning disable CA1034 // Nested types should not be visible + /// public sealed class Throws : ITestAsyncMethodWithNullableParameters< FakeObject, FakeObject, FakeObject, FakeObject> { - public static IEnumerable ThrowsArgumentNullExceptionAsyncTestSource = ObjectArrayHelper.GetArgObjectArrayOfArray(4); + /// + /// Gets the Test Data Source for the method. + /// + public static IEnumerable ThrowsArgumentNullExceptionAsyncTestSource => ObjectArrayHelper.GetArgObjectArrayOfArray(4); + /// [Theory] [MemberData(nameof(ThrowsArgumentNullExceptionAsyncTestSource))] public async Task ThrowsArgumentNullExceptionAsync( @@ -30,10 +43,10 @@ public async Task ThrowsArgumentNullExceptionAsync( arg1, arg2, arg3, - arg4, - expectedParameterNameForException)); + arg4)).ConfigureAwait(false); Assert.Equal(expectedParameterNameForException, exception.ParamName); } } +#pragma warning restore CA1034 // Nested types should not be visible } -} \ No newline at end of file +} diff --git a/src/NetTestRegimentation.UnitTests/ITestAsyncMethodWithNullableParametersT5Test.cs b/src/NetTestRegimentation.UnitTests/ITestAsyncMethodWithNullableParametersT5Test.cs index d572cce..5bc6547 100644 --- a/src/NetTestRegimentation.UnitTests/ITestAsyncMethodWithNullableParametersT5Test.cs +++ b/src/NetTestRegimentation.UnitTests/ITestAsyncMethodWithNullableParametersT5Test.cs @@ -1,4 +1,8 @@ -using System; +// Copyright (c) 2019 dpvreony and Contributors. All rights reserved. +// This file is licensed to you under the MIT license. +// See the LICENSE file in the project root for full license information. + +using System; using System.Collections.Generic; using System.Diagnostics.CodeAnalysis; using System.Threading.Tasks; @@ -6,9 +10,14 @@ namespace NetTestRegimentation.UnitTests { + /// + /// Unit Tests for 5 nullable parameters. + /// [ExcludeFromCodeCoverage] public static class ITestAsyncMethodWithNullableParametersT5Test { +#pragma warning disable CA1034 // Nested types should not be visible + /// public sealed class Throws : ITestAsyncMethodWithNullableParameters< FakeObject, FakeObject, @@ -16,8 +25,12 @@ public sealed class Throws : ITestAsyncMethodWithNullableParameters< FakeObject, FakeObject> { - public static IEnumerable ThrowsArgumentNullExceptionAsyncTestSource = ObjectArrayHelper.GetArgObjectArrayOfArray(5); + /// + /// Gets the Test Data Source for the method. + /// + public static IEnumerable ThrowsArgumentNullExceptionAsyncTestSource => ObjectArrayHelper.GetArgObjectArrayOfArray(5); + /// [Theory] [MemberData(nameof(ThrowsArgumentNullExceptionAsyncTestSource))] public async Task ThrowsArgumentNullExceptionAsync( @@ -33,10 +46,10 @@ public async Task ThrowsArgumentNullExceptionAsync( arg2, arg3, arg4, - arg5, - expectedParameterNameForException)); + arg5)).ConfigureAwait(false); Assert.Equal(expectedParameterNameForException, exception.ParamName); } } +#pragma warning restore CA1034 // Nested types should not be visible } -} \ No newline at end of file +} diff --git a/src/NetTestRegimentation.UnitTests/ITestAsyncMethodWithNullableParametersT6Test.cs b/src/NetTestRegimentation.UnitTests/ITestAsyncMethodWithNullableParametersT6Test.cs index b986c94..7b841aa 100644 --- a/src/NetTestRegimentation.UnitTests/ITestAsyncMethodWithNullableParametersT6Test.cs +++ b/src/NetTestRegimentation.UnitTests/ITestAsyncMethodWithNullableParametersT6Test.cs @@ -1,4 +1,8 @@ -using System; +// Copyright (c) 2019 dpvreony and Contributors. All rights reserved. +// This file is licensed to you under the MIT license. +// See the LICENSE file in the project root for full license information. + +using System; using System.Collections.Generic; using System.Diagnostics.CodeAnalysis; using System.Threading.Tasks; @@ -6,9 +10,14 @@ namespace NetTestRegimentation.UnitTests { + /// + /// Unit Tests for 6 nullable parameters. + /// [ExcludeFromCodeCoverage] public static class ITestAsyncMethodWithNullableParametersT6Test { +#pragma warning disable CA1034 // Nested types should not be visible + /// public sealed class Throws : ITestAsyncMethodWithNullableParameters< FakeObject, FakeObject, @@ -17,8 +26,12 @@ public sealed class Throws : ITestAsyncMethodWithNullableParameters< FakeObject, FakeObject> { - public static IEnumerable ThrowsArgumentNullExceptionAsyncTestSource = ObjectArrayHelper.GetArgObjectArrayOfArray(6); + /// + /// Gets the Test Data Source for the method. + /// + public static IEnumerable ThrowsArgumentNullExceptionAsyncTestSource => ObjectArrayHelper.GetArgObjectArrayOfArray(6); + /// [Theory] [MemberData(nameof(ThrowsArgumentNullExceptionAsyncTestSource))] public async Task ThrowsArgumentNullExceptionAsync( @@ -36,10 +49,10 @@ public async Task ThrowsArgumentNullExceptionAsync( arg3, arg4, arg5, - arg6, - expectedParameterNameForException)); + arg6)).ConfigureAwait(false); Assert.Equal(expectedParameterNameForException, exception.ParamName); } } +#pragma warning restore CA1034 // Nested types should not be visible } -} \ No newline at end of file +} diff --git a/src/NetTestRegimentation.UnitTests/ITestAsyncMethodWithNullableParametersT7Test.cs b/src/NetTestRegimentation.UnitTests/ITestAsyncMethodWithNullableParametersT7Test.cs index f82d019..71ef678 100644 --- a/src/NetTestRegimentation.UnitTests/ITestAsyncMethodWithNullableParametersT7Test.cs +++ b/src/NetTestRegimentation.UnitTests/ITestAsyncMethodWithNullableParametersT7Test.cs @@ -1,4 +1,8 @@ -using System; +// Copyright (c) 2019 dpvreony and Contributors. All rights reserved. +// This file is licensed to you under the MIT license. +// See the LICENSE file in the project root for full license information. + +using System; using System.Collections.Generic; using System.Diagnostics.CodeAnalysis; using System.Threading.Tasks; @@ -6,9 +10,14 @@ namespace NetTestRegimentation.UnitTests { + /// + /// Unit Tests for 7 nullable parameters. + /// [ExcludeFromCodeCoverage] public static class ITestAsyncMethodWithNullableParametersT7Test { +#pragma warning disable CA1034 // Nested types should not be visible + /// public sealed class Throws : ITestAsyncMethodWithNullableParameters< FakeObject, FakeObject, @@ -18,8 +27,12 @@ public sealed class Throws : ITestAsyncMethodWithNullableParameters< FakeObject, FakeObject> { - public static IEnumerable ThrowsArgumentNullExceptionAsyncTestSource = ObjectArrayHelper.GetArgObjectArrayOfArray(7); + /// + /// Gets the Test Data Source for the method. + /// + public static IEnumerable ThrowsArgumentNullExceptionAsyncTestSource => ObjectArrayHelper.GetArgObjectArrayOfArray(7); + /// [Theory] [MemberData(nameof(ThrowsArgumentNullExceptionAsyncTestSource))] public async Task ThrowsArgumentNullExceptionAsync( @@ -39,10 +52,10 @@ public async Task ThrowsArgumentNullExceptionAsync( arg4, arg5, arg6, - arg7, - expectedParameterNameForException)); + arg7)).ConfigureAwait(false); Assert.Equal(expectedParameterNameForException, exception.ParamName); } } +#pragma warning restore CA1034 // Nested types should not be visible } -} \ No newline at end of file +} diff --git a/src/NetTestRegimentation.UnitTests/ITestAsyncMethodWithNullableParametersT8Test.cs b/src/NetTestRegimentation.UnitTests/ITestAsyncMethodWithNullableParametersT8Test.cs index 285d2c0..bf52e85 100644 --- a/src/NetTestRegimentation.UnitTests/ITestAsyncMethodWithNullableParametersT8Test.cs +++ b/src/NetTestRegimentation.UnitTests/ITestAsyncMethodWithNullableParametersT8Test.cs @@ -1,4 +1,8 @@ -using System; +// Copyright (c) 2019 dpvreony and Contributors. All rights reserved. +// This file is licensed to you under the MIT license. +// See the LICENSE file in the project root for full license information. + +using System; using System.Collections.Generic; using System.Diagnostics.CodeAnalysis; using System.Threading.Tasks; @@ -6,9 +10,14 @@ namespace NetTestRegimentation.UnitTests { + /// + /// Unit Tests for 8 nullable parameters. + /// [ExcludeFromCodeCoverage] public static class ITestAsyncMethodWithNullableParametersT8Test { +#pragma warning disable CA1034 // Nested types should not be visible + /// public sealed class Throws : ITestAsyncMethodWithNullableParameters< FakeObject, FakeObject, @@ -19,8 +28,12 @@ public sealed class Throws : ITestAsyncMethodWithNullableParameters< FakeObject, FakeObject> { - public static IEnumerable ThrowsArgumentNullExceptionAsyncTestSource = ObjectArrayHelper.GetArgObjectArrayOfArray(8); + /// + /// Gets the Test Data Source for the method. + /// + public static IEnumerable ThrowsArgumentNullExceptionAsyncTestSource => ObjectArrayHelper.GetArgObjectArrayOfArray(8); + /// [Theory] [MemberData(nameof(ThrowsArgumentNullExceptionAsyncTestSource))] public async Task ThrowsArgumentNullExceptionAsync( @@ -42,10 +55,10 @@ public async Task ThrowsArgumentNullExceptionAsync( arg5, arg6, arg7, - arg8, - expectedParameterNameForException)); + arg8)).ConfigureAwait(false); Assert.Equal(expectedParameterNameForException, exception.ParamName); } } +#pragma warning restore CA1034 // Nested types should not be visible } -} \ No newline at end of file +} diff --git a/src/NetTestRegimentation.UnitTests/ITestAsyncMethodWithNullableParametersT9Test.cs b/src/NetTestRegimentation.UnitTests/ITestAsyncMethodWithNullableParametersT9Test.cs index 95ba356..23e0c5e 100644 --- a/src/NetTestRegimentation.UnitTests/ITestAsyncMethodWithNullableParametersT9Test.cs +++ b/src/NetTestRegimentation.UnitTests/ITestAsyncMethodWithNullableParametersT9Test.cs @@ -1,4 +1,8 @@ -using System; +// Copyright (c) 2019 dpvreony and Contributors. All rights reserved. +// This file is licensed to you under the MIT license. +// See the LICENSE file in the project root for full license information. + +using System; using System.Collections.Generic; using System.Diagnostics.CodeAnalysis; using System.Threading.Tasks; @@ -6,9 +10,14 @@ namespace NetTestRegimentation.UnitTests { + /// + /// Unit Tests for 9 nullable parameters. + /// [ExcludeFromCodeCoverage] public static class ITestAsyncMethodWithNullableParametersT9Test { +#pragma warning disable CA1034 // Nested types should not be visible + /// public sealed class Throws : ITestAsyncMethodWithNullableParameters< FakeObject, FakeObject, @@ -20,8 +29,12 @@ public sealed class Throws : ITestAsyncMethodWithNullableParameters< FakeObject, FakeObject> { - public static IEnumerable ThrowsArgumentNullExceptionAsyncTestSource = ObjectArrayHelper.GetArgObjectArrayOfArray(9); + /// + /// Gets the Test Data Source for the method. + /// + public static IEnumerable ThrowsArgumentNullExceptionAsyncTestSource => ObjectArrayHelper.GetArgObjectArrayOfArray(9); + /// [Theory] [MemberData(nameof(ThrowsArgumentNullExceptionAsyncTestSource))] public async Task ThrowsArgumentNullExceptionAsync( @@ -45,10 +58,10 @@ public async Task ThrowsArgumentNullExceptionAsync( arg6, arg7, arg8, - arg9, - expectedParameterNameForException)); + arg9)).ConfigureAwait(false); Assert.Equal(expectedParameterNameForException, exception.ParamName); } } +#pragma warning restore CA1034 // Nested types should not be visible } -} \ No newline at end of file +} diff --git a/src/NetTestRegimentation.UnitTests/Moq/ITestAsyncMethodWithMoqNullableParametersT10Test.cs b/src/NetTestRegimentation.UnitTests/Moq/ITestAsyncMethodWithMoqNullableParametersT10Test.cs index 16dbb6f..55e81ab 100644 --- a/src/NetTestRegimentation.UnitTests/Moq/ITestAsyncMethodWithMoqNullableParametersT10Test.cs +++ b/src/NetTestRegimentation.UnitTests/Moq/ITestAsyncMethodWithMoqNullableParametersT10Test.cs @@ -1,4 +1,8 @@ -using Moq; +// Copyright (c) 2019 dpvreony and Contributors. All rights reserved. +// This file is licensed to you under the MIT license. +// See the LICENSE file in the project root for full license information. + +using Moq; using NetTestRegimentation.Moq; using System; using System.Collections.Generic; @@ -9,9 +13,14 @@ namespace NetTestRegimentation.UnitTests.Moq { + /// + /// Unit Tests for 10 nullable parameters through Moq. + /// [ExcludeFromCodeCoverage] public static class ITestAsyncMethodWithMoqNullableParametersT10Test { +#pragma warning disable CA1034 // Nested types should not be visible + /// public sealed class Throws : ITestAsyncMethodWithMoqNullableParameters< FakeObject, FakeObject, @@ -24,8 +33,12 @@ public sealed class Throws : ITestAsyncMethodWithMoqNullableParameters< FakeObject, FakeObject> { - public static IEnumerable ThrowsArgumentNullExceptionAsyncTestSource = ObjectArrayHelper.GetMoqArgObjectArrayOfArray(10); + /// + /// Gets the Test Data Source for the method. + /// + public static IEnumerable ThrowsArgumentNullExceptionAsyncTestSource => ObjectArrayHelper.GetMoqArgObjectArrayOfArray(10); + /// [Theory] [MemberData(nameof(ThrowsArgumentNullExceptionAsyncTestSource))] public async Task ThrowsArgumentNullExceptionAsync( @@ -51,10 +64,10 @@ public async Task ThrowsArgumentNullExceptionAsync( arg7?.Object, arg8?.Object, arg9?.Object, - arg10?.Object, - expectedParameterNameForException)); + arg10?.Object)).ConfigureAwait(false); Assert.Equal(expectedParameterNameForException, exception.ParamName); } } +#pragma warning restore CA1034 // Nested types should not be visible } -} \ No newline at end of file +} diff --git a/src/NetTestRegimentation.UnitTests/Moq/ITestAsyncMethodWithMoqNullableParametersT11Test.cs b/src/NetTestRegimentation.UnitTests/Moq/ITestAsyncMethodWithMoqNullableParametersT11Test.cs index e8b78c4..a4a9b43 100644 --- a/src/NetTestRegimentation.UnitTests/Moq/ITestAsyncMethodWithMoqNullableParametersT11Test.cs +++ b/src/NetTestRegimentation.UnitTests/Moq/ITestAsyncMethodWithMoqNullableParametersT11Test.cs @@ -1,4 +1,8 @@ -using Moq; +// Copyright (c) 2019 dpvreony and Contributors. All rights reserved. +// This file is licensed to you under the MIT license. +// See the LICENSE file in the project root for full license information. + +using Moq; using NetTestRegimentation.Moq; using System; using System.Collections.Generic; @@ -9,9 +13,14 @@ namespace NetTestRegimentation.UnitTests.Moq { + /// + /// Unit Tests for 11 nullable parameters through Moq. + /// [ExcludeFromCodeCoverage] public static class ITestAsyncMethodWithMoqNullableParametersT11Test { +#pragma warning disable CA1034 // Nested types should not be visible + /// public sealed class Throws : ITestAsyncMethodWithMoqNullableParameters< FakeObject, FakeObject, @@ -25,8 +34,12 @@ public sealed class Throws : ITestAsyncMethodWithMoqNullableParameters< FakeObject, FakeObject> { - public static IEnumerable ThrowsArgumentNullExceptionAsyncTestSource = ObjectArrayHelper.GetMoqArgObjectArrayOfArray(11); + /// + /// Gets the Test Data Source for the method. + /// + public static IEnumerable ThrowsArgumentNullExceptionAsyncTestSource => ObjectArrayHelper.GetMoqArgObjectArrayOfArray(11); + /// [Theory] [MemberData(nameof(ThrowsArgumentNullExceptionAsyncTestSource))] public async Task ThrowsArgumentNullExceptionAsync( @@ -54,10 +67,10 @@ public async Task ThrowsArgumentNullExceptionAsync( arg8?.Object, arg9?.Object, arg10?.Object, - arg11?.Object, - expectedParameterNameForException)); + arg11?.Object)).ConfigureAwait(false); Assert.Equal(expectedParameterNameForException, exception.ParamName); } } +#pragma warning restore CA1034 // Nested types should not be visible } -} \ No newline at end of file +} diff --git a/src/NetTestRegimentation.UnitTests/Moq/ITestAsyncMethodWithMoqNullableParametersT12Test.cs b/src/NetTestRegimentation.UnitTests/Moq/ITestAsyncMethodWithMoqNullableParametersT12Test.cs index bdfa642..21280b9 100644 --- a/src/NetTestRegimentation.UnitTests/Moq/ITestAsyncMethodWithMoqNullableParametersT12Test.cs +++ b/src/NetTestRegimentation.UnitTests/Moq/ITestAsyncMethodWithMoqNullableParametersT12Test.cs @@ -1,4 +1,8 @@ -using Moq; +// Copyright (c) 2019 dpvreony and Contributors. All rights reserved. +// This file is licensed to you under the MIT license. +// See the LICENSE file in the project root for full license information. + +using Moq; using NetTestRegimentation.Moq; using System; using System.Collections.Generic; @@ -9,9 +13,14 @@ namespace NetTestRegimentation.UnitTests.Moq { + /// + /// Unit Tests for 12 nullable parameters through Moq. + /// [ExcludeFromCodeCoverage] public static class ITestAsyncMethodWithMoqNullableParametersT12Test { +#pragma warning disable CA1034 // Nested types should not be visible + /// public sealed class Throws : ITestAsyncMethodWithMoqNullableParameters< FakeObject, FakeObject, @@ -26,8 +35,12 @@ public sealed class Throws : ITestAsyncMethodWithMoqNullableParameters< FakeObject, FakeObject> { - public static IEnumerable ThrowsArgumentNullExceptionAsyncTestSource = ObjectArrayHelper.GetMoqArgObjectArrayOfArray(12); + /// + /// Gets the Test Data Source for the method. + /// + public static IEnumerable ThrowsArgumentNullExceptionAsyncTestSource => ObjectArrayHelper.GetMoqArgObjectArrayOfArray(12); + /// [Theory] [MemberData(nameof(ThrowsArgumentNullExceptionAsyncTestSource))] public async Task ThrowsArgumentNullExceptionAsync( @@ -57,10 +70,10 @@ public async Task ThrowsArgumentNullExceptionAsync( arg9?.Object, arg10?.Object, arg11?.Object, - arg12?.Object, - expectedParameterNameForException)); + arg12?.Object)).ConfigureAwait(false); Assert.Equal(expectedParameterNameForException, exception.ParamName); } } +#pragma warning restore CA1034 // Nested types should not be visible } -} \ No newline at end of file +} diff --git a/src/NetTestRegimentation.UnitTests/Moq/ITestAsyncMethodWithMoqNullableParametersT13Test.cs b/src/NetTestRegimentation.UnitTests/Moq/ITestAsyncMethodWithMoqNullableParametersT13Test.cs index be9b1c4..c416981 100644 --- a/src/NetTestRegimentation.UnitTests/Moq/ITestAsyncMethodWithMoqNullableParametersT13Test.cs +++ b/src/NetTestRegimentation.UnitTests/Moq/ITestAsyncMethodWithMoqNullableParametersT13Test.cs @@ -1,4 +1,8 @@ -using Moq; +// Copyright (c) 2019 dpvreony and Contributors. All rights reserved. +// This file is licensed to you under the MIT license. +// See the LICENSE file in the project root for full license information. + +using Moq; using NetTestRegimentation.Moq; using System; using System.Collections.Generic; @@ -9,9 +13,14 @@ namespace NetTestRegimentation.UnitTests.Moq { + /// + /// Unit Tests for 13 nullable parameters through Moq. + /// [ExcludeFromCodeCoverage] public static class ITestAsyncMethodWithMoqNullableParametersT13Test { +#pragma warning disable CA1034 // Nested types should not be visible + /// public sealed class Throws : ITestAsyncMethodWithMoqNullableParameters< FakeObject, FakeObject, @@ -27,8 +36,12 @@ public sealed class Throws : ITestAsyncMethodWithMoqNullableParameters< FakeObject, FakeObject> { - public static IEnumerable ThrowsArgumentNullExceptionAsyncTestSource = ObjectArrayHelper.GetMoqArgObjectArrayOfArray(13); + /// + /// Gets the Test Data Source for the method. + /// + public static IEnumerable ThrowsArgumentNullExceptionAsyncTestSource => ObjectArrayHelper.GetMoqArgObjectArrayOfArray(13); + /// [Theory] [MemberData(nameof(ThrowsArgumentNullExceptionAsyncTestSource))] public async Task ThrowsArgumentNullExceptionAsync( @@ -60,10 +73,10 @@ public async Task ThrowsArgumentNullExceptionAsync( arg10?.Object, arg11?.Object, arg12?.Object, - arg13?.Object, - expectedParameterNameForException)); + arg13?.Object)).ConfigureAwait(false); Assert.Equal(expectedParameterNameForException, exception.ParamName); } } +#pragma warning restore CA1034 // Nested types should not be visible } -} \ No newline at end of file +} diff --git a/src/NetTestRegimentation.UnitTests/Moq/ITestAsyncMethodWithMoqNullableParametersT14Test.cs b/src/NetTestRegimentation.UnitTests/Moq/ITestAsyncMethodWithMoqNullableParametersT14Test.cs index 9c77669..5ea2b6c 100644 --- a/src/NetTestRegimentation.UnitTests/Moq/ITestAsyncMethodWithMoqNullableParametersT14Test.cs +++ b/src/NetTestRegimentation.UnitTests/Moq/ITestAsyncMethodWithMoqNullableParametersT14Test.cs @@ -1,4 +1,8 @@ -using Moq; +// Copyright (c) 2019 dpvreony and Contributors. All rights reserved. +// This file is licensed to you under the MIT license. +// See the LICENSE file in the project root for full license information. + +using Moq; using NetTestRegimentation.Moq; using System; using System.Collections.Generic; @@ -9,9 +13,14 @@ namespace NetTestRegimentation.UnitTests.Moq { + /// + /// Unit Tests for 14 nullable parameters through Moq. + /// [ExcludeFromCodeCoverage] public static class ITestAsyncMethodWithMoqNullableParametersT14Test { +#pragma warning disable CA1034 // Nested types should not be visible + /// public sealed class Throws : ITestAsyncMethodWithMoqNullableParameters< FakeObject, FakeObject, @@ -28,8 +37,12 @@ public sealed class Throws : ITestAsyncMethodWithMoqNullableParameters< FakeObject, FakeObject> { - public static IEnumerable ThrowsArgumentNullExceptionAsyncTestSource = ObjectArrayHelper.GetMoqArgObjectArrayOfArray(14); + /// + /// Gets the Test Data Source for the method. + /// + public static IEnumerable ThrowsArgumentNullExceptionAsyncTestSource => ObjectArrayHelper.GetMoqArgObjectArrayOfArray(14); + /// [Theory] [MemberData(nameof(ThrowsArgumentNullExceptionAsyncTestSource))] public async Task ThrowsArgumentNullExceptionAsync( @@ -63,10 +76,10 @@ public async Task ThrowsArgumentNullExceptionAsync( arg11?.Object, arg12?.Object, arg13?.Object, - arg14?.Object, - expectedParameterNameForException)); + arg14?.Object)).ConfigureAwait(false); Assert.Equal(expectedParameterNameForException, exception.ParamName); } } +#pragma warning restore CA1034 // Nested types should not be visible } -} \ No newline at end of file +} diff --git a/src/NetTestRegimentation.UnitTests/Moq/ITestAsyncMethodWithMoqNullableParametersT15Test.cs b/src/NetTestRegimentation.UnitTests/Moq/ITestAsyncMethodWithMoqNullableParametersT15Test.cs index a329d67..07e0c8a 100644 --- a/src/NetTestRegimentation.UnitTests/Moq/ITestAsyncMethodWithMoqNullableParametersT15Test.cs +++ b/src/NetTestRegimentation.UnitTests/Moq/ITestAsyncMethodWithMoqNullableParametersT15Test.cs @@ -1,4 +1,8 @@ -using Moq; +// Copyright (c) 2019 dpvreony and Contributors. All rights reserved. +// This file is licensed to you under the MIT license. +// See the LICENSE file in the project root for full license information. + +using Moq; using NetTestRegimentation.Moq; using System; using System.Collections.Generic; @@ -9,9 +13,14 @@ namespace NetTestRegimentation.UnitTests.Moq { + /// + /// Unit Tests for 15 nullable parameters through Moq. + /// [ExcludeFromCodeCoverage] public static class ITestAsyncMethodWithMoqNullableParametersT15Test { +#pragma warning disable CA1034 // Nested types should not be visible + /// public sealed class Throws : ITestAsyncMethodWithMoqNullableParameters< FakeObject, FakeObject, @@ -29,8 +38,12 @@ public sealed class Throws : ITestAsyncMethodWithMoqNullableParameters< FakeObject, FakeObject> { - public static IEnumerable ThrowsArgumentNullExceptionAsyncTestSource = ObjectArrayHelper.GetMoqArgObjectArrayOfArray(15); + /// + /// Gets the Test Data Source for the method. + /// + public static IEnumerable ThrowsArgumentNullExceptionAsyncTestSource => ObjectArrayHelper.GetMoqArgObjectArrayOfArray(15); + /// [Theory] [MemberData(nameof(ThrowsArgumentNullExceptionAsyncTestSource))] public async Task ThrowsArgumentNullExceptionAsync( @@ -66,10 +79,10 @@ public async Task ThrowsArgumentNullExceptionAsync( arg12?.Object, arg13?.Object, arg14?.Object, - arg15?.Object, - expectedParameterNameForException)); + arg15?.Object)).ConfigureAwait(false); Assert.Equal(expectedParameterNameForException, exception.ParamName); } } +#pragma warning restore CA1034 // Nested types should not be visible } -} \ No newline at end of file +} diff --git a/src/NetTestRegimentation.UnitTests/Moq/ITestAsyncMethodWithMoqNullableParametersT16Test.cs b/src/NetTestRegimentation.UnitTests/Moq/ITestAsyncMethodWithMoqNullableParametersT16Test.cs index f7f16c5..b4a315d 100644 --- a/src/NetTestRegimentation.UnitTests/Moq/ITestAsyncMethodWithMoqNullableParametersT16Test.cs +++ b/src/NetTestRegimentation.UnitTests/Moq/ITestAsyncMethodWithMoqNullableParametersT16Test.cs @@ -1,4 +1,8 @@ -using Moq; +// Copyright (c) 2019 dpvreony and Contributors. All rights reserved. +// This file is licensed to you under the MIT license. +// See the LICENSE file in the project root for full license information. + +using Moq; using NetTestRegimentation.Moq; using System; using System.Collections.Generic; @@ -9,9 +13,14 @@ namespace NetTestRegimentation.UnitTests.Moq { + /// + /// Unit Tests for 16 nullable parameters through Moq. + /// [ExcludeFromCodeCoverage] public static class ITestAsyncMethodWithMoqNullableParametersT16Test { +#pragma warning disable CA1034 // Nested types should not be visible + /// public sealed class Throws : ITestAsyncMethodWithMoqNullableParameters< FakeObject, FakeObject, @@ -30,8 +39,12 @@ public sealed class Throws : ITestAsyncMethodWithMoqNullableParameters< FakeObject, FakeObject> { - public static IEnumerable ThrowsArgumentNullExceptionAsyncTestSource = ObjectArrayHelper.GetMoqArgObjectArrayOfArray(16); + /// + /// Gets the Test Data Source for the method. + /// + public static IEnumerable ThrowsArgumentNullExceptionAsyncTestSource => ObjectArrayHelper.GetMoqArgObjectArrayOfArray(16); + /// [Theory] [MemberData(nameof(ThrowsArgumentNullExceptionAsyncTestSource))] public async Task ThrowsArgumentNullExceptionAsync( @@ -69,10 +82,10 @@ public async Task ThrowsArgumentNullExceptionAsync( arg13?.Object, arg14?.Object, arg15?.Object, - arg16?.Object, - expectedParameterNameForException)); + arg16?.Object)).ConfigureAwait(false); Assert.Equal(expectedParameterNameForException, exception.ParamName); } } +#pragma warning restore CA1034 // Nested types should not be visible } -} \ No newline at end of file +} diff --git a/src/NetTestRegimentation.UnitTests/Moq/ITestAsyncMethodWithMoqNullableParametersT1Test.cs b/src/NetTestRegimentation.UnitTests/Moq/ITestAsyncMethodWithMoqNullableParametersT1Test.cs index 16bb429..673d95b 100644 --- a/src/NetTestRegimentation.UnitTests/Moq/ITestAsyncMethodWithMoqNullableParametersT1Test.cs +++ b/src/NetTestRegimentation.UnitTests/Moq/ITestAsyncMethodWithMoqNullableParametersT1Test.cs @@ -1,4 +1,8 @@ -using Moq; +// Copyright (c) 2019 dpvreony and Contributors. All rights reserved. +// This file is licensed to you under the MIT license. +// See the LICENSE file in the project root for full license information. + +using Moq; using NetTestRegimentation.Moq; using System; using System.Collections.Generic; @@ -9,22 +13,32 @@ namespace NetTestRegimentation.UnitTests.Moq { + /// + /// Unit Tests for 1 nullable parameter through Moq. + /// [ExcludeFromCodeCoverage] public static class ITestAsyncMethodWithMoqNullableParametersT1Test { +#pragma warning disable CA1034 // Nested types should not be visible + /// public sealed class Throws : ITestAsyncMethodWithMoqNullableParameters { - public static IEnumerable ThrowsArgumentNullExceptionAsyncTestSource = ObjectArrayHelper.GetMoqArgObjectArrayOfArray(1); + /// + /// Gets the Test Data Source for the method. + /// + public static IEnumerable ThrowsArgumentNullExceptionAsyncTestSource => ObjectArrayHelper.GetMoqArgObjectArrayOfArray(1); + /// [Theory] [MemberData(nameof(ThrowsArgumentNullExceptionAsyncTestSource))] public async Task ThrowsArgumentNullExceptionAsync( Mock arg, string expectedParameterNameForException) { - var exception = await Assert.ThrowsAsync(() => ArgumentHelpers.ThrowIfNullAsync(arg?.Object, expectedParameterNameForException)); + var exception = await Assert.ThrowsAsync(() => ArgumentHelpers.ThrowIfNullAsync(arg?.Object)).ConfigureAwait(false); Assert.Equal(expectedParameterNameForException, exception.ParamName); } } } +#pragma warning restore CA1034 // Nested types should not be visible } diff --git a/src/NetTestRegimentation.UnitTests/Moq/ITestAsyncMethodWithMoqNullableParametersT2Test.cs b/src/NetTestRegimentation.UnitTests/Moq/ITestAsyncMethodWithMoqNullableParametersT2Test.cs index eddd9a5..0714fe3 100644 --- a/src/NetTestRegimentation.UnitTests/Moq/ITestAsyncMethodWithMoqNullableParametersT2Test.cs +++ b/src/NetTestRegimentation.UnitTests/Moq/ITestAsyncMethodWithMoqNullableParametersT2Test.cs @@ -1,4 +1,8 @@ -using Moq; +// Copyright (c) 2019 dpvreony and Contributors. All rights reserved. +// This file is licensed to you under the MIT license. +// See the LICENSE file in the project root for full license information. + +using Moq; using NetTestRegimentation.Moq; using System; using System.Collections.Generic; @@ -9,15 +13,24 @@ namespace NetTestRegimentation.UnitTests.Moq { + /// + /// Unit Tests for 2 nullable parameters through Moq. + /// [ExcludeFromCodeCoverage] public static class ITestAsyncMethodWithMoqNullableParametersT2Test { +#pragma warning disable CA1034 // Nested types should not be visible + /// public sealed class Throws : ITestAsyncMethodWithMoqNullableParameters< FakeObject, FakeObject> { - public static IEnumerable ThrowsArgumentNullExceptionAsyncTestSource = ObjectArrayHelper.GetMoqArgObjectArrayOfArray(2); + /// + /// Gets the Test Data Source for the method. + /// + public static IEnumerable ThrowsArgumentNullExceptionAsyncTestSource => ObjectArrayHelper.GetMoqArgObjectArrayOfArray(2); + /// [Theory] [MemberData(nameof(ThrowsArgumentNullExceptionAsyncTestSource))] public async Task ThrowsArgumentNullExceptionAsync( @@ -27,10 +40,10 @@ public async Task ThrowsArgumentNullExceptionAsync( { var exception = await Assert.ThrowsAsync(() => ArgumentHelpers.ThrowIfNullAsync( arg1?.Object, - arg2?.Object, - expectedParameterNameForException)); + arg2?.Object)).ConfigureAwait(false); Assert.Equal(expectedParameterNameForException, exception.ParamName); } } +#pragma warning restore CA1034 // Nested types should not be visible } } diff --git a/src/NetTestRegimentation.UnitTests/Moq/ITestAsyncMethodWithMoqNullableParametersT3Test.cs b/src/NetTestRegimentation.UnitTests/Moq/ITestAsyncMethodWithMoqNullableParametersT3Test.cs index b23b31a..d94196e 100644 --- a/src/NetTestRegimentation.UnitTests/Moq/ITestAsyncMethodWithMoqNullableParametersT3Test.cs +++ b/src/NetTestRegimentation.UnitTests/Moq/ITestAsyncMethodWithMoqNullableParametersT3Test.cs @@ -1,4 +1,8 @@ -using Moq; +// Copyright (c) 2019 dpvreony and Contributors. All rights reserved. +// This file is licensed to you under the MIT license. +// See the LICENSE file in the project root for full license information. + +using Moq; using NetTestRegimentation.Moq; using System; using System.Collections.Generic; @@ -9,16 +13,25 @@ namespace NetTestRegimentation.UnitTests.Moq { + /// + /// Unit Tests for 3 nullable parameters through Moq. + /// [ExcludeFromCodeCoverage] public static class ITestAsyncMethodWithMoqNullableParametersT3Test { +#pragma warning disable CA1034 // Nested types should not be visible + /// public sealed class Throws : ITestAsyncMethodWithMoqNullableParameters< FakeObject, FakeObject, FakeObject> { - public static IEnumerable ThrowsArgumentNullExceptionAsyncTestSource = ObjectArrayHelper.GetMoqArgObjectArrayOfArray(3); + /// + /// Gets the Test Data Source for the method. + /// + public static IEnumerable ThrowsArgumentNullExceptionAsyncTestSource => ObjectArrayHelper.GetMoqArgObjectArrayOfArray(3); + /// [Theory] [MemberData(nameof(ThrowsArgumentNullExceptionAsyncTestSource))] public async Task ThrowsArgumentNullExceptionAsync( @@ -30,10 +43,10 @@ public async Task ThrowsArgumentNullExceptionAsync( var exception = await Assert.ThrowsAsync(() => ArgumentHelpers.ThrowIfNullAsync( arg1?.Object, arg2?.Object, - arg3?.Object, - expectedParameterNameForException)); + arg3?.Object)).ConfigureAwait(false); Assert.Equal(expectedParameterNameForException, exception.ParamName); } } +#pragma warning restore CA1034 // Nested types should not be visible } -} \ No newline at end of file +} diff --git a/src/NetTestRegimentation.UnitTests/Moq/ITestAsyncMethodWithMoqNullableParametersT4Test.cs b/src/NetTestRegimentation.UnitTests/Moq/ITestAsyncMethodWithMoqNullableParametersT4Test.cs index 215905b..a6d3279 100644 --- a/src/NetTestRegimentation.UnitTests/Moq/ITestAsyncMethodWithMoqNullableParametersT4Test.cs +++ b/src/NetTestRegimentation.UnitTests/Moq/ITestAsyncMethodWithMoqNullableParametersT4Test.cs @@ -1,4 +1,8 @@ -using Moq; +// Copyright (c) 2019 dpvreony and Contributors. All rights reserved. +// This file is licensed to you under the MIT license. +// See the LICENSE file in the project root for full license information. + +using Moq; using NetTestRegimentation.Moq; using System; using System.Collections.Generic; @@ -9,17 +13,26 @@ namespace NetTestRegimentation.UnitTests.Moq { + /// + /// Unit Tests for 4 nullable parameters through Moq. + /// [ExcludeFromCodeCoverage] public static class ITestAsyncMethodWithMoqNullableParametersT4Test { +#pragma warning disable CA1034 // Nested types should not be visible + /// public sealed class Throws : ITestAsyncMethodWithMoqNullableParameters< FakeObject, FakeObject, FakeObject, FakeObject> { - public static IEnumerable ThrowsArgumentNullExceptionAsyncTestSource = ObjectArrayHelper.GetMoqArgObjectArrayOfArray(4); + /// + /// Gets the Test Data Source for the method. + /// + public static IEnumerable ThrowsArgumentNullExceptionAsyncTestSource => ObjectArrayHelper.GetMoqArgObjectArrayOfArray(4); + /// [Theory] [MemberData(nameof(ThrowsArgumentNullExceptionAsyncTestSource))] public async Task ThrowsArgumentNullExceptionAsync( @@ -33,10 +46,10 @@ public async Task ThrowsArgumentNullExceptionAsync( arg1?.Object, arg2?.Object, arg3?.Object, - arg4?.Object, - expectedParameterNameForException)); + arg4?.Object)).ConfigureAwait(false); Assert.Equal(expectedParameterNameForException, exception.ParamName); } } +#pragma warning restore CA1034 // Nested types should not be visible } -} \ No newline at end of file +} diff --git a/src/NetTestRegimentation.UnitTests/Moq/ITestAsyncMethodWithMoqNullableParametersT5Test.cs b/src/NetTestRegimentation.UnitTests/Moq/ITestAsyncMethodWithMoqNullableParametersT5Test.cs index 91fafb6..7f8cbce 100644 --- a/src/NetTestRegimentation.UnitTests/Moq/ITestAsyncMethodWithMoqNullableParametersT5Test.cs +++ b/src/NetTestRegimentation.UnitTests/Moq/ITestAsyncMethodWithMoqNullableParametersT5Test.cs @@ -1,4 +1,8 @@ -using Moq; +// Copyright (c) 2019 dpvreony and Contributors. All rights reserved. +// This file is licensed to you under the MIT license. +// See the LICENSE file in the project root for full license information. + +using Moq; using NetTestRegimentation.Moq; using System; using System.Collections.Generic; @@ -9,9 +13,14 @@ namespace NetTestRegimentation.UnitTests.Moq { + /// + /// Unit Tests for 5 nullable parameters through Moq. + /// [ExcludeFromCodeCoverage] public static class ITestAsyncMethodWithMoqNullableParametersT5Test { +#pragma warning disable CA1034 // Nested types should not be visible + /// public sealed class Throws : ITestAsyncMethodWithMoqNullableParameters< FakeObject, FakeObject, @@ -19,8 +28,12 @@ public sealed class Throws : ITestAsyncMethodWithMoqNullableParameters< FakeObject, FakeObject> { - public static IEnumerable ThrowsArgumentNullExceptionAsyncTestSource = ObjectArrayHelper.GetMoqArgObjectArrayOfArray(5); + /// + /// Gets the Test Data Source for the method. + /// + public static IEnumerable ThrowsArgumentNullExceptionAsyncTestSource => ObjectArrayHelper.GetMoqArgObjectArrayOfArray(5); + /// [Theory] [MemberData(nameof(ThrowsArgumentNullExceptionAsyncTestSource))] public async Task ThrowsArgumentNullExceptionAsync( @@ -36,10 +49,10 @@ public async Task ThrowsArgumentNullExceptionAsync( arg2?.Object, arg3?.Object, arg4?.Object, - arg5?.Object, - expectedParameterNameForException)); + arg5?.Object)).ConfigureAwait(false); Assert.Equal(expectedParameterNameForException, exception.ParamName); } } +#pragma warning restore CA1034 // Nested types should not be visible } -} \ No newline at end of file +} diff --git a/src/NetTestRegimentation.UnitTests/Moq/ITestAsyncMethodWithMoqNullableParametersT6Test.cs b/src/NetTestRegimentation.UnitTests/Moq/ITestAsyncMethodWithMoqNullableParametersT6Test.cs index da52401..70b9634 100644 --- a/src/NetTestRegimentation.UnitTests/Moq/ITestAsyncMethodWithMoqNullableParametersT6Test.cs +++ b/src/NetTestRegimentation.UnitTests/Moq/ITestAsyncMethodWithMoqNullableParametersT6Test.cs @@ -1,4 +1,8 @@ -using Moq; +// Copyright (c) 2019 dpvreony and Contributors. All rights reserved. +// This file is licensed to you under the MIT license. +// See the LICENSE file in the project root for full license information. + +using Moq; using NetTestRegimentation.Moq; using System; using System.Collections.Generic; @@ -9,9 +13,14 @@ namespace NetTestRegimentation.UnitTests.Moq { + /// + /// Unit Tests for 6 nullable parameters through Moq. + /// [ExcludeFromCodeCoverage] public static class ITestAsyncMethodWithMoqNullableParametersT6Test { +#pragma warning disable CA1034 // Nested types should not be visible + /// public sealed class Throws : ITestAsyncMethodWithMoqNullableParameters< FakeObject, FakeObject, @@ -20,8 +29,12 @@ public sealed class Throws : ITestAsyncMethodWithMoqNullableParameters< FakeObject, FakeObject> { - public static IEnumerable ThrowsArgumentNullExceptionAsyncTestSource = ObjectArrayHelper.GetMoqArgObjectArrayOfArray(6); + /// + /// Gets the Test Data Source for the method. + /// + public static IEnumerable ThrowsArgumentNullExceptionAsyncTestSource => ObjectArrayHelper.GetMoqArgObjectArrayOfArray(6); + /// [Theory] [MemberData(nameof(ThrowsArgumentNullExceptionAsyncTestSource))] public async Task ThrowsArgumentNullExceptionAsync( @@ -39,10 +52,10 @@ public async Task ThrowsArgumentNullExceptionAsync( arg3?.Object, arg4?.Object, arg5?.Object, - arg6?.Object, - expectedParameterNameForException)); + arg6?.Object)).ConfigureAwait(false); Assert.Equal(expectedParameterNameForException, exception.ParamName); } } +#pragma warning restore CA1034 // Nested types should not be visible } -} \ No newline at end of file +} diff --git a/src/NetTestRegimentation.UnitTests/Moq/ITestAsyncMethodWithMoqNullableParametersT7Test.cs b/src/NetTestRegimentation.UnitTests/Moq/ITestAsyncMethodWithMoqNullableParametersT7Test.cs index 30bcfbd..5e74517 100644 --- a/src/NetTestRegimentation.UnitTests/Moq/ITestAsyncMethodWithMoqNullableParametersT7Test.cs +++ b/src/NetTestRegimentation.UnitTests/Moq/ITestAsyncMethodWithMoqNullableParametersT7Test.cs @@ -1,4 +1,8 @@ -using Moq; +// Copyright (c) 2019 dpvreony and Contributors. All rights reserved. +// This file is licensed to you under the MIT license. +// See the LICENSE file in the project root for full license information. + +using Moq; using NetTestRegimentation.Moq; using System; using System.Collections.Generic; @@ -9,9 +13,14 @@ namespace NetTestRegimentation.UnitTests.Moq { + /// + /// Unit Tests for 7 nullable parameters through Moq. + /// [ExcludeFromCodeCoverage] public static class ITestAsyncMethodWithMoqNullableParametersT7Test { +#pragma warning disable CA1034 // Nested types should not be visible + /// public sealed class Throws : ITestAsyncMethodWithMoqNullableParameters< FakeObject, FakeObject, @@ -21,8 +30,12 @@ public sealed class Throws : ITestAsyncMethodWithMoqNullableParameters< FakeObject, FakeObject> { - public static IEnumerable ThrowsArgumentNullExceptionAsyncTestSource = ObjectArrayHelper.GetMoqArgObjectArrayOfArray(7); + /// + /// Gets the Test Data Source for the method. + /// + public static IEnumerable ThrowsArgumentNullExceptionAsyncTestSource => ObjectArrayHelper.GetMoqArgObjectArrayOfArray(7); + /// [Theory] [MemberData(nameof(ThrowsArgumentNullExceptionAsyncTestSource))] public async Task ThrowsArgumentNullExceptionAsync( @@ -42,10 +55,10 @@ public async Task ThrowsArgumentNullExceptionAsync( arg4?.Object, arg5?.Object, arg6?.Object, - arg7?.Object, - expectedParameterNameForException)); + arg7?.Object)).ConfigureAwait(false); Assert.Equal(expectedParameterNameForException, exception.ParamName); } } +#pragma warning restore CA1034 // Nested types should not be visible } -} \ No newline at end of file +} diff --git a/src/NetTestRegimentation.UnitTests/Moq/ITestAsyncMethodWithMoqNullableParametersT8Test.cs b/src/NetTestRegimentation.UnitTests/Moq/ITestAsyncMethodWithMoqNullableParametersT8Test.cs index 0d2ccd4..eee8941 100644 --- a/src/NetTestRegimentation.UnitTests/Moq/ITestAsyncMethodWithMoqNullableParametersT8Test.cs +++ b/src/NetTestRegimentation.UnitTests/Moq/ITestAsyncMethodWithMoqNullableParametersT8Test.cs @@ -1,4 +1,8 @@ -using Moq; +// Copyright (c) 2019 dpvreony and Contributors. All rights reserved. +// This file is licensed to you under the MIT license. +// See the LICENSE file in the project root for full license information. + +using Moq; using NetTestRegimentation.Moq; using System; using System.Collections.Generic; @@ -9,9 +13,14 @@ namespace NetTestRegimentation.UnitTests.Moq { + /// + /// Unit Tests for 8 nullable parameters through Moq. + /// [ExcludeFromCodeCoverage] public static class ITestAsyncMethodWithMoqNullableParametersT8Test { +#pragma warning disable CA1034 // Nested types should not be visible + /// public sealed class Throws : ITestAsyncMethodWithMoqNullableParameters< FakeObject, FakeObject, @@ -22,8 +31,12 @@ public sealed class Throws : ITestAsyncMethodWithMoqNullableParameters< FakeObject, FakeObject> { - public static IEnumerable ThrowsArgumentNullExceptionAsyncTestSource = ObjectArrayHelper.GetMoqArgObjectArrayOfArray(8); + /// + /// Gets the Test Data Source for the method. + /// + public static IEnumerable ThrowsArgumentNullExceptionAsyncTestSource => ObjectArrayHelper.GetMoqArgObjectArrayOfArray(8); + /// [Theory] [MemberData(nameof(ThrowsArgumentNullExceptionAsyncTestSource))] public async Task ThrowsArgumentNullExceptionAsync( @@ -45,10 +58,10 @@ public async Task ThrowsArgumentNullExceptionAsync( arg5?.Object, arg6?.Object, arg7?.Object, - arg8?.Object, - expectedParameterNameForException)); + arg8?.Object)).ConfigureAwait(false); Assert.Equal(expectedParameterNameForException, exception.ParamName); } } +#pragma warning restore CA1034 // Nested types should not be visible } -} \ No newline at end of file +} diff --git a/src/NetTestRegimentation.UnitTests/Moq/ITestAsyncMethodWithMoqNullableParametersT9Test.cs b/src/NetTestRegimentation.UnitTests/Moq/ITestAsyncMethodWithMoqNullableParametersT9Test.cs index 1fa0a14..cadcdf5 100644 --- a/src/NetTestRegimentation.UnitTests/Moq/ITestAsyncMethodWithMoqNullableParametersT9Test.cs +++ b/src/NetTestRegimentation.UnitTests/Moq/ITestAsyncMethodWithMoqNullableParametersT9Test.cs @@ -1,4 +1,8 @@ -using Moq; +// Copyright (c) 2019 dpvreony and Contributors. All rights reserved. +// This file is licensed to you under the MIT license. +// See the LICENSE file in the project root for full license information. + +using Moq; using NetTestRegimentation.Moq; using System; using System.Collections.Generic; @@ -9,9 +13,14 @@ namespace NetTestRegimentation.UnitTests.Moq { + /// + /// Unit Tests for 9 nullable parameters through Moq. + /// [ExcludeFromCodeCoverage] public static class ITestAsyncMethodWithMoqNullableParametersT9Test { +#pragma warning disable CA1034 // Nested types should not be visible + /// public sealed class Throws : ITestAsyncMethodWithMoqNullableParameters< FakeObject, FakeObject, @@ -23,8 +32,12 @@ public sealed class Throws : ITestAsyncMethodWithMoqNullableParameters< FakeObject, FakeObject> { - public static IEnumerable ThrowsArgumentNullExceptionAsyncTestSource = ObjectArrayHelper.GetMoqArgObjectArrayOfArray(9); + /// + /// Gets the Test Data Source for the method. + /// + public static IEnumerable ThrowsArgumentNullExceptionAsyncTestSource => ObjectArrayHelper.GetMoqArgObjectArrayOfArray(9); + /// [Theory] [MemberData(nameof(ThrowsArgumentNullExceptionAsyncTestSource))] public async Task ThrowsArgumentNullExceptionAsync( @@ -48,10 +61,10 @@ public async Task ThrowsArgumentNullExceptionAsync( arg6?.Object, arg7?.Object, arg8?.Object, - arg9?.Object, - expectedParameterNameForException)); + arg9?.Object)).ConfigureAwait(false); Assert.Equal(expectedParameterNameForException, exception.ParamName); } } +#pragma warning restore CA1034 // Nested types should not be visible } -} \ No newline at end of file +} diff --git a/src/NetTestRegimentation.UnitTests/ObjectArrayHelper.cs b/src/NetTestRegimentation.UnitTests/ObjectArrayHelper.cs index d58fe75..3bd31c8 100644 --- a/src/NetTestRegimentation.UnitTests/ObjectArrayHelper.cs +++ b/src/NetTestRegimentation.UnitTests/ObjectArrayHelper.cs @@ -1,12 +1,25 @@ -using System; +// Copyright (c) 2019 dpvreony and Contributors. All rights reserved. +// This file is licensed to you under the MIT license. +// See the LICENSE file in the project root for full license information. + +using System; using System.Collections.Generic; +using System.Globalization; using System.Text; using Moq; namespace NetTestRegimentation.UnitTests { + /// + /// Helpers for producing testable object arrays for unit testing. + /// public static class ObjectArrayHelper { + /// + /// Gets an array of test objects for unit test member data sources. + /// + /// Size of the array. + /// 2 dimension array. 1st dimension is test scenario, 2nd is the arguments the method takes. public static object[][] GetArgObjectArrayOfArray(int size) { var result = new List(size); @@ -18,6 +31,12 @@ public static object[][] GetArgObjectArrayOfArray(int size) return result.ToArray(); } + /// + /// Gets an array of test objects for unit test member data sources. + /// + /// Size of the array. + /// 1 based index of the argument to leave null. + /// array. this is for the number of arguments the method takes. public static object[] GetArgObjectArray( int size, int argumentToLeaveNull) @@ -28,11 +47,16 @@ public static object[] GetArgObjectArray( result.Add((i == argumentToLeaveNull) ? null : new FakeObject()); } - result.Add($"arg{argumentToLeaveNull}"); + result.Add($"arg{(size > 1 ? argumentToLeaveNull.ToString(NumberFormatInfo.InvariantInfo) : string.Empty)}"); return result.ToArray(); } + /// + /// Gets an array of test objects for unit test member data sources utilising Moq. + /// + /// Size of the array. + /// 2 dimension array. 1st dimension is test scenario, 2nd is the arguments the method takes. public static object[][] GetMoqArgObjectArrayOfArray(int size) { var result = new List(size); @@ -44,6 +68,12 @@ public static object[][] GetMoqArgObjectArrayOfArray(int size) return result.ToArray(); } + /// + /// Gets an array of test moq objects for unit test member data sources. + /// + /// Size of the array. + /// 1 based index of the argument to leave null. + /// array. this is for the number of arguments the method takes. public static object[] GetMoqArgObjectArray( int size, int argumentToLeaveNull) @@ -54,7 +84,7 @@ public static object[] GetMoqArgObjectArray( result.Add((i == argumentToLeaveNull) ? null : new Mock()); } - result.Add($"arg{argumentToLeaveNull}"); + result.Add($"arg{(size > 1 ? argumentToLeaveNull.ToString(NumberFormatInfo.InvariantInfo) : string.Empty)}"); return result.ToArray(); } diff --git a/src/NetTestRegimentation.XUnit/NetTestRegimentation.XUnit.csproj b/src/NetTestRegimentation.XUnit/NetTestRegimentation.XUnit.csproj new file mode 100644 index 0000000..ea83d29 --- /dev/null +++ b/src/NetTestRegimentation.XUnit/NetTestRegimentation.XUnit.csproj @@ -0,0 +1,7 @@ + + + + netcoreapp3.0 + + + diff --git a/src/NetTestRegimentation.sln b/src/NetTestRegimentation.sln index 4c99d03..d405649 100644 --- a/src/NetTestRegimentation.sln +++ b/src/NetTestRegimentation.sln @@ -1,13 +1,15 @@  Microsoft Visual Studio Solution File, Format Version 12.00 -# Visual Studio 15 -VisualStudioVersion = 15.0.28307.421 +# Visual Studio Version 16 +VisualStudioVersion = 16.0.29519.87 MinimumVisualStudioVersion = 10.0.40219.1 Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "NetTestRegimentation", "NetTestRegimentation\NetTestRegimentation.csproj", "{F1E91E4A-554C-42DC-8570-0349C1A56C18}" EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "NetTestRegimentation.UnitTests", "NetTestRegimentation.UnitTests\NetTestRegimentation.UnitTests.csproj", "{98BE3C86-7D46-4735-B89C-D60C98D88479}" EndProject -Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "NetTestRegimentation.Moq", "NetTestRegimentation.Moq\NetTestRegimentation.Moq.csproj", "{CC4B853A-469F-4A7E-ACD5-881CE2CEBC6A}" +Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "NetTestRegimentation.Moq", "NetTestRegimentation.Moq\NetTestRegimentation.Moq.csproj", "{CC4B853A-469F-4A7E-ACD5-881CE2CEBC6A}" +EndProject +Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "NetTestRegimentation.XUnit", "NetTestRegimentation.XUnit\NetTestRegimentation.XUnit.csproj", "{9D090858-E187-4E99-B201-97166988C144}" EndProject Global GlobalSection(SolutionConfigurationPlatforms) = preSolution @@ -27,6 +29,10 @@ Global {CC4B853A-469F-4A7E-ACD5-881CE2CEBC6A}.Debug|Any CPU.Build.0 = Debug|Any CPU {CC4B853A-469F-4A7E-ACD5-881CE2CEBC6A}.Release|Any CPU.ActiveCfg = Release|Any CPU {CC4B853A-469F-4A7E-ACD5-881CE2CEBC6A}.Release|Any CPU.Build.0 = Release|Any CPU + {9D090858-E187-4E99-B201-97166988C144}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {9D090858-E187-4E99-B201-97166988C144}.Debug|Any CPU.Build.0 = Debug|Any CPU + {9D090858-E187-4E99-B201-97166988C144}.Release|Any CPU.ActiveCfg = Release|Any CPU + {9D090858-E187-4E99-B201-97166988C144}.Release|Any CPU.Build.0 = Release|Any CPU EndGlobalSection GlobalSection(SolutionProperties) = preSolution HideSolutionNode = FALSE diff --git a/src/NetTestRegimentation/ITestAsyncMethodWithNullableParameters.cs b/src/NetTestRegimentation/ITestAsyncMethodWithNullableParameters.cs index 90a3f41..987a5be 100644 --- a/src/NetTestRegimentation/ITestAsyncMethodWithNullableParameters.cs +++ b/src/NetTestRegimentation/ITestAsyncMethodWithNullableParameters.cs @@ -1,341 +1,23 @@ +// Copyright (c) 2019 dpvreony and Contributors. All rights reserved. +// This file is licensed to you under the MIT license. +// See the LICENSE file in the project root for full license information. + using System.Threading.Tasks; namespace NetTestRegimentation { + /// + /// Unit Tests for Async Methods that contain nullable parameters. + /// + /// + /// This is a catch all interface. You should look to use one of the generic versions. + /// public interface ITestAsyncMethodWithNullableParameters { + /// + /// Check to ensure nullable parameters throw . + /// + /// A representing the asynchronous operation. Task ThrowsArgumentNullExceptionAsync(); } - - public interface ITestAsyncMethodWithNullableParameters - { - Task ThrowsArgumentNullExceptionAsync( - TArg arg, - string expectedParameterNameForException); - } - - public interface ITestAsyncMethodWithNullableParameters - { - Task ThrowsArgumentNullExceptionAsync( - TArg1 arg1, - TArg2 arg2, - string expectedParameterNameForException); - } - - public interface ITestAsyncMethodWithNullableParameters - { - Task ThrowsArgumentNullExceptionAsync( - TArg1 arg1, - TArg2 arg2, - TArg3 arg3, - string expectedParameterNameForException); - } - - public interface ITestAsyncMethodWithNullableParameters - { - Task ThrowsArgumentNullExceptionAsync( - TArg1 arg1, - TArg2 arg2, - TArg3 arg3, - TArg4 arg4, - string expectedParameterNameForException); - } - - public interface ITestAsyncMethodWithNullableParameters - { - Task ThrowsArgumentNullExceptionAsync( - TArg1 arg1, - TArg2 arg2, - TArg3 arg3, - TArg4 arg4, - TArg5 arg5, - string expectedParameterNameForException); - } - - public interface ITestAsyncMethodWithNullableParameters - { - Task ThrowsArgumentNullExceptionAsync( - TArg1 arg1, - TArg2 arg2, - TArg3 arg3, - TArg4 arg4, - TArg5 arg5, - TArg6 arg6, - string expectedParameterNameForException); - } - - public interface ITestAsyncMethodWithNullableParameters - { - Task ThrowsArgumentNullExceptionAsync( - TArg1 arg1, - TArg2 arg2, - TArg3 arg3, - TArg4 arg4, - TArg5 arg5, - TArg6 arg6, - TArg7 arg7, - string expectedParameterNameForException); - } - - public interface ITestAsyncMethodWithNullableParameters - { - Task ThrowsArgumentNullExceptionAsync( - TArg1 arg1, - TArg2 arg2, - TArg3 arg3, - TArg4 arg4, - TArg5 arg5, - TArg6 arg6, - TArg7 arg7, - TArg8 arg8, - string expectedParameterNameForException); - } - - public interface ITestAsyncMethodWithNullableParameters< - in TArg1, - in TArg2, - in TArg3, - in TArg4, - in TArg5, - in TArg6, - in TArg7, - in TArg8, - in TArg9> - { - Task ThrowsArgumentNullExceptionAsync( - TArg1 arg1, - TArg2 arg2, - TArg3 arg3, - TArg4 arg4, - TArg5 arg5, - TArg6 arg6, - TArg7 arg7, - TArg8 arg8, - TArg9 arg9, - string expectedParameterNameForException); - } - - public interface ITestAsyncMethodWithNullableParameters< - in TArg1, - in TArg2, - in TArg3, - in TArg4, - in TArg5, - in TArg6, - in TArg7, - in TArg8, - in TArg9, - in TArg10> - { - Task ThrowsArgumentNullExceptionAsync( - TArg1 arg1, - TArg2 arg2, - TArg3 arg3, - TArg4 arg4, - TArg5 arg5, - TArg6 arg6, - TArg7 arg7, - TArg8 arg8, - TArg9 arg9, - TArg10 arg10, - string expectedParameterNameForException); - } - - public interface ITestAsyncMethodWithNullableParameters< - in TArg1, - in TArg2, - in TArg3, - in TArg4, - in TArg5, - in TArg6, - in TArg7, - in TArg8, - in TArg9, - in TArg10, - in TArg11> - { - Task ThrowsArgumentNullExceptionAsync( - TArg1 arg1, - TArg2 arg2, - TArg3 arg3, - TArg4 arg4, - TArg5 arg5, - TArg6 arg6, - TArg7 arg7, - TArg8 arg8, - TArg9 arg9, - TArg10 arg10, - TArg11 arg11, - string expectedParameterNameForException); - } - - public interface ITestAsyncMethodWithNullableParameters< - in TArg1, - in TArg2, - in TArg3, - in TArg4, - in TArg5, - in TArg6, - in TArg7, - in TArg8, - in TArg9, - in TArg10, - in TArg11, - in TArg12> - { - Task ThrowsArgumentNullExceptionAsync( - TArg1 arg1, - TArg2 arg2, - TArg3 arg3, - TArg4 arg4, - TArg5 arg5, - TArg6 arg6, - TArg7 arg7, - TArg8 arg8, - TArg9 arg9, - TArg10 arg10, - TArg11 arg11, - TArg12 arg12, - string expectedParameterNameForException); - } - - public interface ITestAsyncMethodWithNullableParameters< - in TArg1, - in TArg2, - in TArg3, - in TArg4, - in TArg5, - in TArg6, - in TArg7, - in TArg8, - in TArg9, - in TArg10, - in TArg11, - in TArg12, - in TArg13> - { - Task ThrowsArgumentNullExceptionAsync( - TArg1 arg1, - TArg2 arg2, - TArg3 arg3, - TArg4 arg4, - TArg5 arg5, - TArg6 arg6, - TArg7 arg7, - TArg8 arg8, - TArg9 arg9, - TArg10 arg10, - TArg11 arg11, - TArg12 arg12, - TArg13 arg13, - string expectedParameterNameForException); - } - - public interface ITestAsyncMethodWithNullableParameters< - in TArg1, - in TArg2, - in TArg3, - in TArg4, - in TArg5, - in TArg6, - in TArg7, - in TArg8, - in TArg9, - in TArg10, - in TArg11, - in TArg12, - in TArg13, - in TArg14> - { - Task ThrowsArgumentNullExceptionAsync( - TArg1 arg1, - TArg2 arg2, - TArg3 arg3, - TArg4 arg4, - TArg5 arg5, - TArg6 arg6, - TArg7 arg7, - TArg8 arg8, - TArg9 arg9, - TArg10 arg10, - TArg11 arg11, - TArg12 arg12, - TArg13 arg13, - TArg14 arg14, - string expectedParameterNameForException); - } - - public interface ITestAsyncMethodWithNullableParameters< - in TArg1, - in TArg2, - in TArg3, - in TArg4, - in TArg5, - in TArg6, - in TArg7, - in TArg8, - in TArg9, - in TArg10, - in TArg11, - in TArg12, - in TArg13, - in TArg14, - in TArg15> - { - Task ThrowsArgumentNullExceptionAsync( - TArg1 arg1, - TArg2 arg2, - TArg3 arg3, - TArg4 arg4, - TArg5 arg5, - TArg6 arg6, - TArg7 arg7, - TArg8 arg8, - TArg9 arg9, - TArg10 arg10, - TArg11 arg11, - TArg12 arg12, - TArg13 arg13, - TArg14 arg14, - TArg15 arg15, - string expectedParameterNameForException); - } - - public interface ITestAsyncMethodWithNullableParameters< - in TArg1, - in TArg2, - in TArg3, - in TArg4, - in TArg5, - in TArg6, - in TArg7, - in TArg8, - in TArg9, - in TArg10, - in TArg11, - in TArg12, - in TArg13, - in TArg14, - in TArg15, - in TArg16> - { - Task ThrowsArgumentNullExceptionAsync( - TArg1 arg1, - TArg2 arg2, - TArg3 arg3, - TArg4 arg4, - TArg5 arg5, - TArg6 arg6, - TArg7 arg7, - TArg8 arg8, - TArg9 arg9, - TArg10 arg10, - TArg11 arg11, - TArg12 arg12, - TArg13 arg13, - TArg14 arg14, - TArg15 arg15, - TArg16 arg16, - string expectedParameterNameForException); - } } diff --git a/src/NetTestRegimentation/ITestAsyncMethodWithNullableParameters{TArg1,TArg2,TArg3,TArg4,TArg5,TArg6,TArg7,TArg8,TArg9,TArg10,TArg11,TArg12,TArg13,TArg14,TArg15,TArg16}.cs b/src/NetTestRegimentation/ITestAsyncMethodWithNullableParameters{TArg1,TArg2,TArg3,TArg4,TArg5,TArg6,TArg7,TArg8,TArg9,TArg10,TArg11,TArg12,TArg13,TArg14,TArg15,TArg16}.cs new file mode 100644 index 0000000..d745933 --- /dev/null +++ b/src/NetTestRegimentation/ITestAsyncMethodWithNullableParameters{TArg1,TArg2,TArg3,TArg4,TArg5,TArg6,TArg7,TArg8,TArg9,TArg10,TArg11,TArg12,TArg13,TArg14,TArg15,TArg16}.cs @@ -0,0 +1,90 @@ +// Copyright (c) 2019 dpvreony and Contributors. All rights reserved. +// This file is licensed to you under the MIT license. +// See the LICENSE file in the project root for full license information. + +using System.Threading.Tasks; + +namespace NetTestRegimentation +{ + /// + /// Unit Tests for a method that takes sixteen nullable parameters. + /// + /// Type for the 1st argument. + /// Type for the 2nd argument. + /// Type for the 3rd argument. + /// Type for the 4th argument. + /// Type for the 5th argument. + /// Type for the 6th argument. + /// Type for the 7th argument. + /// Type for the 8th argument. + /// Type for the 9th argument. + /// Type for the 10th argument. + /// Type for the 11th argument. + /// Type for the 12th argument. + /// Type for the 13th argument. + /// Type for the 14th argument. + /// Type for the 15th argument. + /// Type for the 16th argument. + public interface ITestAsyncMethodWithNullableParameters< + in TArg1, + in TArg2, + in TArg3, + in TArg4, + in TArg5, + in TArg6, + in TArg7, + in TArg8, + in TArg9, + in TArg10, + in TArg11, + in TArg12, + in TArg13, + in TArg14, + in TArg15, + in TArg16> + { + /// + /// Check to ensure nullable parameters throw . + /// + /// The 1st nullable argument. + /// The 2nd nullable argument. + /// The 3rd nullable argument. + /// The 4th nullable argument. + /// The 5th nullable argument. + /// The 6th nullable argument. + /// The 7th nullable argument. + /// The 8th nullable argument. + /// The 9th nullable argument. + /// The 10th nullable argument. + /// The 11th nullable argument. + /// The 12th nullable argument. + /// The 13th nullable argument. + /// The 14th nullable argument. + /// The 15th nullable argument. + /// The 16th nullable argument. + /// + /// The name of the parameter expected to throw an exception. + /// + /// + /// A representing the asynchronous operation. + /// + Task ThrowsArgumentNullExceptionAsync( + TArg1 arg1, + TArg2 arg2, + TArg3 arg3, + TArg4 arg4, + TArg5 arg5, + TArg6 arg6, + TArg7 arg7, + TArg8 arg8, + TArg9 arg9, + TArg10 arg10, + TArg11 arg11, + TArg12 arg12, + TArg13 arg13, + TArg14 arg14, + TArg15 arg15, + TArg16 arg16, + string expectedParameterNameForException); + } +} diff --git a/src/NetTestRegimentation/ITestAsyncMethodWithNullableParameters{TArg1,TArg2,TArg3,TArg4,TArg5,TArg6,TArg7,TArg8,TArg9,TArg10,TArg11,TArg12,TArg13,TArg14,TArg15}.cs b/src/NetTestRegimentation/ITestAsyncMethodWithNullableParameters{TArg1,TArg2,TArg3,TArg4,TArg5,TArg6,TArg7,TArg8,TArg9,TArg10,TArg11,TArg12,TArg13,TArg14,TArg15}.cs new file mode 100644 index 0000000..fc39533 --- /dev/null +++ b/src/NetTestRegimentation/ITestAsyncMethodWithNullableParameters{TArg1,TArg2,TArg3,TArg4,TArg5,TArg6,TArg7,TArg8,TArg9,TArg10,TArg11,TArg12,TArg13,TArg14,TArg15}.cs @@ -0,0 +1,86 @@ +// Copyright (c) 2019 dpvreony and Contributors. All rights reserved. +// This file is licensed to you under the MIT license. +// See the LICENSE file in the project root for full license information. + +using System.Threading.Tasks; + +namespace NetTestRegimentation +{ + /// + /// Unit Tests for a method that takes fifteen nullable parameters. + /// + /// Type for the 1st argument. + /// Type for the 2nd argument. + /// Type for the 3rd argument. + /// Type for the 4th argument. + /// Type for the 5th argument. + /// Type for the 6th argument. + /// Type for the 7th argument. + /// Type for the 8th argument. + /// Type for the 9th argument. + /// Type for the 10th argument. + /// Type for the 11th argument. + /// Type for the 12th argument. + /// Type for the 13th argument. + /// Type for the 14th argument. + /// Type for the 15th argument. + public interface ITestAsyncMethodWithNullableParameters< + in TArg1, + in TArg2, + in TArg3, + in TArg4, + in TArg5, + in TArg6, + in TArg7, + in TArg8, + in TArg9, + in TArg10, + in TArg11, + in TArg12, + in TArg13, + in TArg14, + in TArg15> + { + /// + /// Check to ensure nullable parameters throw . + /// + /// The 1st nullable argument. + /// The 2nd nullable argument. + /// The 3rd nullable argument. + /// The 4th nullable argument. + /// The 5th nullable argument. + /// The 6th nullable argument. + /// The 7th nullable argument. + /// The 8th nullable argument. + /// The 9th nullable argument. + /// The 10th nullable argument. + /// The 11th nullable argument. + /// The 12th nullable argument. + /// The 13th nullable argument. + /// The 14th nullable argument. + /// The 15th nullable argument. + /// + /// The name of the parameter expected to throw an exception. + /// + /// + /// A representing the asynchronous operation. + /// + Task ThrowsArgumentNullExceptionAsync( + TArg1 arg1, + TArg2 arg2, + TArg3 arg3, + TArg4 arg4, + TArg5 arg5, + TArg6 arg6, + TArg7 arg7, + TArg8 arg8, + TArg9 arg9, + TArg10 arg10, + TArg11 arg11, + TArg12 arg12, + TArg13 arg13, + TArg14 arg14, + TArg15 arg15, + string expectedParameterNameForException); + } +} diff --git a/src/NetTestRegimentation/ITestAsyncMethodWithNullableParameters{TArg1,TArg2,TArg3,TArg4,TArg5,TArg6,TArg7,TArg8,TArg9,TArg10,TArg11,TArg12,TArg13,TArg14}.cs b/src/NetTestRegimentation/ITestAsyncMethodWithNullableParameters{TArg1,TArg2,TArg3,TArg4,TArg5,TArg6,TArg7,TArg8,TArg9,TArg10,TArg11,TArg12,TArg13,TArg14}.cs new file mode 100644 index 0000000..1465961 --- /dev/null +++ b/src/NetTestRegimentation/ITestAsyncMethodWithNullableParameters{TArg1,TArg2,TArg3,TArg4,TArg5,TArg6,TArg7,TArg8,TArg9,TArg10,TArg11,TArg12,TArg13,TArg14}.cs @@ -0,0 +1,82 @@ +// Copyright (c) 2019 dpvreony and Contributors. All rights reserved. +// This file is licensed to you under the MIT license. +// See the LICENSE file in the project root for full license information. + +using System.Threading.Tasks; + +namespace NetTestRegimentation +{ + /// + /// Unit Tests for a method that takes fourteen nullable parameters. + /// + /// Type for the 1st argument. + /// Type for the 2nd argument. + /// Type for the 3rd argument. + /// Type for the 4th argument. + /// Type for the 5th argument. + /// Type for the 6th argument. + /// Type for the 7th argument. + /// Type for the 8th argument. + /// Type for the 9th argument. + /// Type for the 10th argument. + /// Type for the 11th argument. + /// Type for the 12th argument. + /// Type for the 13th argument. + /// Type for the 14th argument. + public interface ITestAsyncMethodWithNullableParameters< + in TArg1, + in TArg2, + in TArg3, + in TArg4, + in TArg5, + in TArg6, + in TArg7, + in TArg8, + in TArg9, + in TArg10, + in TArg11, + in TArg12, + in TArg13, + in TArg14> + { + /// + /// Check to ensure nullable parameters throw . + /// + /// The 1st nullable argument. + /// The 2nd nullable argument. + /// The 3rd nullable argument. + /// The 4th nullable argument. + /// The 5th nullable argument. + /// The 6th nullable argument. + /// The 7th nullable argument. + /// The 8th nullable argument. + /// The 9th nullable argument. + /// The 10th nullable argument. + /// The 11th nullable argument. + /// The 12th nullable argument. + /// The 13th nullable argument. + /// The 14th nullable argument. + /// + /// The name of the parameter expected to throw an exception. + /// + /// + /// A representing the asynchronous operation. + /// + Task ThrowsArgumentNullExceptionAsync( + TArg1 arg1, + TArg2 arg2, + TArg3 arg3, + TArg4 arg4, + TArg5 arg5, + TArg6 arg6, + TArg7 arg7, + TArg8 arg8, + TArg9 arg9, + TArg10 arg10, + TArg11 arg11, + TArg12 arg12, + TArg13 arg13, + TArg14 arg14, + string expectedParameterNameForException); + } +} diff --git a/src/NetTestRegimentation/ITestAsyncMethodWithNullableParameters{TArg1,TArg2,TArg3,TArg4,TArg5,TArg6,TArg7,TArg8,TArg9,TArg10,TArg11,TArg12,TArg13}.cs b/src/NetTestRegimentation/ITestAsyncMethodWithNullableParameters{TArg1,TArg2,TArg3,TArg4,TArg5,TArg6,TArg7,TArg8,TArg9,TArg10,TArg11,TArg12,TArg13}.cs new file mode 100644 index 0000000..e27e488 --- /dev/null +++ b/src/NetTestRegimentation/ITestAsyncMethodWithNullableParameters{TArg1,TArg2,TArg3,TArg4,TArg5,TArg6,TArg7,TArg8,TArg9,TArg10,TArg11,TArg12,TArg13}.cs @@ -0,0 +1,78 @@ +// Copyright (c) 2019 dpvreony and Contributors. All rights reserved. +// This file is licensed to you under the MIT license. +// See the LICENSE file in the project root for full license information. + +using System.Threading.Tasks; + +namespace NetTestRegimentation +{ + /// + /// Unit Tests for a method that takes thirteen nullable parameters. + /// + /// Type for the 1st argument. + /// Type for the 2nd argument. + /// Type for the 3rd argument. + /// Type for the 4th argument. + /// Type for the 5th argument. + /// Type for the 6th argument. + /// Type for the 7th argument. + /// Type for the 8th argument. + /// Type for the 9th argument. + /// Type for the 10th argument. + /// Type for the 11th argument. + /// Type for the 12th argument. + /// Type for the 13th argument. + public interface ITestAsyncMethodWithNullableParameters< + in TArg1, + in TArg2, + in TArg3, + in TArg4, + in TArg5, + in TArg6, + in TArg7, + in TArg8, + in TArg9, + in TArg10, + in TArg11, + in TArg12, + in TArg13> + { + /// + /// Check to ensure nullable parameters throw . + /// + /// The 1st nullable argument. + /// The 2nd nullable argument. + /// The 3rd nullable argument. + /// The 4th nullable argument. + /// The 5th nullable argument. + /// The 6th nullable argument. + /// The 7th nullable argument. + /// The 8th nullable argument. + /// The 9th nullable argument. + /// The 10th nullable argument. + /// The 11th nullable argument. + /// The 12th nullable argument. + /// The 13th nullable argument. + /// + /// The name of the parameter expected to throw an exception. + /// + /// + /// A representing the asynchronous operation. + /// + Task ThrowsArgumentNullExceptionAsync( + TArg1 arg1, + TArg2 arg2, + TArg3 arg3, + TArg4 arg4, + TArg5 arg5, + TArg6 arg6, + TArg7 arg7, + TArg8 arg8, + TArg9 arg9, + TArg10 arg10, + TArg11 arg11, + TArg12 arg12, + TArg13 arg13, + string expectedParameterNameForException); + } +} diff --git a/src/NetTestRegimentation/ITestAsyncMethodWithNullableParameters{TArg1,TArg2,TArg3,TArg4,TArg5,TArg6,TArg7,TArg8,TArg9,TArg10,TArg11,TArg12}.cs b/src/NetTestRegimentation/ITestAsyncMethodWithNullableParameters{TArg1,TArg2,TArg3,TArg4,TArg5,TArg6,TArg7,TArg8,TArg9,TArg10,TArg11,TArg12}.cs new file mode 100644 index 0000000..f93a0e3 --- /dev/null +++ b/src/NetTestRegimentation/ITestAsyncMethodWithNullableParameters{TArg1,TArg2,TArg3,TArg4,TArg5,TArg6,TArg7,TArg8,TArg9,TArg10,TArg11,TArg12}.cs @@ -0,0 +1,74 @@ +// Copyright (c) 2019 dpvreony and Contributors. All rights reserved. +// This file is licensed to you under the MIT license. +// See the LICENSE file in the project root for full license information. + +using System.Threading.Tasks; + +namespace NetTestRegimentation +{ + /// + /// Unit Tests for a method that takes twelve nullable parameters. + /// + /// Type for the 1st argument. + /// Type for the 2nd argument. + /// Type for the 3rd argument. + /// Type for the 4th argument. + /// Type for the 5th argument. + /// Type for the 6th argument. + /// Type for the 7th argument. + /// Type for the 8th argument. + /// Type for the 9th argument. + /// Type for the 10th argument. + /// Type for the 11th argument. + /// Type for the 12th argument. + public interface ITestAsyncMethodWithNullableParameters< + in TArg1, + in TArg2, + in TArg3, + in TArg4, + in TArg5, + in TArg6, + in TArg7, + in TArg8, + in TArg9, + in TArg10, + in TArg11, + in TArg12> + { + /// + /// Check to ensure nullable parameters throw . + /// + /// The 1st nullable argument. + /// The 2nd nullable argument. + /// The 3rd nullable argument. + /// The 4th nullable argument. + /// The 5th nullable argument. + /// The 6th nullable argument. + /// The 7th nullable argument. + /// The 8th nullable argument. + /// The 9th nullable argument. + /// The 10th nullable argument. + /// The 11th nullable argument. + /// The 12th nullable argument. + /// + /// The name of the parameter expected to throw an exception. + /// + /// + /// A representing the asynchronous operation. + /// + Task ThrowsArgumentNullExceptionAsync( + TArg1 arg1, + TArg2 arg2, + TArg3 arg3, + TArg4 arg4, + TArg5 arg5, + TArg6 arg6, + TArg7 arg7, + TArg8 arg8, + TArg9 arg9, + TArg10 arg10, + TArg11 arg11, + TArg12 arg12, + string expectedParameterNameForException); + } +} diff --git a/src/NetTestRegimentation/ITestAsyncMethodWithNullableParameters{TArg1,TArg2,TArg3,TArg4,TArg5,TArg6,TArg7,TArg8,TArg9,TArg10,TArg11}.cs b/src/NetTestRegimentation/ITestAsyncMethodWithNullableParameters{TArg1,TArg2,TArg3,TArg4,TArg5,TArg6,TArg7,TArg8,TArg9,TArg10,TArg11}.cs new file mode 100644 index 0000000..3acf8f3 --- /dev/null +++ b/src/NetTestRegimentation/ITestAsyncMethodWithNullableParameters{TArg1,TArg2,TArg3,TArg4,TArg5,TArg6,TArg7,TArg8,TArg9,TArg10,TArg11}.cs @@ -0,0 +1,70 @@ +// Copyright (c) 2019 dpvreony and Contributors. All rights reserved. +// This file is licensed to you under the MIT license. +// See the LICENSE file in the project root for full license information. + +using System.Threading.Tasks; + +namespace NetTestRegimentation +{ + /// + /// Unit Tests for a method that takes eleven nullable parameters. + /// + /// Type for the 1st argument. + /// Type for the 2nd argument. + /// Type for the 3rd argument. + /// Type for the 4th argument. + /// Type for the 5th argument. + /// Type for the 6th argument. + /// Type for the 7th argument. + /// Type for the 8th argument. + /// Type for the 9th argument. + /// Type for the 10th argument. + /// Type for the 11th argument. + public interface ITestAsyncMethodWithNullableParameters< + in TArg1, + in TArg2, + in TArg3, + in TArg4, + in TArg5, + in TArg6, + in TArg7, + in TArg8, + in TArg9, + in TArg10, + in TArg11> + { + /// + /// Check to ensure nullable parameters throw . + /// + /// The 1st nullable argument. + /// The 2nd nullable argument. + /// The 3rd nullable argument. + /// The 4th nullable argument. + /// The 5th nullable argument. + /// The 6th nullable argument. + /// The 7th nullable argument. + /// The 8th nullable argument. + /// The 9th nullable argument. + /// The 10th nullable argument. + /// The 11th nullable argument. + /// + /// The name of the parameter expected to throw an exception. + /// + /// + /// A representing the asynchronous operation. + /// + Task ThrowsArgumentNullExceptionAsync( + TArg1 arg1, + TArg2 arg2, + TArg3 arg3, + TArg4 arg4, + TArg5 arg5, + TArg6 arg6, + TArg7 arg7, + TArg8 arg8, + TArg9 arg9, + TArg10 arg10, + TArg11 arg11, + string expectedParameterNameForException); + } +} diff --git a/src/NetTestRegimentation/ITestAsyncMethodWithNullableParameters{TArg1,TArg2,TArg3,TArg4,TArg5,TArg6,TArg7,TArg8,TArg9,TArg10}.cs b/src/NetTestRegimentation/ITestAsyncMethodWithNullableParameters{TArg1,TArg2,TArg3,TArg4,TArg5,TArg6,TArg7,TArg8,TArg9,TArg10}.cs new file mode 100644 index 0000000..d3a7e9c --- /dev/null +++ b/src/NetTestRegimentation/ITestAsyncMethodWithNullableParameters{TArg1,TArg2,TArg3,TArg4,TArg5,TArg6,TArg7,TArg8,TArg9,TArg10}.cs @@ -0,0 +1,66 @@ +// Copyright (c) 2019 dpvreony and Contributors. All rights reserved. +// This file is licensed to you under the MIT license. +// See the LICENSE file in the project root for full license information. + +using System.Threading.Tasks; + +namespace NetTestRegimentation +{ + /// + /// Unit Tests for a method that takes ten nullable parameters. + /// + /// Type for the 1st argument. + /// Type for the 2nd argument. + /// Type for the 3rd argument. + /// Type for the 4th argument. + /// Type for the 5th argument. + /// Type for the 6th argument. + /// Type for the 7th argument. + /// Type for the 8th argument. + /// Type for the 9th argument. + /// Type for the 10th argument. + public interface ITestAsyncMethodWithNullableParameters< + in TArg1, + in TArg2, + in TArg3, + in TArg4, + in TArg5, + in TArg6, + in TArg7, + in TArg8, + in TArg9, + in TArg10> + { + /// + /// Check to ensure nullable parameters throw . + /// + /// The 1st nullable argument. + /// The 2nd nullable argument. + /// The 3rd nullable argument. + /// The 4th nullable argument. + /// The 5th nullable argument. + /// The 6th nullable argument. + /// The 7th nullable argument. + /// The 8th nullable argument. + /// The 9th nullable argument. + /// The 10th nullable argument. + /// + /// The name of the parameter expected to throw an exception. + /// + /// + /// A representing the asynchronous operation. + /// + Task ThrowsArgumentNullExceptionAsync( + TArg1 arg1, + TArg2 arg2, + TArg3 arg3, + TArg4 arg4, + TArg5 arg5, + TArg6 arg6, + TArg7 arg7, + TArg8 arg8, + TArg9 arg9, + TArg10 arg10, + string expectedParameterNameForException); + } +} diff --git a/src/NetTestRegimentation/ITestAsyncMethodWithNullableParameters{TArg1,TArg2,TArg3,TArg4,TArg5,TArg6,TArg7,TArg8,TArg9}.cs b/src/NetTestRegimentation/ITestAsyncMethodWithNullableParameters{TArg1,TArg2,TArg3,TArg4,TArg5,TArg6,TArg7,TArg8,TArg9}.cs new file mode 100644 index 0000000..1e62fdd --- /dev/null +++ b/src/NetTestRegimentation/ITestAsyncMethodWithNullableParameters{TArg1,TArg2,TArg3,TArg4,TArg5,TArg6,TArg7,TArg8,TArg9}.cs @@ -0,0 +1,62 @@ +// Copyright (c) 2019 dpvreony and Contributors. All rights reserved. +// This file is licensed to you under the MIT license. +// See the LICENSE file in the project root for full license information. + +using System.Threading.Tasks; + +namespace NetTestRegimentation +{ + /// + /// Unit Tests for a method that takes nine nullable parameters. + /// + /// Type for the 1st argument. + /// Type for the 2nd argument. + /// Type for the 3rd argument. + /// Type for the 4th argument. + /// Type for the 5th argument. + /// Type for the 6th argument. + /// Type for the 7th argument. + /// Type for the 8th argument. + /// Type for the 9th argument. + public interface ITestAsyncMethodWithNullableParameters< + in TArg1, + in TArg2, + in TArg3, + in TArg4, + in TArg5, + in TArg6, + in TArg7, + in TArg8, + in TArg9> + { + /// + /// Check to ensure nullable parameters throw . + /// + /// The 1st nullable argument. + /// The 2nd nullable argument. + /// The 3rd nullable argument. + /// The 4th nullable argument. + /// The 5th nullable argument. + /// The 6th nullable argument. + /// The 7th nullable argument. + /// The 8th nullable argument. + /// The 9th nullable argument. + /// + /// The name of the parameter expected to throw an exception. + /// + /// + /// A representing the asynchronous operation. + /// + Task ThrowsArgumentNullExceptionAsync( + TArg1 arg1, + TArg2 arg2, + TArg3 arg3, + TArg4 arg4, + TArg5 arg5, + TArg6 arg6, + TArg7 arg7, + TArg8 arg8, + TArg9 arg9, + string expectedParameterNameForException); + } +} diff --git a/src/NetTestRegimentation/ITestAsyncMethodWithNullableParameters{TArg1,TArg2,TArg3,TArg4,TArg5,TArg6,TArg7,TArg8}.cs b/src/NetTestRegimentation/ITestAsyncMethodWithNullableParameters{TArg1,TArg2,TArg3,TArg4,TArg5,TArg6,TArg7,TArg8}.cs new file mode 100644 index 0000000..a099b31 --- /dev/null +++ b/src/NetTestRegimentation/ITestAsyncMethodWithNullableParameters{TArg1,TArg2,TArg3,TArg4,TArg5,TArg6,TArg7,TArg8}.cs @@ -0,0 +1,50 @@ +// Copyright (c) 2019 dpvreony and Contributors. All rights reserved. +// This file is licensed to you under the MIT license. +// See the LICENSE file in the project root for full license information. + +using System.Threading.Tasks; + +namespace NetTestRegimentation +{ + /// + /// Unit Tests for a method that takes eight nullable parameters. + /// + /// Type for the 1st argument. + /// Type for the 2nd argument. + /// Type for the 3rd argument. + /// Type for the 4th argument. + /// Type for the 5th argument. + /// Type for the 6th argument. + /// Type for the 7th argument. + /// Type for the 8th argument. + public interface ITestAsyncMethodWithNullableParameters + { + /// + /// Check to ensure nullable parameters throw . + /// + /// The 1st nullable argument. + /// The 2nd nullable argument. + /// The 3rd nullable argument. + /// The 4th nullable argument. + /// The 5th nullable argument. + /// The 6th nullable argument. + /// The 7th nullable argument. + /// The 8th nullable argument. + /// + /// The name of the parameter expected to throw an exception. + /// + /// + /// A representing the asynchronous operation. + /// + Task ThrowsArgumentNullExceptionAsync( + TArg1 arg1, + TArg2 arg2, + TArg3 arg3, + TArg4 arg4, + TArg5 arg5, + TArg6 arg6, + TArg7 arg7, + TArg8 arg8, + string expectedParameterNameForException); + } +} diff --git a/src/NetTestRegimentation/ITestAsyncMethodWithNullableParameters{TArg1,TArg2,TArg3,TArg4,TArg5,TArg6,TArg7}.cs b/src/NetTestRegimentation/ITestAsyncMethodWithNullableParameters{TArg1,TArg2,TArg3,TArg4,TArg5,TArg6,TArg7}.cs new file mode 100644 index 0000000..d1e00a5 --- /dev/null +++ b/src/NetTestRegimentation/ITestAsyncMethodWithNullableParameters{TArg1,TArg2,TArg3,TArg4,TArg5,TArg6,TArg7}.cs @@ -0,0 +1,47 @@ +// Copyright (c) 2019 dpvreony and Contributors. All rights reserved. +// This file is licensed to you under the MIT license. +// See the LICENSE file in the project root for full license information. + +using System.Threading.Tasks; + +namespace NetTestRegimentation +{ + /// + /// Unit Tests for a method that takes seven nullable parameters. + /// + /// Type for the 1st argument. + /// Type for the 2nd argument. + /// Type for the 3rd argument. + /// Type for the 4th argument. + /// Type for the 5th argument. + /// Type for the 6th argument. + /// Type for the 7th argument. + public interface ITestAsyncMethodWithNullableParameters + { + /// + /// Check to ensure nullable parameters throw . + /// + /// The 1st nullable argument. + /// The 2nd nullable argument. + /// The 3rd nullable argument. + /// The 4th nullable argument. + /// The 5th nullable argument. + /// The 6th nullable argument. + /// The 7th nullable argument. + /// + /// The name of the parameter expected to throw an exception. + /// + /// + /// A representing the asynchronous operation. + /// + Task ThrowsArgumentNullExceptionAsync( + TArg1 arg1, + TArg2 arg2, + TArg3 arg3, + TArg4 arg4, + TArg5 arg5, + TArg6 arg6, + TArg7 arg7, + string expectedParameterNameForException); + } +} diff --git a/src/NetTestRegimentation/ITestAsyncMethodWithNullableParameters{TArg1,TArg2,TArg3,TArg4,TArg5,TArg6}.cs b/src/NetTestRegimentation/ITestAsyncMethodWithNullableParameters{TArg1,TArg2,TArg3,TArg4,TArg5,TArg6}.cs new file mode 100644 index 0000000..4d8f5f7 --- /dev/null +++ b/src/NetTestRegimentation/ITestAsyncMethodWithNullableParameters{TArg1,TArg2,TArg3,TArg4,TArg5,TArg6}.cs @@ -0,0 +1,44 @@ +// Copyright (c) 2019 dpvreony and Contributors. All rights reserved. +// This file is licensed to you under the MIT license. +// See the LICENSE file in the project root for full license information. + +using System.Threading.Tasks; + +namespace NetTestRegimentation +{ + /// + /// Unit Tests for a method that takes six nullable parameters. + /// + /// Type for the 1st argument. + /// Type for the 2nd argument. + /// Type for the 3rd argument. + /// Type for the 4th argument. + /// Type for the 5th argument. + /// Type for the 6th argument. + public interface ITestAsyncMethodWithNullableParameters + { + /// + /// Check to ensure nullable parameters throw . + /// + /// The 1st nullable argument. + /// The 2nd nullable argument. + /// The 3rd nullable argument. + /// The 4th nullable argument. + /// The 5th nullable argument. + /// The 6th nullable argument. + /// + /// The name of the parameter expected to throw an exception. + /// + /// + /// A representing the asynchronous operation. + /// + Task ThrowsArgumentNullExceptionAsync( + TArg1 arg1, + TArg2 arg2, + TArg3 arg3, + TArg4 arg4, + TArg5 arg5, + TArg6 arg6, + string expectedParameterNameForException); + } +} diff --git a/src/NetTestRegimentation/ITestAsyncMethodWithNullableParameters{TArg1,TArg2,TArg3,TArg4,TArg5}.cs b/src/NetTestRegimentation/ITestAsyncMethodWithNullableParameters{TArg1,TArg2,TArg3,TArg4,TArg5}.cs new file mode 100644 index 0000000..8d83c54 --- /dev/null +++ b/src/NetTestRegimentation/ITestAsyncMethodWithNullableParameters{TArg1,TArg2,TArg3,TArg4,TArg5}.cs @@ -0,0 +1,41 @@ +// Copyright (c) 2019 dpvreony and Contributors. All rights reserved. +// This file is licensed to you under the MIT license. +// See the LICENSE file in the project root for full license information. + +using System.Threading.Tasks; + +namespace NetTestRegimentation +{ + /// + /// Unit Tests for a method that takes five nullable parameters. + /// + /// Type for the 1st argument. + /// Type for the 2nd argument. + /// Type for the 3rd argument. + /// Type for the 4th argument. + /// Type for the 5th argument. + public interface ITestAsyncMethodWithNullableParameters + { + /// + /// Check to ensure nullable parameters throw . + /// + /// The 1st nullable argument. + /// The 2nd nullable argument. + /// The 3rd nullable argument. + /// The 4th nullable argument. + /// The 5th nullable argument. + /// + /// The name of the parameter expected to throw an exception. + /// + /// + /// A representing the asynchronous operation. + /// + Task ThrowsArgumentNullExceptionAsync( + TArg1 arg1, + TArg2 arg2, + TArg3 arg3, + TArg4 arg4, + TArg5 arg5, + string expectedParameterNameForException); + } +} diff --git a/src/NetTestRegimentation/ITestAsyncMethodWithNullableParameters{TArg1,TArg2,TArg3,TArg4}.cs b/src/NetTestRegimentation/ITestAsyncMethodWithNullableParameters{TArg1,TArg2,TArg3,TArg4}.cs new file mode 100644 index 0000000..4936270 --- /dev/null +++ b/src/NetTestRegimentation/ITestAsyncMethodWithNullableParameters{TArg1,TArg2,TArg3,TArg4}.cs @@ -0,0 +1,38 @@ +// Copyright (c) 2019 dpvreony and Contributors. All rights reserved. +// This file is licensed to you under the MIT license. +// See the LICENSE file in the project root for full license information. + +using System.Threading.Tasks; + +namespace NetTestRegimentation +{ + /// + /// Unit Tests for a method that takes four nullable parameters. + /// + /// Type for the 1st argument. + /// Type for the 2nd argument. + /// Type for the 3rd argument. + /// Type for the 4th argument. + public interface ITestAsyncMethodWithNullableParameters + { + /// + /// Check to ensure nullable parameters throw . + /// + /// The 1st nullable argument. + /// The 2nd nullable argument. + /// The 3rd nullable argument. + /// The 4th nullable argument. + /// + /// The name of the parameter expected to throw an exception. + /// + /// + /// A representing the asynchronous operation. + /// + Task ThrowsArgumentNullExceptionAsync( + TArg1 arg1, + TArg2 arg2, + TArg3 arg3, + TArg4 arg4, + string expectedParameterNameForException); + } +} diff --git a/src/NetTestRegimentation/ITestAsyncMethodWithNullableParameters{TArg1,TArg2,TArg3}.cs b/src/NetTestRegimentation/ITestAsyncMethodWithNullableParameters{TArg1,TArg2,TArg3}.cs new file mode 100644 index 0000000..1bcbe2c --- /dev/null +++ b/src/NetTestRegimentation/ITestAsyncMethodWithNullableParameters{TArg1,TArg2,TArg3}.cs @@ -0,0 +1,35 @@ +// Copyright (c) 2019 dpvreony and Contributors. All rights reserved. +// This file is licensed to you under the MIT license. +// See the LICENSE file in the project root for full license information. + +using System.Threading.Tasks; + +namespace NetTestRegimentation +{ + /// + /// Unit Tests for a method that takes three nullable parameters. + /// + /// Type for the 1st argument. + /// Type for the 2nd argument. + /// Type for the 3rd argument. + public interface ITestAsyncMethodWithNullableParameters + { + /// + /// Check to ensure nullable parameters throw . + /// + /// The 1st nullable argument. + /// The 2nd nullable argument. + /// The 3rd nullable argument. + /// + /// The name of the parameter expected to throw an exception. + /// + /// + /// A representing the asynchronous operation. + /// + Task ThrowsArgumentNullExceptionAsync( + TArg1 arg1, + TArg2 arg2, + TArg3 arg3, + string expectedParameterNameForException); + } +} diff --git a/src/NetTestRegimentation/ITestAsyncMethodWithNullableParameters{TArg1,TArg2}.cs b/src/NetTestRegimentation/ITestAsyncMethodWithNullableParameters{TArg1,TArg2}.cs new file mode 100644 index 0000000..a9e7198 --- /dev/null +++ b/src/NetTestRegimentation/ITestAsyncMethodWithNullableParameters{TArg1,TArg2}.cs @@ -0,0 +1,32 @@ +// Copyright (c) 2019 dpvreony and Contributors. All rights reserved. +// This file is licensed to you under the MIT license. +// See the LICENSE file in the project root for full license information. + +using System.Threading.Tasks; + +namespace NetTestRegimentation +{ + /// + /// Unit Tests for a method that takes two nullable parameters. + /// + /// Type for the 1st argument. + /// Type for the 2nd argument. + public interface ITestAsyncMethodWithNullableParameters + { + /// + /// Check to ensure nullable parameters throw . + /// + /// The 1st nullable argument. + /// The 2nd nullable argument. + /// + /// The name of the parameter expected to throw an exception. + /// + /// + /// A representing the asynchronous operation. + /// + Task ThrowsArgumentNullExceptionAsync( + TArg1 arg1, + TArg2 arg2, + string expectedParameterNameForException); + } +} diff --git a/src/NetTestRegimentation/ITestAsyncMethodWithNullableParameters{TArg}.cs b/src/NetTestRegimentation/ITestAsyncMethodWithNullableParameters{TArg}.cs new file mode 100644 index 0000000..a53c171 --- /dev/null +++ b/src/NetTestRegimentation/ITestAsyncMethodWithNullableParameters{TArg}.cs @@ -0,0 +1,29 @@ +// Copyright (c) 2019 dpvreony and Contributors. All rights reserved. +// This file is licensed to you under the MIT license. +// See the LICENSE file in the project root for full license information. + +using System.Threading.Tasks; + +namespace NetTestRegimentation +{ + /// + /// Unit Tests for a method that a nullable parameter. + /// + /// Type for the argument. + public interface ITestAsyncMethodWithNullableParameters + { + /// + /// Check to ensure nullable parameters throw . + /// + /// The nullable argument. + /// + /// The name of the parameter expected to throw an exception. + /// + /// + /// A representing the asynchronous operation. + /// + Task ThrowsArgumentNullExceptionAsync( + TArg arg, + string expectedParameterNameForException); + } +} diff --git a/src/NetTestRegimentation/ITestAsyncMethodWithParameterValidation.cs b/src/NetTestRegimentation/ITestAsyncMethodWithParameterValidation.cs index b3475e0..8080543 100644 --- a/src/NetTestRegimentation/ITestAsyncMethodWithParameterValidation.cs +++ b/src/NetTestRegimentation/ITestAsyncMethodWithParameterValidation.cs @@ -1,336 +1,26 @@ +// Copyright (c) 2019 dpvreony and Contributors. All rights reserved. +// This file is licensed to you under the MIT license. +// See the LICENSE file in the project root for full license information. + using System.Threading.Tasks; namespace NetTestRegimentation { - public interface ITestAsyncMethodWithParameterValidation - { - Task ThrowsArgumentExceptionAsync( - TArg arg, - string expectedParameterNameForException); - } - - public interface ITestAsyncMethodWithParameterValidation - { - Task ThrowsArgumentExceptionAsync( - TArg1 arg1, - TArg2 arg2, - string expectedParameterNameForException); - } - - public interface ITestAsyncMethodWithParameterValidation - { - Task ThrowsArgumentExceptionAsync( - TArg1 arg1, - TArg2 arg2, - TArg3 arg3, - string expectedParameterNameForException); - } - - public interface ITestAsyncMethodWithParameterValidation - { - Task ThrowsArgumentExceptionAsync( - TArg1 arg1, - TArg2 arg2, - TArg3 arg3, - TArg4 arg4, - string expectedParameterNameForException); - } - - public interface ITestAsyncMethodWithParameterValidation - { - Task ThrowsArgumentExceptionAsync( - TArg1 arg1, - TArg2 arg2, - TArg3 arg3, - TArg4 arg4, - TArg5 arg5, - string expectedParameterNameForException); - } - - public interface ITestAsyncMethodWithParameterValidation - { - Task ThrowsArgumentExceptionAsync( - TArg1 arg1, - TArg2 arg2, - TArg3 arg3, - TArg4 arg4, - TArg5 arg5, - TArg6 arg6, - string expectedParameterNameForException); - } - - public interface ITestAsyncMethodWithParameterValidation - { - Task ThrowsArgumentExceptionAsync( - TArg1 arg1, - TArg2 arg2, - TArg3 arg3, - TArg4 arg4, - TArg5 arg5, - TArg6 arg6, - TArg7 arg7, - string expectedParameterNameForException); - } - - public interface ITestAsyncMethodWithParameterValidation - { - Task ThrowsArgumentExceptionAsync( - TArg1 arg1, - TArg2 arg2, - TArg3 arg3, - TArg4 arg4, - TArg5 arg5, - TArg6 arg6, - TArg7 arg7, - TArg8 arg8, - string expectedParameterNameForException); - } - - public interface ITestAsyncMethodWithParameterValidation< - in TArg1, - in TArg2, - in TArg3, - in TArg4, - in TArg5, - in TArg6, - in TArg7, - in TArg8, - in TArg9> - { - Task ThrowsArgumentExceptionAsync( - TArg1 arg1, - TArg2 arg2, - TArg3 arg3, - TArg4 arg4, - TArg5 arg5, - TArg6 arg6, - TArg7 arg7, - TArg8 arg8, - TArg9 arg9, - string expectedParameterNameForException); - } - - public interface ITestAsyncMethodWithParameterValidation< - in TArg1, - in TArg2, - in TArg3, - in TArg4, - in TArg5, - in TArg6, - in TArg7, - in TArg8, - in TArg9, - in TArg10> - { - Task ThrowsArgumentExceptionAsync( - TArg1 arg1, - TArg2 arg2, - TArg3 arg3, - TArg4 arg4, - TArg5 arg5, - TArg6 arg6, - TArg7 arg7, - TArg8 arg8, - TArg9 arg9, - TArg10 arg10, - string expectedParameterNameForException); - } - - public interface ITestAsyncMethodWithParameterValidation< - in TArg1, - in TArg2, - in TArg3, - in TArg4, - in TArg5, - in TArg6, - in TArg7, - in TArg8, - in TArg9, - in TArg10, - in TArg11> - { - Task ThrowsArgumentExceptionAsync( - TArg1 arg1, - TArg2 arg2, - TArg3 arg3, - TArg4 arg4, - TArg5 arg5, - TArg6 arg6, - TArg7 arg7, - TArg8 arg8, - TArg9 arg9, - TArg10 arg10, - TArg11 arg11, - string expectedParameterNameForException); - } - - public interface ITestAsyncMethodWithParameterValidation< - in TArg1, - in TArg2, - in TArg3, - in TArg4, - in TArg5, - in TArg6, - in TArg7, - in TArg8, - in TArg9, - in TArg10, - in TArg11, - in TArg12> - { - Task ThrowsArgumentExceptionAsync( - TArg1 arg1, - TArg2 arg2, - TArg3 arg3, - TArg4 arg4, - TArg5 arg5, - TArg6 arg6, - TArg7 arg7, - TArg8 arg8, - TArg9 arg9, - TArg10 arg10, - TArg11 arg11, - TArg12 arg12, - string expectedParameterNameForException); - } - - public interface ITestAsyncMethodWithParameterValidation< - in TArg1, - in TArg2, - in TArg3, - in TArg4, - in TArg5, - in TArg6, - in TArg7, - in TArg8, - in TArg9, - in TArg10, - in TArg11, - in TArg12, - in TArg13> - { - Task ThrowsArgumentExceptionAsync( - TArg1 arg1, - TArg2 arg2, - TArg3 arg3, - TArg4 arg4, - TArg5 arg5, - TArg6 arg6, - TArg7 arg7, - TArg8 arg8, - TArg9 arg9, - TArg10 arg10, - TArg11 arg11, - TArg12 arg12, - TArg13 arg13, - string expectedParameterNameForException); - } - - public interface ITestAsyncMethodWithParameterValidation< - in TArg1, - in TArg2, - in TArg3, - in TArg4, - in TArg5, - in TArg6, - in TArg7, - in TArg8, - in TArg9, - in TArg10, - in TArg11, - in TArg12, - in TArg13, - in TArg14> - { - Task ThrowsArgumentExceptionAsync( - TArg1 arg1, - TArg2 arg2, - TArg3 arg3, - TArg4 arg4, - TArg5 arg5, - TArg6 arg6, - TArg7 arg7, - TArg8 arg8, - TArg9 arg9, - TArg10 arg10, - TArg11 arg11, - TArg12 arg12, - TArg13 arg13, - TArg14 arg14, - string expectedParameterNameForException); - } - - public interface ITestAsyncMethodWithParameterValidation< - in TArg1, - in TArg2, - in TArg3, - in TArg4, - in TArg5, - in TArg6, - in TArg7, - in TArg8, - in TArg9, - in TArg10, - in TArg11, - in TArg12, - in TArg13, - in TArg14, - in TArg15> - { - Task ThrowsArgumentExceptionAsync( - TArg1 arg1, - TArg2 arg2, - TArg3 arg3, - TArg4 arg4, - TArg5 arg5, - TArg6 arg6, - TArg7 arg7, - TArg8 arg8, - TArg9 arg9, - TArg10 arg10, - TArg11 arg11, - TArg12 arg12, - TArg13 arg13, - TArg14 arg14, - TArg15 arg15, - string expectedParameterNameForException); - } - - public interface ITestAsyncMethodWithParameterValidation< - in TArg1, - in TArg2, - in TArg3, - in TArg4, - in TArg5, - in TArg6, - in TArg7, - in TArg8, - in TArg9, - in TArg10, - in TArg11, - in TArg12, - in TArg13, - in TArg14, - in TArg15, - in TArg16> - { - Task ThrowsArgumentExceptionAsync( - TArg1 arg1, - TArg2 arg2, - TArg3 arg3, - TArg4 arg4, - TArg5 arg5, - TArg6 arg6, - TArg7 arg7, - TArg8 arg8, - TArg9 arg9, - TArg10 arg10, - TArg11 arg11, - TArg12 arg12, - TArg13 arg13, - TArg14 arg14, - TArg15 arg15, - TArg16 arg16, - string expectedParameterNameForException); - } -} \ No newline at end of file + /// + /// Unit Tests for Async Methods that contain parameters that need validation. + /// + /// + /// This is a catch all interface. You should look to use one of the generic versions. + /// + public interface ITestAsyncMethodWithParameterValidation + { + /// + /// Check to ensure parameters that require validation throw . + /// + /// + /// Consider the use of or where it makes sense. + /// + /// A representing the asynchronous operation. + Task ThrowsArgumentExceptionAsync(); + } +} diff --git a/src/NetTestRegimentation/ITestAsyncMethodWithParameterValidation{TArg1,TArg2,TArg3,TArg4,TArg5,TArg6,TArg7,TArg8,TArg9,TArg10,TArg11,TArg12,TArg13,TArg14,TArg15,TArg16}.cs b/src/NetTestRegimentation/ITestAsyncMethodWithParameterValidation{TArg1,TArg2,TArg3,TArg4,TArg5,TArg6,TArg7,TArg8,TArg9,TArg10,TArg11,TArg12,TArg13,TArg14,TArg15,TArg16}.cs new file mode 100644 index 0000000..e4c5e94 --- /dev/null +++ b/src/NetTestRegimentation/ITestAsyncMethodWithParameterValidation{TArg1,TArg2,TArg3,TArg4,TArg5,TArg6,TArg7,TArg8,TArg9,TArg10,TArg11,TArg12,TArg13,TArg14,TArg15,TArg16}.cs @@ -0,0 +1,90 @@ +// Copyright (c) 2019 dpvreony and Contributors. All rights reserved. +// This file is licensed to you under the MIT license. +// See the LICENSE file in the project root for full license information. + +using System.Threading.Tasks; + +namespace NetTestRegimentation +{ + /// + /// Unit Tests for Async Methods that contain sixteen parameters that need validation. + /// + /// Type for the 1st argument. + /// Type for the 2nd argument. + /// Type for the 3rd argument. + /// Type for the 4th argument. + /// Type for the 5th argument. + /// Type for the 6th argument. + /// Type for the 7th argument. + /// Type for the 8th argument. + /// Type for the 9th argument. + /// Type for the 10th argument. + /// Type for the 11th argument. + /// Type for the 12th argument. + /// Type for the 13th argument. + /// Type for the 14th argument. + /// Type for the 15th argument. + /// Type for the 16th argument. + public interface ITestAsyncMethodWithParameterValidation< + in TArg1, + in TArg2, + in TArg3, + in TArg4, + in TArg5, + in TArg6, + in TArg7, + in TArg8, + in TArg9, + in TArg10, + in TArg11, + in TArg12, + in TArg13, + in TArg14, + in TArg15, + in TArg16> + { + /// + /// Check to ensure parameters requiring validation throw . + /// + /// The 1st argument that takes validation. + /// The 2nd argument that takes validation. + /// The 3rd argument that takes validation. + /// The 4th argument that takes validation. + /// The 5th argument that takes validation. + /// The 6th argument that takes validation. + /// The 7th argument that takes validation. + /// The 8th argument that takes validation. + /// The 9th argument that takes validation. + /// The 10th argument that takes validation. + /// The 11th argument that takes validation. + /// The 12th argument that takes validation. + /// The 13th argument that takes validation. + /// The 14th argument that takes validation. + /// The 15th argument that takes validation. + /// The 16th argument that takes validation. + /// + /// The name of the parameter expected to throw an exception. + /// + /// + /// A representing the asynchronous operation. + /// + Task ThrowsArgumentExceptionAsync( + TArg1 arg1, + TArg2 arg2, + TArg3 arg3, + TArg4 arg4, + TArg5 arg5, + TArg6 arg6, + TArg7 arg7, + TArg8 arg8, + TArg9 arg9, + TArg10 arg10, + TArg11 arg11, + TArg12 arg12, + TArg13 arg13, + TArg14 arg14, + TArg15 arg15, + TArg16 arg16, + string expectedParameterNameForException); + } +} diff --git a/src/NetTestRegimentation/ITestAsyncMethodWithParameterValidation{TArg1,TArg2,TArg3,TArg4,TArg5,TArg6,TArg7,TArg8,TArg9,TArg10,TArg11,TArg12,TArg13,TArg14,TArg15}.cs b/src/NetTestRegimentation/ITestAsyncMethodWithParameterValidation{TArg1,TArg2,TArg3,TArg4,TArg5,TArg6,TArg7,TArg8,TArg9,TArg10,TArg11,TArg12,TArg13,TArg14,TArg15}.cs new file mode 100644 index 0000000..56b0cf5 --- /dev/null +++ b/src/NetTestRegimentation/ITestAsyncMethodWithParameterValidation{TArg1,TArg2,TArg3,TArg4,TArg5,TArg6,TArg7,TArg8,TArg9,TArg10,TArg11,TArg12,TArg13,TArg14,TArg15}.cs @@ -0,0 +1,86 @@ +// Copyright (c) 2019 dpvreony and Contributors. All rights reserved. +// This file is licensed to you under the MIT license. +// See the LICENSE file in the project root for full license information. + +using System.Threading.Tasks; + +namespace NetTestRegimentation +{ + /// + /// Unit Tests for Async Methods that contain 15 parameters that need validation. + /// + /// Type for the 1st argument. + /// Type for the 2nd argument. + /// Type for the 3rd argument. + /// Type for the 4th argument. + /// Type for the 5th argument. + /// Type for the 6th argument. + /// Type for the 7th argument. + /// Type for the 8th argument. + /// Type for the 9th argument. + /// Type for the 10th argument. + /// Type for the 11th argument. + /// Type for the 12th argument. + /// Type for the 13th argument. + /// Type for the 14th argument. + /// Type for the 15th argument. + public interface ITestAsyncMethodWithParameterValidation< + in TArg1, + in TArg2, + in TArg3, + in TArg4, + in TArg5, + in TArg6, + in TArg7, + in TArg8, + in TArg9, + in TArg10, + in TArg11, + in TArg12, + in TArg13, + in TArg14, + in TArg15> + { + /// + /// Check to ensure parameters requiring validation throw . + /// + /// The 1st argument that takes validation. + /// The 2nd argument that takes validation. + /// The 3rd argument that takes validation. + /// The 4th argument that takes validation. + /// The 5th argument that takes validation. + /// The 6th argument that takes validation. + /// The 7th argument that takes validation. + /// The 8th argument that takes validation. + /// The 9th argument that takes validation. + /// The 10th argument that takes validation. + /// The 11th argument that takes validation. + /// The 12th argument that takes validation. + /// The 13th argument that takes validation. + /// The 14th argument that takes validation. + /// The 15th argument that takes validation. + /// + /// The name of the parameter expected to throw an exception. + /// + /// + /// A representing the asynchronous operation. + /// + Task ThrowsArgumentExceptionAsync( + TArg1 arg1, + TArg2 arg2, + TArg3 arg3, + TArg4 arg4, + TArg5 arg5, + TArg6 arg6, + TArg7 arg7, + TArg8 arg8, + TArg9 arg9, + TArg10 arg10, + TArg11 arg11, + TArg12 arg12, + TArg13 arg13, + TArg14 arg14, + TArg15 arg15, + string expectedParameterNameForException); + } +} diff --git a/src/NetTestRegimentation/ITestAsyncMethodWithParameterValidation{TArg1,TArg2,TArg3,TArg4,TArg5,TArg6,TArg7,TArg8,TArg9,TArg10,TArg11,TArg12,TArg13,TArg14}.cs b/src/NetTestRegimentation/ITestAsyncMethodWithParameterValidation{TArg1,TArg2,TArg3,TArg4,TArg5,TArg6,TArg7,TArg8,TArg9,TArg10,TArg11,TArg12,TArg13,TArg14}.cs new file mode 100644 index 0000000..476e1f9 --- /dev/null +++ b/src/NetTestRegimentation/ITestAsyncMethodWithParameterValidation{TArg1,TArg2,TArg3,TArg4,TArg5,TArg6,TArg7,TArg8,TArg9,TArg10,TArg11,TArg12,TArg13,TArg14}.cs @@ -0,0 +1,82 @@ +// Copyright (c) 2019 dpvreony and Contributors. All rights reserved. +// This file is licensed to you under the MIT license. +// See the LICENSE file in the project root for full license information. + +using System.Threading.Tasks; + +namespace NetTestRegimentation +{ + /// + /// Unit Tests for Async Methods that contain 14 parameters that need validation. + /// + /// Type for the 1st argument. + /// Type for the 2nd argument. + /// Type for the 3rd argument. + /// Type for the 4th argument. + /// Type for the 5th argument. + /// Type for the 6th argument. + /// Type for the 7th argument. + /// Type for the 8th argument. + /// Type for the 9th argument. + /// Type for the 10th argument. + /// Type for the 11th argument. + /// Type for the 12th argument. + /// Type for the 13th argument. + /// Type for the 14th argument. + public interface ITestAsyncMethodWithParameterValidation< + in TArg1, + in TArg2, + in TArg3, + in TArg4, + in TArg5, + in TArg6, + in TArg7, + in TArg8, + in TArg9, + in TArg10, + in TArg11, + in TArg12, + in TArg13, + in TArg14> + { + /// + /// Check to ensure parameters requiring validation throw . + /// + /// The 1st argument that takes validation. + /// The 2nd argument that takes validation. + /// The 3rd argument that takes validation. + /// The 4th argument that takes validation. + /// The 5th argument that takes validation. + /// The 6th argument that takes validation. + /// The 7th argument that takes validation. + /// The 8th argument that takes validation. + /// The 9th argument that takes validation. + /// The 10th argument that takes validation. + /// The 11th argument that takes validation. + /// The 12th argument that takes validation. + /// The 13th argument that takes validation. + /// The 14th argument that takes validation. + /// + /// The name of the parameter expected to throw an exception. + /// + /// + /// A representing the asynchronous operation. + /// + Task ThrowsArgumentExceptionAsync( + TArg1 arg1, + TArg2 arg2, + TArg3 arg3, + TArg4 arg4, + TArg5 arg5, + TArg6 arg6, + TArg7 arg7, + TArg8 arg8, + TArg9 arg9, + TArg10 arg10, + TArg11 arg11, + TArg12 arg12, + TArg13 arg13, + TArg14 arg14, + string expectedParameterNameForException); + } +} diff --git a/src/NetTestRegimentation/ITestAsyncMethodWithParameterValidation{TArg1,TArg2,TArg3,TArg4,TArg5,TArg6,TArg7,TArg8,TArg9,TArg10,TArg11,TArg12,TArg13}.cs b/src/NetTestRegimentation/ITestAsyncMethodWithParameterValidation{TArg1,TArg2,TArg3,TArg4,TArg5,TArg6,TArg7,TArg8,TArg9,TArg10,TArg11,TArg12,TArg13}.cs new file mode 100644 index 0000000..3030766 --- /dev/null +++ b/src/NetTestRegimentation/ITestAsyncMethodWithParameterValidation{TArg1,TArg2,TArg3,TArg4,TArg5,TArg6,TArg7,TArg8,TArg9,TArg10,TArg11,TArg12,TArg13}.cs @@ -0,0 +1,78 @@ +// Copyright (c) 2019 dpvreony and Contributors. All rights reserved. +// This file is licensed to you under the MIT license. +// See the LICENSE file in the project root for full license information. + +using System.Threading.Tasks; + +namespace NetTestRegimentation +{ + /// + /// Unit Tests for Async Methods that contain 13 parameters that need validation. + /// + /// Type for the 1st argument. + /// Type for the 2nd argument. + /// Type for the 3rd argument. + /// Type for the 4th argument. + /// Type for the 5th argument. + /// Type for the 6th argument. + /// Type for the 7th argument. + /// Type for the 8th argument. + /// Type for the 9th argument. + /// Type for the 10th argument. + /// Type for the 11th argument. + /// Type for the 12th argument. + /// Type for the 13th argument. + public interface ITestAsyncMethodWithParameterValidation< + in TArg1, + in TArg2, + in TArg3, + in TArg4, + in TArg5, + in TArg6, + in TArg7, + in TArg8, + in TArg9, + in TArg10, + in TArg11, + in TArg12, + in TArg13> + { + /// + /// Check to ensure parameters requiring validation throw . + /// + /// The 1st argument that takes validation. + /// The 2nd argument that takes validation. + /// The 3rd argument that takes validation. + /// The 4th argument that takes validation. + /// The 5th argument that takes validation. + /// The 6th argument that takes validation. + /// The 7th argument that takes validation. + /// The 8th argument that takes validation. + /// The 9th argument that takes validation. + /// The 10th argument that takes validation. + /// The 11th argument that takes validation. + /// The 12th argument that takes validation. + /// The 13th argument that takes validation. + /// + /// The name of the parameter expected to throw an exception. + /// + /// + /// A representing the asynchronous operation. + /// + Task ThrowsArgumentExceptionAsync( + TArg1 arg1, + TArg2 arg2, + TArg3 arg3, + TArg4 arg4, + TArg5 arg5, + TArg6 arg6, + TArg7 arg7, + TArg8 arg8, + TArg9 arg9, + TArg10 arg10, + TArg11 arg11, + TArg12 arg12, + TArg13 arg13, + string expectedParameterNameForException); + } +} diff --git a/src/NetTestRegimentation/ITestAsyncMethodWithParameterValidation{TArg1,TArg2,TArg3,TArg4,TArg5,TArg6,TArg7,TArg8,TArg9,TArg10,TArg11,TArg12}.cs b/src/NetTestRegimentation/ITestAsyncMethodWithParameterValidation{TArg1,TArg2,TArg3,TArg4,TArg5,TArg6,TArg7,TArg8,TArg9,TArg10,TArg11,TArg12}.cs new file mode 100644 index 0000000..7f797d5 --- /dev/null +++ b/src/NetTestRegimentation/ITestAsyncMethodWithParameterValidation{TArg1,TArg2,TArg3,TArg4,TArg5,TArg6,TArg7,TArg8,TArg9,TArg10,TArg11,TArg12}.cs @@ -0,0 +1,74 @@ +// Copyright (c) 2019 dpvreony and Contributors. All rights reserved. +// This file is licensed to you under the MIT license. +// See the LICENSE file in the project root for full license information. + +using System.Threading.Tasks; + +namespace NetTestRegimentation +{ + /// + /// Unit Tests for Async Methods that contain 12 parameters that need validation. + /// + /// Type for the 1st argument. + /// Type for the 2nd argument. + /// Type for the 3rd argument. + /// Type for the 4th argument. + /// Type for the 5th argument. + /// Type for the 6th argument. + /// Type for the 7th argument. + /// Type for the 8th argument. + /// Type for the 9th argument. + /// Type for the 10th argument. + /// Type for the 11th argument. + /// Type for the 12th argument. + public interface ITestAsyncMethodWithParameterValidation< + in TArg1, + in TArg2, + in TArg3, + in TArg4, + in TArg5, + in TArg6, + in TArg7, + in TArg8, + in TArg9, + in TArg10, + in TArg11, + in TArg12> + { + /// + /// Check to ensure parameters requiring validation throw . + /// + /// The 1st argument that takes validation. + /// The 2nd argument that takes validation. + /// The 3rd argument that takes validation. + /// The 4th argument that takes validation. + /// The 5th argument that takes validation. + /// The 6th argument that takes validation. + /// The 7th argument that takes validation. + /// The 8th argument that takes validation. + /// The 9th argument that takes validation. + /// The 10th argument that takes validation. + /// The 11th argument that takes validation. + /// The 12th argument that takes validation. + /// + /// The name of the parameter expected to throw an exception. + /// + /// + /// A representing the asynchronous operation. + /// + Task ThrowsArgumentExceptionAsync( + TArg1 arg1, + TArg2 arg2, + TArg3 arg3, + TArg4 arg4, + TArg5 arg5, + TArg6 arg6, + TArg7 arg7, + TArg8 arg8, + TArg9 arg9, + TArg10 arg10, + TArg11 arg11, + TArg12 arg12, + string expectedParameterNameForException); + } +} diff --git a/src/NetTestRegimentation/ITestAsyncMethodWithParameterValidation{TArg1,TArg2,TArg3,TArg4,TArg5,TArg6,TArg7,TArg8,TArg9,TArg10,TArg11}.cs b/src/NetTestRegimentation/ITestAsyncMethodWithParameterValidation{TArg1,TArg2,TArg3,TArg4,TArg5,TArg6,TArg7,TArg8,TArg9,TArg10,TArg11}.cs new file mode 100644 index 0000000..612e214 --- /dev/null +++ b/src/NetTestRegimentation/ITestAsyncMethodWithParameterValidation{TArg1,TArg2,TArg3,TArg4,TArg5,TArg6,TArg7,TArg8,TArg9,TArg10,TArg11}.cs @@ -0,0 +1,70 @@ +// Copyright (c) 2019 dpvreony and Contributors. All rights reserved. +// This file is licensed to you under the MIT license. +// See the LICENSE file in the project root for full license information. + +using System.Threading.Tasks; + +namespace NetTestRegimentation +{ + /// + /// Unit Tests for Async Methods that contain 11 parameters that need validation. + /// + /// Type for the 1st argument. + /// Type for the 2nd argument. + /// Type for the 3rd argument. + /// Type for the 4th argument. + /// Type for the 5th argument. + /// Type for the 6th argument. + /// Type for the 7th argument. + /// Type for the 8th argument. + /// Type for the 9th argument. + /// Type for the 10th argument. + /// Type for the 11th argument. + public interface ITestAsyncMethodWithParameterValidation< + in TArg1, + in TArg2, + in TArg3, + in TArg4, + in TArg5, + in TArg6, + in TArg7, + in TArg8, + in TArg9, + in TArg10, + in TArg11> + { + /// + /// Check to ensure parameters requiring validation throw . + /// + /// The 1st argument that takes validation. + /// The 2nd argument that takes validation. + /// The 3rd argument that takes validation. + /// The 4th argument that takes validation. + /// The 5th argument that takes validation. + /// The 6th argument that takes validation. + /// The 7th argument that takes validation. + /// The 8th argument that takes validation. + /// The 9th argument that takes validation. + /// The 10th argument that takes validation. + /// The 11th argument that takes validation. + /// + /// The name of the parameter expected to throw an exception. + /// + /// + /// A representing the asynchronous operation. + /// + Task ThrowsArgumentExceptionAsync( + TArg1 arg1, + TArg2 arg2, + TArg3 arg3, + TArg4 arg4, + TArg5 arg5, + TArg6 arg6, + TArg7 arg7, + TArg8 arg8, + TArg9 arg9, + TArg10 arg10, + TArg11 arg11, + string expectedParameterNameForException); + } +} diff --git a/src/NetTestRegimentation/ITestAsyncMethodWithParameterValidation{TArg1,TArg2,TArg3,TArg4,TArg5,TArg6,TArg7,TArg8,TArg9,TArg10}.cs b/src/NetTestRegimentation/ITestAsyncMethodWithParameterValidation{TArg1,TArg2,TArg3,TArg4,TArg5,TArg6,TArg7,TArg8,TArg9,TArg10}.cs new file mode 100644 index 0000000..d0dc8fe --- /dev/null +++ b/src/NetTestRegimentation/ITestAsyncMethodWithParameterValidation{TArg1,TArg2,TArg3,TArg4,TArg5,TArg6,TArg7,TArg8,TArg9,TArg10}.cs @@ -0,0 +1,66 @@ +// Copyright (c) 2019 dpvreony and Contributors. All rights reserved. +// This file is licensed to you under the MIT license. +// See the LICENSE file in the project root for full license information. + +using System.Threading.Tasks; + +namespace NetTestRegimentation +{ + /// + /// Unit Tests for Async Methods that contain 10 parameters that need validation. + /// + /// Type for the 1st argument. + /// Type for the 2nd argument. + /// Type for the 3rd argument. + /// Type for the 4th argument. + /// Type for the 5th argument. + /// Type for the 6th argument. + /// Type for the 7th argument. + /// Type for the 8th argument. + /// Type for the 9th argument. + /// Type for the 10th argument. + public interface ITestAsyncMethodWithParameterValidation< + in TArg1, + in TArg2, + in TArg3, + in TArg4, + in TArg5, + in TArg6, + in TArg7, + in TArg8, + in TArg9, + in TArg10> + { + /// + /// Check to ensure parameters requiring validation throw . + /// + /// The 1st argument that takes validation. + /// The 2nd argument that takes validation. + /// The 3rd argument that takes validation. + /// The 4th argument that takes validation. + /// The 5th argument that takes validation. + /// The 6th argument that takes validation. + /// The 7th argument that takes validation. + /// The 8th argument that takes validation. + /// The 9th argument that takes validation. + /// The 10th argument that takes validation. + /// + /// The name of the parameter expected to throw an exception. + /// + /// + /// A representing the asynchronous operation. + /// + Task ThrowsArgumentExceptionAsync( + TArg1 arg1, + TArg2 arg2, + TArg3 arg3, + TArg4 arg4, + TArg5 arg5, + TArg6 arg6, + TArg7 arg7, + TArg8 arg8, + TArg9 arg9, + TArg10 arg10, + string expectedParameterNameForException); + } +} diff --git a/src/NetTestRegimentation/ITestAsyncMethodWithParameterValidation{TArg1,TArg2,TArg3,TArg4,TArg5,TArg6,TArg7,TArg8,TArg9}.cs b/src/NetTestRegimentation/ITestAsyncMethodWithParameterValidation{TArg1,TArg2,TArg3,TArg4,TArg5,TArg6,TArg7,TArg8,TArg9}.cs new file mode 100644 index 0000000..762c728 --- /dev/null +++ b/src/NetTestRegimentation/ITestAsyncMethodWithParameterValidation{TArg1,TArg2,TArg3,TArg4,TArg5,TArg6,TArg7,TArg8,TArg9}.cs @@ -0,0 +1,62 @@ +// Copyright (c) 2019 dpvreony and Contributors. All rights reserved. +// This file is licensed to you under the MIT license. +// See the LICENSE file in the project root for full license information. + +using System.Threading.Tasks; + +namespace NetTestRegimentation +{ + /// + /// Unit Tests for Async Methods that contain 9 parameters that need validation. + /// + /// Type for the 1st argument. + /// Type for the 2nd argument. + /// Type for the 3rd argument. + /// Type for the 4th argument. + /// Type for the 5th argument. + /// Type for the 6th argument. + /// Type for the 7th argument. + /// Type for the 8th argument. + /// Type for the 9th argument. + public interface ITestAsyncMethodWithParameterValidation< + in TArg1, + in TArg2, + in TArg3, + in TArg4, + in TArg5, + in TArg6, + in TArg7, + in TArg8, + in TArg9> + { + /// + /// Check to ensure parameters requiring validation throw . + /// + /// The 1st argument that takes validation. + /// The 2nd argument that takes validation. + /// The 3rd argument that takes validation. + /// The 4th argument that takes validation. + /// The 5th argument that takes validation. + /// The 6th argument that takes validation. + /// The 7th argument that takes validation. + /// The 8th argument that takes validation. + /// The 9th argument that takes validation. + /// + /// The name of the parameter expected to throw an exception. + /// + /// + /// A representing the asynchronous operation. + /// + Task ThrowsArgumentExceptionAsync( + TArg1 arg1, + TArg2 arg2, + TArg3 arg3, + TArg4 arg4, + TArg5 arg5, + TArg6 arg6, + TArg7 arg7, + TArg8 arg8, + TArg9 arg9, + string expectedParameterNameForException); + } +} diff --git a/src/NetTestRegimentation/ITestAsyncMethodWithParameterValidation{TArg1,TArg2,TArg3,TArg4,TArg5,TArg6,TArg7,TArg8}.cs b/src/NetTestRegimentation/ITestAsyncMethodWithParameterValidation{TArg1,TArg2,TArg3,TArg4,TArg5,TArg6,TArg7,TArg8}.cs new file mode 100644 index 0000000..36b150c --- /dev/null +++ b/src/NetTestRegimentation/ITestAsyncMethodWithParameterValidation{TArg1,TArg2,TArg3,TArg4,TArg5,TArg6,TArg7,TArg8}.cs @@ -0,0 +1,50 @@ +// Copyright (c) 2019 dpvreony and Contributors. All rights reserved. +// This file is licensed to you under the MIT license. +// See the LICENSE file in the project root for full license information. + +using System.Threading.Tasks; + +namespace NetTestRegimentation +{ + /// + /// Unit Tests for Async Methods that contain 8 parameters that need validation. + /// + /// Type for the 1st argument. + /// Type for the 2nd argument. + /// Type for the 3rd argument. + /// Type for the 4th argument. + /// Type for the 5th argument. + /// Type for the 6th argument. + /// Type for the 7th argument. + /// Type for the 8th argument. + public interface ITestAsyncMethodWithParameterValidation + { + /// + /// Check to ensure parameters requiring validation throw . + /// + /// The 1st argument that takes validation. + /// The 2nd argument that takes validation. + /// The 3rd argument that takes validation. + /// The 4th argument that takes validation. + /// The 5th argument that takes validation. + /// The 6th argument that takes validation. + /// The 7th argument that takes validation. + /// The 8th argument that takes validation. + /// + /// The name of the parameter expected to throw an exception. + /// + /// + /// A representing the asynchronous operation. + /// + Task ThrowsArgumentExceptionAsync( + TArg1 arg1, + TArg2 arg2, + TArg3 arg3, + TArg4 arg4, + TArg5 arg5, + TArg6 arg6, + TArg7 arg7, + TArg8 arg8, + string expectedParameterNameForException); + } +} diff --git a/src/NetTestRegimentation/ITestAsyncMethodWithParameterValidation{TArg1,TArg2,TArg3,TArg4,TArg5,TArg6,TArg7}.cs b/src/NetTestRegimentation/ITestAsyncMethodWithParameterValidation{TArg1,TArg2,TArg3,TArg4,TArg5,TArg6,TArg7}.cs new file mode 100644 index 0000000..29832a8 --- /dev/null +++ b/src/NetTestRegimentation/ITestAsyncMethodWithParameterValidation{TArg1,TArg2,TArg3,TArg4,TArg5,TArg6,TArg7}.cs @@ -0,0 +1,47 @@ +// Copyright (c) 2019 dpvreony and Contributors. All rights reserved. +// This file is licensed to you under the MIT license. +// See the LICENSE file in the project root for full license information. + +using System.Threading.Tasks; + +namespace NetTestRegimentation +{ + /// + /// Unit Tests for Async Methods that contain 7 parameters that need validation. + /// + /// Type for the 1st argument. + /// Type for the 2nd argument. + /// Type for the 3rd argument. + /// Type for the 4th argument. + /// Type for the 5th argument. + /// Type for the 6th argument. + /// Type for the 7th argument. + public interface ITestAsyncMethodWithParameterValidation + { + /// + /// Check to ensure parameters requiring validation throw . + /// + /// The 1st argument that takes validation. + /// The 2nd argument that takes validation. + /// The 3rd argument that takes validation. + /// The 4th argument that takes validation. + /// The 5th argument that takes validation. + /// The 6th argument that takes validation. + /// The 7th argument that takes validation. + /// + /// The name of the parameter expected to throw an exception. + /// + /// + /// A representing the asynchronous operation. + /// + Task ThrowsArgumentExceptionAsync( + TArg1 arg1, + TArg2 arg2, + TArg3 arg3, + TArg4 arg4, + TArg5 arg5, + TArg6 arg6, + TArg7 arg7, + string expectedParameterNameForException); + } +} diff --git a/src/NetTestRegimentation/ITestAsyncMethodWithParameterValidation{TArg1,TArg2,TArg3,TArg4,TArg5,TArg6}.cs b/src/NetTestRegimentation/ITestAsyncMethodWithParameterValidation{TArg1,TArg2,TArg3,TArg4,TArg5,TArg6}.cs new file mode 100644 index 0000000..a3c970a --- /dev/null +++ b/src/NetTestRegimentation/ITestAsyncMethodWithParameterValidation{TArg1,TArg2,TArg3,TArg4,TArg5,TArg6}.cs @@ -0,0 +1,44 @@ +// Copyright (c) 2019 dpvreony and Contributors. All rights reserved. +// This file is licensed to you under the MIT license. +// See the LICENSE file in the project root for full license information. + +using System.Threading.Tasks; + +namespace NetTestRegimentation +{ + /// + /// Unit Tests for Async Methods that contain 6 parameters that need validation. + /// + /// Type for the 1st argument. + /// Type for the 2nd argument. + /// Type for the 3rd argument. + /// Type for the 4th argument. + /// Type for the 5th argument. + /// Type for the 6th argument. + public interface ITestAsyncMethodWithParameterValidation + { + /// + /// Check to ensure parameters requiring validation throw . + /// + /// The 1st argument that takes validation. + /// The 2nd argument that takes validation. + /// The 3rd argument that takes validation. + /// The 4th argument that takes validation. + /// The 5th argument that takes validation. + /// The 6th argument that takes validation. + /// + /// The name of the parameter expected to throw an exception. + /// + /// + /// A representing the asynchronous operation. + /// + Task ThrowsArgumentExceptionAsync( + TArg1 arg1, + TArg2 arg2, + TArg3 arg3, + TArg4 arg4, + TArg5 arg5, + TArg6 arg6, + string expectedParameterNameForException); + } +} diff --git a/src/NetTestRegimentation/ITestAsyncMethodWithParameterValidation{TArg1,TArg2,TArg3,TArg4,TArg5}.cs b/src/NetTestRegimentation/ITestAsyncMethodWithParameterValidation{TArg1,TArg2,TArg3,TArg4,TArg5}.cs new file mode 100644 index 0000000..4589ba0 --- /dev/null +++ b/src/NetTestRegimentation/ITestAsyncMethodWithParameterValidation{TArg1,TArg2,TArg3,TArg4,TArg5}.cs @@ -0,0 +1,41 @@ +// Copyright (c) 2019 dpvreony and Contributors. All rights reserved. +// This file is licensed to you under the MIT license. +// See the LICENSE file in the project root for full license information. + +using System.Threading.Tasks; + +namespace NetTestRegimentation +{ + /// + /// Unit Tests for Async Methods that contain 5 parameters that need validation. + /// + /// Type for the 1st argument. + /// Type for the 2nd argument. + /// Type for the 3rd argument. + /// Type for the 4th argument. + /// Type for the 5th argument. + public interface ITestAsyncMethodWithParameterValidation + { + /// + /// Check to ensure parameters requiring validation throw . + /// + /// The 1st argument that takes validation. + /// The 2nd argument that takes validation. + /// The 3rd argument that takes validation. + /// The 4th argument that takes validation. + /// The 5th argument that takes validation. + /// + /// The name of the parameter expected to throw an exception. + /// + /// + /// A representing the asynchronous operation. + /// + Task ThrowsArgumentExceptionAsync( + TArg1 arg1, + TArg2 arg2, + TArg3 arg3, + TArg4 arg4, + TArg5 arg5, + string expectedParameterNameForException); + } +} diff --git a/src/NetTestRegimentation/ITestAsyncMethodWithParameterValidation{TArg1,TArg2,TArg3,TArg4}.cs b/src/NetTestRegimentation/ITestAsyncMethodWithParameterValidation{TArg1,TArg2,TArg3,TArg4}.cs new file mode 100644 index 0000000..dfd673e --- /dev/null +++ b/src/NetTestRegimentation/ITestAsyncMethodWithParameterValidation{TArg1,TArg2,TArg3,TArg4}.cs @@ -0,0 +1,38 @@ +// Copyright (c) 2019 dpvreony and Contributors. All rights reserved. +// This file is licensed to you under the MIT license. +// See the LICENSE file in the project root for full license information. + +using System.Threading.Tasks; + +namespace NetTestRegimentation +{ + /// + /// Unit Tests for Async Methods that contain 4 parameters that need validation. + /// + /// Type for the 1st argument. + /// Type for the 2nd argument. + /// Type for the 3rd argument. + /// Type for the 4th argument. + public interface ITestAsyncMethodWithParameterValidation + { + /// + /// Check to ensure parameters requiring validation throw . + /// + /// The 1st argument that takes validation. + /// The 2nd argument that takes validation. + /// The 3rd argument that takes validation. + /// The 4th argument that takes validation. + /// + /// The name of the parameter expected to throw an exception. + /// + /// + /// A representing the asynchronous operation. + /// + Task ThrowsArgumentExceptionAsync( + TArg1 arg1, + TArg2 arg2, + TArg3 arg3, + TArg4 arg4, + string expectedParameterNameForException); + } +} diff --git a/src/NetTestRegimentation/ITestAsyncMethodWithParameterValidation{TArg1,TArg2,TArg3}.cs b/src/NetTestRegimentation/ITestAsyncMethodWithParameterValidation{TArg1,TArg2,TArg3}.cs new file mode 100644 index 0000000..e449bc1 --- /dev/null +++ b/src/NetTestRegimentation/ITestAsyncMethodWithParameterValidation{TArg1,TArg2,TArg3}.cs @@ -0,0 +1,35 @@ +// Copyright (c) 2019 dpvreony and Contributors. All rights reserved. +// This file is licensed to you under the MIT license. +// See the LICENSE file in the project root for full license information. + +using System.Threading.Tasks; + +namespace NetTestRegimentation +{ + /// + /// Unit Tests for Async Methods that contain 3 parameters that need validation. + /// + /// Type for the 1st argument. + /// Type for the 2nd argument. + /// Type for the 3rd argument. + public interface ITestAsyncMethodWithParameterValidation + { + /// + /// Check to ensure parameters requiring validation throw . + /// + /// The 1st argument that takes validation. + /// The 2nd argument that takes validation. + /// The 3rd argument that takes validation. + /// + /// The name of the parameter expected to throw an exception. + /// + /// + /// A representing the asynchronous operation. + /// + Task ThrowsArgumentExceptionAsync( + TArg1 arg1, + TArg2 arg2, + TArg3 arg3, + string expectedParameterNameForException); + } +} diff --git a/src/NetTestRegimentation/ITestAsyncMethodWithParameterValidation{TArg1,TArg2}.cs b/src/NetTestRegimentation/ITestAsyncMethodWithParameterValidation{TArg1,TArg2}.cs new file mode 100644 index 0000000..3c1c2d6 --- /dev/null +++ b/src/NetTestRegimentation/ITestAsyncMethodWithParameterValidation{TArg1,TArg2}.cs @@ -0,0 +1,32 @@ +// Copyright (c) 2019 dpvreony and Contributors. All rights reserved. +// This file is licensed to you under the MIT license. +// See the LICENSE file in the project root for full license information. + +using System.Threading.Tasks; + +namespace NetTestRegimentation +{ + /// + /// Unit Tests for Async Methods that contain 2 parameters that need validation. + /// + /// Type for the 1st argument. + /// Type for the 2nd argument. + public interface ITestAsyncMethodWithParameterValidation + { + /// + /// Check to ensure parameters requiring validation throw . + /// + /// The 1st argument that takes validation. + /// The 2nd argument that takes validation. + /// + /// The name of the parameter expected to throw an exception. + /// + /// + /// A representing the asynchronous operation. + /// + Task ThrowsArgumentExceptionAsync( + TArg1 arg1, + TArg2 arg2, + string expectedParameterNameForException); + } +} diff --git a/src/NetTestRegimentation/ITestAsyncMethodWithParameterValidation{TArg}.cs b/src/NetTestRegimentation/ITestAsyncMethodWithParameterValidation{TArg}.cs new file mode 100644 index 0000000..d5add78 --- /dev/null +++ b/src/NetTestRegimentation/ITestAsyncMethodWithParameterValidation{TArg}.cs @@ -0,0 +1,29 @@ +// Copyright (c) 2019 dpvreony and Contributors. All rights reserved. +// This file is licensed to you under the MIT license. +// See the LICENSE file in the project root for full license information. + +using System.Threading.Tasks; + +namespace NetTestRegimentation +{ + /// + /// Unit Tests for Async Methods that contain 1 parameter that need validation. + /// + /// Type for the argument. + public interface ITestAsyncMethodWithParameterValidation + { + /// + /// Check to ensure parameters requiring validation throw . + /// + /// The argument that takes validation. + /// + /// The name of the parameter expected to throw an exception. + /// + /// + /// A representing the asynchronous operation. + /// + Task ThrowsArgumentExceptionAsync( + TArg arg, + string expectedParameterNameForException); + } +} diff --git a/src/NetTestRegimentation/ITestAsyncMethodWithRangeParameters.cs b/src/NetTestRegimentation/ITestAsyncMethodWithRangeParameters.cs index fad812f..c5ba2bf 100644 --- a/src/NetTestRegimentation/ITestAsyncMethodWithRangeParameters.cs +++ b/src/NetTestRegimentation/ITestAsyncMethodWithRangeParameters.cs @@ -1,24 +1,77 @@ +// Copyright (c) 2019 dpvreony and Contributors. All rights reserved. +// This file is licensed to you under the MIT license. +// See the LICENSE file in the project root for full license information. + using System.Threading.Tasks; namespace NetTestRegimentation { +#pragma warning disable SA1402 // File may only contain a single type + /// + /// Unit Tests for Async Methods that contain 1 parameter that needs range validation. + /// + /// Type for the argument. public interface ITestAsyncMethodWithRangeParameters { + /// + /// Check to ensure parameters requiring validation throw . + /// + /// The 1st argument that takes validation. + /// + /// The name of the parameter expected to throw an exception. + /// + /// + /// A representing the asynchronous operation. + /// Task ThrowsArgumentOutOfRangeExceptionAsync( TArg arg, string expectedParameterNameForException); } + /// + /// Unit Tests for Async Methods that contain 2 parameters that need range validation. + /// + /// Type for the 1st argument. + /// Type for the 2nd argument. public interface ITestAsyncMethodWithRangeParameters { + /// + /// Check to ensure parameters requiring validation throw . + /// + /// The 1st argument that takes validation. + /// The 2nd argument that takes validation. + /// + /// The name of the parameter expected to throw an exception. + /// + /// + /// A representing the asynchronous operation. + /// Task ThrowsArgumentOutOfRangeExceptionAsync( TArg1 arg1, TArg2 arg2, string expectedParameterNameForException); } + /// + /// Unit Tests for Async Methods that contain 3 parameters that need range validation. + /// + /// Type for the 1st argument. + /// Type for the 2nd argument. + /// Type for the 3rd argument. public interface ITestAsyncMethodWithRangeParameters { + /// + /// Check to ensure parameters requiring validation throw . + /// + /// The 1st argument that takes validation. + /// The 2nd argument that takes validation. + /// The 3rd argument that takes validation. + /// + /// The name of the parameter expected to throw an exception. + /// + /// + /// A representing the asynchronous operation. + /// Task ThrowsArgumentOutOfRangeExceptionAsync( TArg1 arg1, TArg2 arg2, @@ -26,8 +79,28 @@ Task ThrowsArgumentOutOfRangeExceptionAsync( string expectedParameterNameForException); } + /// + /// Unit Tests for Async Methods that contain 4 parameters that need range validation. + /// + /// Type for the 1st argument. + /// Type for the 2nd argument. + /// Type for the 3rd argument. + /// Type for the 4th argument. public interface ITestAsyncMethodWithRangeParameters { + /// + /// Check to ensure parameters requiring validation throw . + /// + /// The 1st argument that takes validation. + /// The 2nd argument that takes validation. + /// The 3rd argument that takes validation. + /// The 4th argument that takes validation. + /// + /// The name of the parameter expected to throw an exception. + /// + /// + /// A representing the asynchronous operation. + /// Task ThrowsArgumentOutOfRangeExceptionAsync( TArg1 arg1, TArg2 arg2, @@ -36,8 +109,30 @@ Task ThrowsArgumentOutOfRangeExceptionAsync( string expectedParameterNameForException); } + /// + /// Unit Tests for Async Methods that contain 5 parameters that need range validation. + /// + /// Type for the 1st argument. + /// Type for the 2nd argument. + /// Type for the 3rd argument. + /// Type for the 4th argument. + /// Type for the 5th argument. public interface ITestAsyncMethodWithRangeParameters { + /// + /// Check to ensure parameters requiring validation throw . + /// + /// The 1st argument that takes validation. + /// The 2nd argument that takes validation. + /// The 3rd argument that takes validation. + /// The 4th argument that takes validation. + /// The 5th argument that takes validation. + /// + /// The name of the parameter expected to throw an exception. + /// + /// + /// A representing the asynchronous operation. + /// Task ThrowsArgumentOutOfRangeExceptionAsync( TArg1 arg1, TArg2 arg2, @@ -47,8 +142,32 @@ Task ThrowsArgumentOutOfRangeExceptionAsync( string expectedParameterNameForException); } + /// + /// Unit Tests for Async Methods that contain 6 parameters that need range validation. + /// + /// Type for the 1st argument. + /// Type for the 2nd argument. + /// Type for the 3rd argument. + /// Type for the 4th argument. + /// Type for the 5th argument. + /// Type for the 6th argument. public interface ITestAsyncMethodWithRangeParameters { + /// + /// Check to ensure parameters requiring validation throw . + /// + /// The 1st argument that takes validation. + /// The 2nd argument that takes validation. + /// The 3rd argument that takes validation. + /// The 4th argument that takes validation. + /// The 5th argument that takes validation. + /// The 6th argument that takes validation. + /// + /// The name of the parameter expected to throw an exception. + /// + /// + /// A representing the asynchronous operation. + /// Task ThrowsArgumentOutOfRangeExceptionAsync( TArg1 arg1, TArg2 arg2, @@ -59,8 +178,34 @@ Task ThrowsArgumentOutOfRangeExceptionAsync( string expectedParameterNameForException); } + /// + /// Unit Tests for Async Methods that contain 7 parameters that need range validation. + /// + /// Type for the 1st argument. + /// Type for the 2nd argument. + /// Type for the 3rd argument. + /// Type for the 4th argument. + /// Type for the 5th argument. + /// Type for the 6th argument. + /// Type for the 7th argument. public interface ITestAsyncMethodWithRangeParameters { + /// + /// Check to ensure parameters requiring validation throw . + /// + /// The 1st argument that takes validation. + /// The 2nd argument that takes validation. + /// The 3rd argument that takes validation. + /// The 4th argument that takes validation. + /// The 5th argument that takes validation. + /// The 6th argument that takes validation. + /// The 7th argument that takes validation. + /// + /// The name of the parameter expected to throw an exception. + /// + /// + /// A representing the asynchronous operation. + /// Task ThrowsArgumentOutOfRangeExceptionAsync( TArg1 arg1, TArg2 arg2, @@ -72,8 +217,36 @@ Task ThrowsArgumentOutOfRangeExceptionAsync( string expectedParameterNameForException); } + /// + /// Unit Tests for Async Methods that contain 16 parameters that need range validation. + /// + /// Type for the 1st argument. + /// Type for the 2nd argument. + /// Type for the 3rd argument. + /// Type for the 4th argument. + /// Type for the 5th argument. + /// Type for the 6th argument. + /// Type for the 7th argument. + /// Type for the 8th argument. public interface ITestAsyncMethodWithRangeParameters { + /// + /// Check to ensure parameters requiring validation throw . + /// + /// The 1st argument that takes validation. + /// The 2nd argument that takes validation. + /// The 3rd argument that takes validation. + /// The 4th argument that takes validation. + /// The 5th argument that takes validation. + /// The 6th argument that takes validation. + /// The 7th argument that takes validation. + /// The 8th argument that takes validation. + /// + /// The name of the parameter expected to throw an exception. + /// + /// + /// A representing the asynchronous operation. + /// Task ThrowsArgumentOutOfRangeExceptionAsync( TArg1 arg1, TArg2 arg2, @@ -86,6 +259,18 @@ Task ThrowsArgumentOutOfRangeExceptionAsync( string expectedParameterNameForException); } + /// + /// Unit Tests for Async Methods that contain 16 parameters that need range validation. + /// + /// Type for the 1st argument. + /// Type for the 2nd argument. + /// Type for the 3rd argument. + /// Type for the 4th argument. + /// Type for the 5th argument. + /// Type for the 6th argument. + /// Type for the 7th argument. + /// Type for the 8th argument. + /// Type for the 9th argument. public interface ITestAsyncMethodWithRangeParameters< in TArg1, in TArg2, @@ -97,6 +282,24 @@ public interface ITestAsyncMethodWithRangeParameters< in TArg8, in TArg9> { + /// + /// Check to ensure parameters requiring validation throw . + /// + /// The 1st argument that takes validation. + /// The 2nd argument that takes validation. + /// The 3rd argument that takes validation. + /// The 4th argument that takes validation. + /// The 5th argument that takes validation. + /// The 6th argument that takes validation. + /// The 7th argument that takes validation. + /// The 8th argument that takes validation. + /// The 9th argument that takes validation. + /// + /// The name of the parameter expected to throw an exception. + /// + /// + /// A representing the asynchronous operation. + /// Task ThrowsArgumentOutOfRangeExceptionAsync( TArg1 arg1, TArg2 arg2, @@ -110,6 +313,19 @@ Task ThrowsArgumentOutOfRangeExceptionAsync( string expectedParameterNameForException); } + /// + /// Unit Tests for Async Methods that contain 16 parameters that need range validation. + /// + /// Type for the 1st argument. + /// Type for the 2nd argument. + /// Type for the 3rd argument. + /// Type for the 4th argument. + /// Type for the 5th argument. + /// Type for the 6th argument. + /// Type for the 7th argument. + /// Type for the 8th argument. + /// Type for the 9th argument. + /// Type for the 10th argument. public interface ITestAsyncMethodWithRangeParameters< in TArg1, in TArg2, @@ -122,6 +338,25 @@ public interface ITestAsyncMethodWithRangeParameters< in TArg9, in TArg10> { + /// + /// Check to ensure parameters requiring validation throw . + /// + /// The 1st argument that takes validation. + /// The 2nd argument that takes validation. + /// The 3rd argument that takes validation. + /// The 4th argument that takes validation. + /// The 5th argument that takes validation. + /// The 6th argument that takes validation. + /// The 7th argument that takes validation. + /// The 8th argument that takes validation. + /// The 9th argument that takes validation. + /// The 10th argument that takes validation. + /// + /// The name of the parameter expected to throw an exception. + /// + /// + /// A representing the asynchronous operation. + /// Task ThrowsArgumentOutOfRangeExceptionAsync( TArg1 arg1, TArg2 arg2, @@ -136,6 +371,20 @@ Task ThrowsArgumentOutOfRangeExceptionAsync( string expectedParameterNameForException); } + /// + /// Unit Tests for Async Methods that contain 16 parameters that need range validation. + /// + /// Type for the 1st argument. + /// Type for the 2nd argument. + /// Type for the 3rd argument. + /// Type for the 4th argument. + /// Type for the 5th argument. + /// Type for the 6th argument. + /// Type for the 7th argument. + /// Type for the 8th argument. + /// Type for the 9th argument. + /// Type for the 10th argument. + /// Type for the 11th argument. public interface ITestAsyncMethodWithRangeParameters< in TArg1, in TArg2, @@ -149,6 +398,26 @@ public interface ITestAsyncMethodWithRangeParameters< in TArg10, in TArg11> { + /// + /// Check to ensure parameters requiring validation throw . + /// + /// The 1st argument that takes validation. + /// The 2nd argument that takes validation. + /// The 3rd argument that takes validation. + /// The 4th argument that takes validation. + /// The 5th argument that takes validation. + /// The 6th argument that takes validation. + /// The 7th argument that takes validation. + /// The 8th argument that takes validation. + /// The 9th argument that takes validation. + /// The 10th argument that takes validation. + /// The 11th argument that takes validation. + /// + /// The name of the parameter expected to throw an exception. + /// + /// + /// A representing the asynchronous operation. + /// Task ThrowsArgumentOutOfRangeExceptionAsync( TArg1 arg1, TArg2 arg2, @@ -164,6 +433,21 @@ Task ThrowsArgumentOutOfRangeExceptionAsync( string expectedParameterNameForException); } + /// + /// Unit Tests for Async Methods that contain 16 parameters that need range validation. + /// + /// Type for the 1st argument. + /// Type for the 2nd argument. + /// Type for the 3rd argument. + /// Type for the 4th argument. + /// Type for the 5th argument. + /// Type for the 6th argument. + /// Type for the 7th argument. + /// Type for the 8th argument. + /// Type for the 9th argument. + /// Type for the 10th argument. + /// Type for the 11th argument. + /// Type for the 12th argument. public interface ITestAsyncMethodWithRangeParameters< in TArg1, in TArg2, @@ -178,6 +462,27 @@ public interface ITestAsyncMethodWithRangeParameters< in TArg11, in TArg12> { + /// + /// Check to ensure parameters requiring validation throw . + /// + /// The 1st argument that takes validation. + /// The 2nd argument that takes validation. + /// The 3rd argument that takes validation. + /// The 4th argument that takes validation. + /// The 5th argument that takes validation. + /// The 6th argument that takes validation. + /// The 7th argument that takes validation. + /// The 8th argument that takes validation. + /// The 9th argument that takes validation. + /// The 10th argument that takes validation. + /// The 11th argument that takes validation. + /// The 12th argument that takes validation. + /// + /// The name of the parameter expected to throw an exception. + /// + /// + /// A representing the asynchronous operation. + /// Task ThrowsArgumentOutOfRangeExceptionAsync( TArg1 arg1, TArg2 arg2, @@ -194,6 +499,22 @@ Task ThrowsArgumentOutOfRangeExceptionAsync( string expectedParameterNameForException); } + /// + /// Unit Tests for Async Methods that contain 16 parameters that need range validation. + /// + /// Type for the 1st argument. + /// Type for the 2nd argument. + /// Type for the 3rd argument. + /// Type for the 4th argument. + /// Type for the 5th argument. + /// Type for the 6th argument. + /// Type for the 7th argument. + /// Type for the 8th argument. + /// Type for the 9th argument. + /// Type for the 10th argument. + /// Type for the 11th argument. + /// Type for the 12th argument. + /// Type for the 13th argument. public interface ITestAsyncMethodWithRangeParameters< in TArg1, in TArg2, @@ -209,6 +530,28 @@ public interface ITestAsyncMethodWithRangeParameters< in TArg12, in TArg13> { + /// + /// Check to ensure parameters requiring validation throw . + /// + /// The 1st argument that takes validation. + /// The 2nd argument that takes validation. + /// The 3rd argument that takes validation. + /// The 4th argument that takes validation. + /// The 5th argument that takes validation. + /// The 6th argument that takes validation. + /// The 7th argument that takes validation. + /// The 8th argument that takes validation. + /// The 9th argument that takes validation. + /// The 10th argument that takes validation. + /// The 11th argument that takes validation. + /// The 12th argument that takes validation. + /// The 13th argument that takes validation. + /// + /// The name of the parameter expected to throw an exception. + /// + /// + /// A representing the asynchronous operation. + /// Task ThrowsArgumentOutOfRangeExceptionAsync( TArg1 arg1, TArg2 arg2, @@ -226,6 +569,23 @@ Task ThrowsArgumentOutOfRangeExceptionAsync( string expectedParameterNameForException); } + /// + /// Unit Tests for Async Methods that contain 16 parameters that need range validation. + /// + /// Type for the 1st argument. + /// Type for the 2nd argument. + /// Type for the 3rd argument. + /// Type for the 4th argument. + /// Type for the 5th argument. + /// Type for the 6th argument. + /// Type for the 7th argument. + /// Type for the 8th argument. + /// Type for the 9th argument. + /// Type for the 10th argument. + /// Type for the 11th argument. + /// Type for the 12th argument. + /// Type for the 13th argument. + /// Type for the 14th argument. public interface ITestAsyncMethodWithRangeParameters< in TArg1, in TArg2, @@ -242,6 +602,29 @@ public interface ITestAsyncMethodWithRangeParameters< in TArg13, in TArg14> { + /// + /// Check to ensure parameters requiring validation throw . + /// + /// The 1st argument that takes validation. + /// The 2nd argument that takes validation. + /// The 3rd argument that takes validation. + /// The 4th argument that takes validation. + /// The 5th argument that takes validation. + /// The 6th argument that takes validation. + /// The 7th argument that takes validation. + /// The 8th argument that takes validation. + /// The 9th argument that takes validation. + /// The 10th argument that takes validation. + /// The 11th argument that takes validation. + /// The 12th argument that takes validation. + /// The 13th argument that takes validation. + /// The 14th argument that takes validation. + /// + /// The name of the parameter expected to throw an exception. + /// + /// + /// A representing the asynchronous operation. + /// Task ThrowsArgumentOutOfRangeExceptionAsync( TArg1 arg1, TArg2 arg2, @@ -260,6 +643,24 @@ Task ThrowsArgumentOutOfRangeExceptionAsync( string expectedParameterNameForException); } + /// + /// Unit Tests for Async Methods that contain 15 parameters that need range validation. + /// + /// Type for the 1st argument. + /// Type for the 2nd argument. + /// Type for the 3rd argument. + /// Type for the 4th argument. + /// Type for the 5th argument. + /// Type for the 6th argument. + /// Type for the 7th argument. + /// Type for the 8th argument. + /// Type for the 9th argument. + /// Type for the 10th argument. + /// Type for the 11th argument. + /// Type for the 12th argument. + /// Type for the 13th argument. + /// Type for the 14th argument. + /// Type for the 15th argument. public interface ITestAsyncMethodWithRangeParameters< in TArg1, in TArg2, @@ -277,6 +678,30 @@ public interface ITestAsyncMethodWithRangeParameters< in TArg14, in TArg15> { + /// + /// Check to ensure parameters requiring validation throw . + /// + /// The 1st argument that takes validation. + /// The 2nd argument that takes validation. + /// The 3rd argument that takes validation. + /// The 4th argument that takes validation. + /// The 5th argument that takes validation. + /// The 6th argument that takes validation. + /// The 7th argument that takes validation. + /// The 8th argument that takes validation. + /// The 9th argument that takes validation. + /// The 10th argument that takes validation. + /// The 11th argument that takes validation. + /// The 12th argument that takes validation. + /// The 13th argument that takes validation. + /// The 14th argument that takes validation. + /// The 15th argument that takes validation. + /// + /// The name of the parameter expected to throw an exception. + /// + /// + /// A representing the asynchronous operation. + /// Task ThrowsArgumentOutOfRangeExceptionAsync( TArg1 arg1, TArg2 arg2, @@ -296,6 +721,25 @@ Task ThrowsArgumentOutOfRangeExceptionAsync( string expectedParameterNameForException); } + /// + /// Unit Tests for Async Methods that contain 16 parameters that need range validation. + /// + /// Type for the 1st argument. + /// Type for the 2nd argument. + /// Type for the 3rd argument. + /// Type for the 4th argument. + /// Type for the 5th argument. + /// Type for the 6th argument. + /// Type for the 7th argument. + /// Type for the 8th argument. + /// Type for the 9th argument. + /// Type for the 10th argument. + /// Type for the 11th argument. + /// Type for the 12th argument. + /// Type for the 13th argument. + /// Type for the 14th argument. + /// Type for the 15th argument. + /// Type for the 16th argument. public interface ITestAsyncMethodWithRangeParameters< in TArg1, in TArg2, @@ -314,6 +758,31 @@ public interface ITestAsyncMethodWithRangeParameters< in TArg15, in TArg16> { + /// + /// Check to ensure parameters requiring validation throw . + /// + /// The 1st argument that takes validation. + /// The 2nd argument that takes validation. + /// The 3rd argument that takes validation. + /// The 4th argument that takes validation. + /// The 5th argument that takes validation. + /// The 6th argument that takes validation. + /// The 7th argument that takes validation. + /// The 8th argument that takes validation. + /// The 9th argument that takes validation. + /// The 10th argument that takes validation. + /// The 11th argument that takes validation. + /// The 12th argument that takes validation. + /// The 13th argument that takes validation. + /// The 14th argument that takes validation. + /// The 15th argument that takes validation. + /// The 16th argument that takes validation. + /// + /// The name of the parameter expected to throw an exception. + /// + /// + /// A representing the asynchronous operation. + /// Task ThrowsArgumentOutOfRangeExceptionAsync( TArg1 arg1, TArg2 arg2, @@ -333,4 +802,5 @@ Task ThrowsArgumentOutOfRangeExceptionAsync( TArg16 arg16, string expectedParameterNameForException); } -} \ No newline at end of file +#pragma warning restore SA1402 // File may only contain a single type +} diff --git a/src/NetTestRegimentation/ITestConstructorMethod.cs b/src/NetTestRegimentation/ITestConstructorMethod.cs index 544f6b2..4c31351 100644 --- a/src/NetTestRegimentation/ITestConstructorMethod.cs +++ b/src/NetTestRegimentation/ITestConstructorMethod.cs @@ -1,5 +1,12 @@ -namespace NetTestRegimentation +// Copyright (c) 2019 dpvreony and Contributors. All rights reserved. +// This file is licensed to you under the MIT license. +// See the LICENSE file in the project root for full license information. + +namespace NetTestRegimentation { + /// + /// Unit Tests for a constructor method. + /// public interface ITestConstructorMethod { /// @@ -7,84 +14,4 @@ public interface ITestConstructorMethod /// void ReturnsInstance(); } - - public interface ITestConstructorMethodWithNullableParameters - : ITestConstructorMethod, NetTestRegimentation.ITestMethodWithNullableParameters - { - } - - public interface ITestConstructorMethodWithNullableParameters - : ITestConstructorMethod, NetTestRegimentation.ITestMethodWithNullableParameters - { - } - - public interface ITestConstructorMethodWithNullableParameters - : ITestConstructorMethod, NetTestRegimentation.ITestMethodWithNullableParameters - { - } - - public interface ITestConstructorMethodWithNullableParameters - : ITestConstructorMethod, NetTestRegimentation.ITestMethodWithNullableParameters - { - } - - public interface ITestConstructorMethodWithNullableParameters - : ITestConstructorMethod, NetTestRegimentation.ITestMethodWithNullableParameters - { - } - - public interface ITestConstructorMethodWithNullableParameters - : ITestConstructorMethod, NetTestRegimentation.ITestMethodWithNullableParameters - { - } - - public interface ITestConstructorMethodWithNullableParameters - : ITestConstructorMethod, NetTestRegimentation.ITestMethodWithNullableParameters - { - } - - public interface ITestConstructorMethodWithNullableParameters - : ITestConstructorMethod, NetTestRegimentation.ITestMethodWithNullableParameters - { - } - - public interface ITestConstructorMethodWithNullableParameters - : ITestConstructorMethod, NetTestRegimentation.ITestMethodWithNullableParameters - { - } - - public interface ITestConstructorMethodWithNullableParameters - : ITestConstructorMethod, NetTestRegimentation.ITestMethodWithNullableParameters - { - } - - public interface ITestConstructorMethodWithNullableParameters - : ITestConstructorMethod, NetTestRegimentation.ITestMethodWithNullableParameters - { - } - - public interface ITestConstructorMethodWithNullableParameters - : ITestConstructorMethod, NetTestRegimentation.ITestMethodWithNullableParameters - { - } - - public interface ITestConstructorMethodWithNullableParameters - : ITestConstructorMethod, NetTestRegimentation.ITestMethodWithNullableParameters - { - } - - public interface ITestConstructorMethodWithNullableParameters - : ITestConstructorMethod, NetTestRegimentation.ITestMethodWithNullableParameters - { - } - - public interface ITestConstructorMethodWithNullableParameters - : ITestConstructorMethod, NetTestRegimentation.ITestMethodWithNullableParameters - { - } - - public interface ITestConstructorMethodWithNullableParameters - : ITestConstructorMethod, NetTestRegimentation.ITestMethodWithNullableParameters - { - } } diff --git a/src/NetTestRegimentation/ITestConstructorMethodWithNullableParameters{TArg1,TArg2,TArg3,TArg4,TArg5,TArg6,TArg7,TArg8,TArg9,TArg10,TArg11,TArg12,TArg13,TArg14,TArg15,TArg16}.cs b/src/NetTestRegimentation/ITestConstructorMethodWithNullableParameters{TArg1,TArg2,TArg3,TArg4,TArg5,TArg6,TArg7,TArg8,TArg9,TArg10,TArg11,TArg12,TArg13,TArg14,TArg15,TArg16}.cs new file mode 100644 index 0000000..8159e76 --- /dev/null +++ b/src/NetTestRegimentation/ITestConstructorMethodWithNullableParameters{TArg1,TArg2,TArg3,TArg4,TArg5,TArg6,TArg7,TArg8,TArg9,TArg10,TArg11,TArg12,TArg13,TArg14,TArg15,TArg16}.cs @@ -0,0 +1,30 @@ +// Copyright (c) 2019 dpvreony and Contributors. All rights reserved. +// This file is licensed to you under the MIT license. +// See the LICENSE file in the project root for full license information. + +namespace NetTestRegimentation +{ + /// + /// Unit Tests for a constructor method that takes 16 nullable parameters. + /// + /// Type for the 1st argument. + /// Type for the 2nd argument. + /// Type for the 3rd argument. + /// Type for the 4th argument. + /// Type for the 5th argument. + /// Type for the 6th argument. + /// Type for the 7th argument. + /// Type for the 8th argument. + /// Type for the 9th argument. + /// Type for the 10th argument. + /// Type for the 11th argument. + /// Type for the 12th argument. + /// Type for the 13th argument. + /// Type for the 14th argument. + /// Type for the 15th argument. + /// Type for the 16th argument. + public interface ITestConstructorMethodWithNullableParameters + : ITestConstructorMethod, NetTestRegimentation.ITestMethodWithNullableParameters + { + } +} diff --git a/src/NetTestRegimentation/ITestConstructorMethodWithNullableParameters{TArg1,TArg2,TArg3,TArg4,TArg5,TArg6,TArg7,TArg8,TArg9,TArg10,TArg11,TArg12,TArg13,TArg14,TArg15}.cs b/src/NetTestRegimentation/ITestConstructorMethodWithNullableParameters{TArg1,TArg2,TArg3,TArg4,TArg5,TArg6,TArg7,TArg8,TArg9,TArg10,TArg11,TArg12,TArg13,TArg14,TArg15}.cs new file mode 100644 index 0000000..5e72e25 --- /dev/null +++ b/src/NetTestRegimentation/ITestConstructorMethodWithNullableParameters{TArg1,TArg2,TArg3,TArg4,TArg5,TArg6,TArg7,TArg8,TArg9,TArg10,TArg11,TArg12,TArg13,TArg14,TArg15}.cs @@ -0,0 +1,29 @@ +// Copyright (c) 2019 dpvreony and Contributors. All rights reserved. +// This file is licensed to you under the MIT license. +// See the LICENSE file in the project root for full license information. + +namespace NetTestRegimentation +{ + /// + /// Unit Tests for a constructor method that takes 15 nullable parameters. + /// + /// Type for the 1st argument. + /// Type for the 2nd argument. + /// Type for the 3rd argument. + /// Type for the 4th argument. + /// Type for the 5th argument. + /// Type for the 6th argument. + /// Type for the 7th argument. + /// Type for the 8th argument. + /// Type for the 9th argument. + /// Type for the 10th argument. + /// Type for the 11th argument. + /// Type for the 12th argument. + /// Type for the 13th argument. + /// Type for the 14th argument. + /// Type for the 15th argument. + public interface ITestConstructorMethodWithNullableParameters + : ITestConstructorMethod, NetTestRegimentation.ITestMethodWithNullableParameters + { + } +} diff --git a/src/NetTestRegimentation/ITestConstructorMethodWithNullableParameters{TArg1,TArg2,TArg3,TArg4,TArg5,TArg6,TArg7,TArg8,TArg9,TArg10,TArg11,TArg12,TArg13,TArg14}.cs b/src/NetTestRegimentation/ITestConstructorMethodWithNullableParameters{TArg1,TArg2,TArg3,TArg4,TArg5,TArg6,TArg7,TArg8,TArg9,TArg10,TArg11,TArg12,TArg13,TArg14}.cs new file mode 100644 index 0000000..ad4aa28 --- /dev/null +++ b/src/NetTestRegimentation/ITestConstructorMethodWithNullableParameters{TArg1,TArg2,TArg3,TArg4,TArg5,TArg6,TArg7,TArg8,TArg9,TArg10,TArg11,TArg12,TArg13,TArg14}.cs @@ -0,0 +1,28 @@ +// Copyright (c) 2019 dpvreony and Contributors. All rights reserved. +// This file is licensed to you under the MIT license. +// See the LICENSE file in the project root for full license information. + +namespace NetTestRegimentation +{ + /// + /// Unit Tests for a constructor method that takes 14 nullable parameters. + /// + /// Type for the 1st argument. + /// Type for the 2nd argument. + /// Type for the 3rd argument. + /// Type for the 4th argument. + /// Type for the 5th argument. + /// Type for the 6th argument. + /// Type for the 7th argument. + /// Type for the 8th argument. + /// Type for the 9th argument. + /// Type for the 10th argument. + /// Type for the 11th argument. + /// Type for the 12th argument. + /// Type for the 13th argument. + /// Type for the 14th argument. + public interface ITestConstructorMethodWithNullableParameters + : ITestConstructorMethod, NetTestRegimentation.ITestMethodWithNullableParameters + { + } +} diff --git a/src/NetTestRegimentation/ITestConstructorMethodWithNullableParameters{TArg1,TArg2,TArg3,TArg4,TArg5,TArg6,TArg7,TArg8,TArg9,TArg10,TArg11,TArg12,TArg13}.cs b/src/NetTestRegimentation/ITestConstructorMethodWithNullableParameters{TArg1,TArg2,TArg3,TArg4,TArg5,TArg6,TArg7,TArg8,TArg9,TArg10,TArg11,TArg12,TArg13}.cs new file mode 100644 index 0000000..a68f9e2 --- /dev/null +++ b/src/NetTestRegimentation/ITestConstructorMethodWithNullableParameters{TArg1,TArg2,TArg3,TArg4,TArg5,TArg6,TArg7,TArg8,TArg9,TArg10,TArg11,TArg12,TArg13}.cs @@ -0,0 +1,27 @@ +// Copyright (c) 2019 dpvreony and Contributors. All rights reserved. +// This file is licensed to you under the MIT license. +// See the LICENSE file in the project root for full license information. + +namespace NetTestRegimentation +{ + /// + /// Unit Tests for a constructor method that takes 13 nullable parameters. + /// + /// Type for the 1st argument. + /// Type for the 2nd argument. + /// Type for the 3rd argument. + /// Type for the 4th argument. + /// Type for the 5th argument. + /// Type for the 6th argument. + /// Type for the 7th argument. + /// Type for the 8th argument. + /// Type for the 9th argument. + /// Type for the 10th argument. + /// Type for the 11th argument. + /// Type for the 12th argument. + /// Type for the 13th argument. + public interface ITestConstructorMethodWithNullableParameters + : ITestConstructorMethod, NetTestRegimentation.ITestMethodWithNullableParameters + { + } +} diff --git a/src/NetTestRegimentation/ITestConstructorMethodWithNullableParameters{TArg1,TArg2,TArg3,TArg4,TArg5,TArg6,TArg7,TArg8,TArg9,TArg10,TArg11,TArg12}.cs b/src/NetTestRegimentation/ITestConstructorMethodWithNullableParameters{TArg1,TArg2,TArg3,TArg4,TArg5,TArg6,TArg7,TArg8,TArg9,TArg10,TArg11,TArg12}.cs new file mode 100644 index 0000000..6f5be18 --- /dev/null +++ b/src/NetTestRegimentation/ITestConstructorMethodWithNullableParameters{TArg1,TArg2,TArg3,TArg4,TArg5,TArg6,TArg7,TArg8,TArg9,TArg10,TArg11,TArg12}.cs @@ -0,0 +1,26 @@ +// Copyright (c) 2019 dpvreony and Contributors. All rights reserved. +// This file is licensed to you under the MIT license. +// See the LICENSE file in the project root for full license information. + +namespace NetTestRegimentation +{ + /// + /// Unit Tests for a constructor method that takes 12 nullable parameters. + /// + /// Type for the 1st argument. + /// Type for the 2nd argument. + /// Type for the 3rd argument. + /// Type for the 4th argument. + /// Type for the 5th argument. + /// Type for the 6th argument. + /// Type for the 7th argument. + /// Type for the 8th argument. + /// Type for the 9th argument. + /// Type for the 10th argument. + /// Type for the 11th argument. + /// Type for the 12th argument. + public interface ITestConstructorMethodWithNullableParameters + : ITestConstructorMethod, NetTestRegimentation.ITestMethodWithNullableParameters + { + } +} diff --git a/src/NetTestRegimentation/ITestConstructorMethodWithNullableParameters{TArg1,TArg2,TArg3,TArg4,TArg5,TArg6,TArg7,TArg8,TArg9,TArg10,TArg11}.cs b/src/NetTestRegimentation/ITestConstructorMethodWithNullableParameters{TArg1,TArg2,TArg3,TArg4,TArg5,TArg6,TArg7,TArg8,TArg9,TArg10,TArg11}.cs new file mode 100644 index 0000000..7162ffd --- /dev/null +++ b/src/NetTestRegimentation/ITestConstructorMethodWithNullableParameters{TArg1,TArg2,TArg3,TArg4,TArg5,TArg6,TArg7,TArg8,TArg9,TArg10,TArg11}.cs @@ -0,0 +1,25 @@ +// Copyright (c) 2019 dpvreony and Contributors. All rights reserved. +// This file is licensed to you under the MIT license. +// See the LICENSE file in the project root for full license information. + +namespace NetTestRegimentation +{ + /// + /// Unit Tests for a constructor method that takes 11 nullable parameters. + /// + /// Type for the 1st argument. + /// Type for the 2nd argument. + /// Type for the 3rd argument. + /// Type for the 4th argument. + /// Type for the 5th argument. + /// Type for the 6th argument. + /// Type for the 7th argument. + /// Type for the 8th argument. + /// Type for the 9th argument. + /// Type for the 10th argument. + /// Type for the 11th argument. + public interface ITestConstructorMethodWithNullableParameters + : ITestConstructorMethod, NetTestRegimentation.ITestMethodWithNullableParameters + { + } +} diff --git a/src/NetTestRegimentation/ITestConstructorMethodWithNullableParameters{TArg1,TArg2,TArg3,TArg4,TArg5,TArg6,TArg7,TArg8,TArg9,TArg10}.cs b/src/NetTestRegimentation/ITestConstructorMethodWithNullableParameters{TArg1,TArg2,TArg3,TArg4,TArg5,TArg6,TArg7,TArg8,TArg9,TArg10}.cs new file mode 100644 index 0000000..66e7e06 --- /dev/null +++ b/src/NetTestRegimentation/ITestConstructorMethodWithNullableParameters{TArg1,TArg2,TArg3,TArg4,TArg5,TArg6,TArg7,TArg8,TArg9,TArg10}.cs @@ -0,0 +1,24 @@ +// Copyright (c) 2019 dpvreony and Contributors. All rights reserved. +// This file is licensed to you under the MIT license. +// See the LICENSE file in the project root for full license information. + +namespace NetTestRegimentation +{ + /// + /// Unit Tests for a constructor method that takes 10 nullable parameters. + /// + /// Type for the 1st argument. + /// Type for the 2nd argument. + /// Type for the 3rd argument. + /// Type for the 4th argument. + /// Type for the 5th argument. + /// Type for the 6th argument. + /// Type for the 7th argument. + /// Type for the 8th argument. + /// Type for the 9th argument. + /// Type for the 10th argument. + public interface ITestConstructorMethodWithNullableParameters + : ITestConstructorMethod, NetTestRegimentation.ITestMethodWithNullableParameters + { + } +} diff --git a/src/NetTestRegimentation/ITestConstructorMethodWithNullableParameters{TArg1,TArg2,TArg3,TArg4,TArg5,TArg6,TArg7,TArg8,TArg9}.cs b/src/NetTestRegimentation/ITestConstructorMethodWithNullableParameters{TArg1,TArg2,TArg3,TArg4,TArg5,TArg6,TArg7,TArg8,TArg9}.cs new file mode 100644 index 0000000..9723c8e --- /dev/null +++ b/src/NetTestRegimentation/ITestConstructorMethodWithNullableParameters{TArg1,TArg2,TArg3,TArg4,TArg5,TArg6,TArg7,TArg8,TArg9}.cs @@ -0,0 +1,23 @@ +// Copyright (c) 2019 dpvreony and Contributors. All rights reserved. +// This file is licensed to you under the MIT license. +// See the LICENSE file in the project root for full license information. + +namespace NetTestRegimentation +{ + /// + /// Unit Tests for a constructor method that takes 9 nullable parameters. + /// + /// Type for the 1st argument. + /// Type for the 2nd argument. + /// Type for the 3rd argument. + /// Type for the 4th argument. + /// Type for the 5th argument. + /// Type for the 6th argument. + /// Type for the 7th argument. + /// Type for the 8th argument. + /// Type for the 9th argument. + public interface ITestConstructorMethodWithNullableParameters + : ITestConstructorMethod, NetTestRegimentation.ITestMethodWithNullableParameters + { + } +} diff --git a/src/NetTestRegimentation/ITestConstructorMethodWithNullableParameters{TArg1,TArg2,TArg3,TArg4,TArg5,TArg6,TArg7,TArg8}.cs b/src/NetTestRegimentation/ITestConstructorMethodWithNullableParameters{TArg1,TArg2,TArg3,TArg4,TArg5,TArg6,TArg7,TArg8}.cs new file mode 100644 index 0000000..75ba8bc --- /dev/null +++ b/src/NetTestRegimentation/ITestConstructorMethodWithNullableParameters{TArg1,TArg2,TArg3,TArg4,TArg5,TArg6,TArg7,TArg8}.cs @@ -0,0 +1,22 @@ +// Copyright (c) 2019 dpvreony and Contributors. All rights reserved. +// This file is licensed to you under the MIT license. +// See the LICENSE file in the project root for full license information. + +namespace NetTestRegimentation +{ + /// + /// Unit Tests for a constructor method that takes 8 nullable parameters. + /// + /// Type for the 1st argument. + /// Type for the 2nd argument. + /// Type for the 3rd argument. + /// Type for the 4th argument. + /// Type for the 5th argument. + /// Type for the 6th argument. + /// Type for the 7th argument. + /// Type for the 8th argument. + public interface ITestConstructorMethodWithNullableParameters + : ITestConstructorMethod, NetTestRegimentation.ITestMethodWithNullableParameters + { + } +} diff --git a/src/NetTestRegimentation/ITestConstructorMethodWithNullableParameters{TArg1,TArg2,TArg3,TArg4,TArg5,TArg6,TArg7}.cs b/src/NetTestRegimentation/ITestConstructorMethodWithNullableParameters{TArg1,TArg2,TArg3,TArg4,TArg5,TArg6,TArg7}.cs new file mode 100644 index 0000000..12b6e5b --- /dev/null +++ b/src/NetTestRegimentation/ITestConstructorMethodWithNullableParameters{TArg1,TArg2,TArg3,TArg4,TArg5,TArg6,TArg7}.cs @@ -0,0 +1,21 @@ +// Copyright (c) 2019 dpvreony and Contributors. All rights reserved. +// This file is licensed to you under the MIT license. +// See the LICENSE file in the project root for full license information. + +namespace NetTestRegimentation +{ + /// + /// Unit Tests for a constructor method that takes 7 nullable parameters. + /// + /// Type for the 1st argument. + /// Type for the 2nd argument. + /// Type for the 3rd argument. + /// Type for the 4th argument. + /// Type for the 5th argument. + /// Type for the 6th argument. + /// Type for the 7th argument. + public interface ITestConstructorMethodWithNullableParameters + : ITestConstructorMethod, NetTestRegimentation.ITestMethodWithNullableParameters + { + } +} diff --git a/src/NetTestRegimentation/ITestConstructorMethodWithNullableParameters{TArg1,TArg2,TArg3,TArg4,TArg5,TArg6}.cs b/src/NetTestRegimentation/ITestConstructorMethodWithNullableParameters{TArg1,TArg2,TArg3,TArg4,TArg5,TArg6}.cs new file mode 100644 index 0000000..3ceefab --- /dev/null +++ b/src/NetTestRegimentation/ITestConstructorMethodWithNullableParameters{TArg1,TArg2,TArg3,TArg4,TArg5,TArg6}.cs @@ -0,0 +1,20 @@ +// Copyright (c) 2019 dpvreony and Contributors. All rights reserved. +// This file is licensed to you under the MIT license. +// See the LICENSE file in the project root for full license information. + +namespace NetTestRegimentation +{ + /// + /// Unit Tests for a constructor method that takes 6 nullable parameters. + /// + /// Type for the 1st argument. + /// Type for the 2nd argument. + /// Type for the 3rd argument. + /// Type for the 4th argument. + /// Type for the 5th argument. + /// Type for the 6th argument. + public interface ITestConstructorMethodWithNullableParameters + : ITestConstructorMethod, NetTestRegimentation.ITestMethodWithNullableParameters + { + } +} diff --git a/src/NetTestRegimentation/ITestConstructorMethodWithNullableParameters{TArg1,TArg2,TArg3,TArg4,TArg5}.cs b/src/NetTestRegimentation/ITestConstructorMethodWithNullableParameters{TArg1,TArg2,TArg3,TArg4,TArg5}.cs new file mode 100644 index 0000000..bea073d --- /dev/null +++ b/src/NetTestRegimentation/ITestConstructorMethodWithNullableParameters{TArg1,TArg2,TArg3,TArg4,TArg5}.cs @@ -0,0 +1,19 @@ +// Copyright (c) 2019 dpvreony and Contributors. All rights reserved. +// This file is licensed to you under the MIT license. +// See the LICENSE file in the project root for full license information. + +namespace NetTestRegimentation +{ + /// + /// Unit Tests for a constructor method that takes 5 nullable parameters. + /// + /// Type for the 1st argument. + /// Type for the 2nd argument. + /// Type for the 3rd argument. + /// Type for the 4th argument. + /// Type for the 5th argument. + public interface ITestConstructorMethodWithNullableParameters + : ITestConstructorMethod, NetTestRegimentation.ITestMethodWithNullableParameters + { + } +} diff --git a/src/NetTestRegimentation/ITestConstructorMethodWithNullableParameters{TArg1,TArg2,TArg3,TArg4}.cs b/src/NetTestRegimentation/ITestConstructorMethodWithNullableParameters{TArg1,TArg2,TArg3,TArg4}.cs new file mode 100644 index 0000000..518fb16 --- /dev/null +++ b/src/NetTestRegimentation/ITestConstructorMethodWithNullableParameters{TArg1,TArg2,TArg3,TArg4}.cs @@ -0,0 +1,18 @@ +// Copyright (c) 2019 dpvreony and Contributors. All rights reserved. +// This file is licensed to you under the MIT license. +// See the LICENSE file in the project root for full license information. + +namespace NetTestRegimentation +{ + /// + /// Unit Tests for a constructor method that takes 4 nullable parameters. + /// + /// Type for the 1st argument. + /// Type for the 2nd argument. + /// Type for the 3rd argument. + /// Type for the 4th argument. + public interface ITestConstructorMethodWithNullableParameters + : ITestConstructorMethod, NetTestRegimentation.ITestMethodWithNullableParameters + { + } +} diff --git a/src/NetTestRegimentation/ITestConstructorMethodWithNullableParameters{TArg1,TArg2,TArg3}.cs b/src/NetTestRegimentation/ITestConstructorMethodWithNullableParameters{TArg1,TArg2,TArg3}.cs new file mode 100644 index 0000000..c1bf640 --- /dev/null +++ b/src/NetTestRegimentation/ITestConstructorMethodWithNullableParameters{TArg1,TArg2,TArg3}.cs @@ -0,0 +1,17 @@ +// Copyright (c) 2019 dpvreony and Contributors. All rights reserved. +// This file is licensed to you under the MIT license. +// See the LICENSE file in the project root for full license information. + +namespace NetTestRegimentation +{ + /// + /// Unit Tests for a constructor method that takes 3 nullable parameters. + /// + /// Type for the 1st argument. + /// Type for the 2nd argument. + /// Type for the 3rd argument. + public interface ITestConstructorMethodWithNullableParameters + : ITestConstructorMethod, NetTestRegimentation.ITestMethodWithNullableParameters + { + } +} diff --git a/src/NetTestRegimentation/ITestConstructorMethodWithNullableParameters{TArg1,TArg2}.cs b/src/NetTestRegimentation/ITestConstructorMethodWithNullableParameters{TArg1,TArg2}.cs new file mode 100644 index 0000000..c4d2ff0 --- /dev/null +++ b/src/NetTestRegimentation/ITestConstructorMethodWithNullableParameters{TArg1,TArg2}.cs @@ -0,0 +1,16 @@ +// Copyright (c) 2019 dpvreony and Contributors. All rights reserved. +// This file is licensed to you under the MIT license. +// See the LICENSE file in the project root for full license information. + +namespace NetTestRegimentation +{ + /// + /// Unit Tests for a constructor method that takes 2 nullable parameters. + /// + /// Type for the 1st argument. + /// Type for the 2nd argument. + public interface ITestConstructorMethodWithNullableParameters + : ITestConstructorMethod, NetTestRegimentation.ITestMethodWithNullableParameters + { + } +} diff --git a/src/NetTestRegimentation/ITestConstructorMethodWithNullableParameters{TArg}.cs b/src/NetTestRegimentation/ITestConstructorMethodWithNullableParameters{TArg}.cs new file mode 100644 index 0000000..bc5b23b --- /dev/null +++ b/src/NetTestRegimentation/ITestConstructorMethodWithNullableParameters{TArg}.cs @@ -0,0 +1,15 @@ +// Copyright (c) 2019 dpvreony and Contributors. All rights reserved. +// This file is licensed to you under the MIT license. +// See the LICENSE file in the project root for full license information. + +namespace NetTestRegimentation +{ + /// + /// Unit Tests for a constructor method that takes a nullable parameter. + /// + /// The type for the argument. + public interface ITestConstructorMethodWithNullableParameters + : ITestConstructorMethod, NetTestRegimentation.ITestMethodWithNullableParameters + { + } +} diff --git a/src/NetTestRegimentation/ITestEntityFrameworkDbSetProperty.cs b/src/NetTestRegimentation/ITestEntityFrameworkDbSetProperty.cs index 934a595..94e12ad 100644 --- a/src/NetTestRegimentation/ITestEntityFrameworkDbSetProperty.cs +++ b/src/NetTestRegimentation/ITestEntityFrameworkDbSetProperty.cs @@ -1,9 +1,22 @@ +// Copyright (c) 2019 dpvreony and Contributors. All rights reserved. +// This file is licensed to you under the MIT license. +// See the LICENSE file in the project root for full license information. + namespace NetTestRegimentation { + /// + /// Unit Tests for an Entity Framework DB Set Property. + /// public interface ITestEntityFrameworkDbSetProperty { + /// + /// Tests to ensure a DBSet allows insert. + /// void AllowsInsert(); + /// + /// Test to ensure a DBSet doesn't allow inserts of duplicate keys. + /// void PreventsDuplicateInsert(); } -} \ No newline at end of file +} diff --git a/src/NetTestRegimentation/ITestMethodWithNullableParameters.cs b/src/NetTestRegimentation/ITestMethodWithNullableParameters.cs index 8e88865..1de6393 100644 --- a/src/NetTestRegimentation/ITestMethodWithNullableParameters.cs +++ b/src/NetTestRegimentation/ITestMethodWithNullableParameters.cs @@ -1,22 +1,66 @@ +// Copyright (c) 2019 dpvreony and Contributors. All rights reserved. +// This file is licensed to you under the MIT license. +// See the LICENSE file in the project root for full license information. + namespace NetTestRegimentation { +#pragma warning disable SA1402 // File may only contain a single type + /// + /// Unit Tests for a constructor method that takes 1 nullable parameter. + /// + /// Type for the argument. public interface ITestMethodWithNullableParameters { + /// + /// Check to ensure nullable parameters throw . + /// + /// The nullable argument. + /// + /// The name of the parameter expected to throw an exception. + /// void ThrowsArgumentNullException( TArg arg, string expectedParameterNameForException); } + /// + /// Unit Tests for a constructor method that takes 2 nullable parameters. + /// + /// Type for the 1st argument. + /// Type for the 2nd argument. public interface ITestMethodWithNullableParameters { + /// + /// Check to ensure nullable parameters throw . + /// + /// The 1st nullable argument. + /// The 2nd nullable argument. + /// + /// The name of the parameter expected to throw an exception. + /// void ThrowsArgumentNullException( TArg1 arg1, TArg2 arg2, string expectedParameterNameForException); } + /// + /// Unit Tests for a constructor method that takes 3 nullable parameters. + /// + /// Type for the 1st argument. + /// Type for the 2nd argument. + /// Type for the 3rd argument. public interface ITestMethodWithNullableParameters { + /// + /// Check to ensure nullable parameters throw . + /// + /// The 1st nullable argument. + /// The 2nd nullable argument. + /// The 3rd nullable argument. + /// + /// The name of the parameter expected to throw an exception. + /// void ThrowsArgumentNullException( TArg1 arg1, TArg2 arg2, @@ -24,8 +68,25 @@ void ThrowsArgumentNullException( string expectedParameterNameForException); } + /// + /// Unit Tests for a constructor method that takes 4 nullable parameters. + /// + /// Type for the 1st argument. + /// Type for the 2nd argument. + /// Type for the 3rd argument. + /// Type for the 4th argument. public interface ITestMethodWithNullableParameters { + /// + /// Check to ensure nullable parameters throw . + /// + /// The 1st nullable argument. + /// The 2nd nullable argument. + /// The 3rd nullable argument. + /// The 4th nullable argument. + /// + /// The name of the parameter expected to throw an exception. + /// void ThrowsArgumentNullException( TArg1 arg1, TArg2 arg2, @@ -34,8 +95,27 @@ void ThrowsArgumentNullException( string expectedParameterNameForException); } + /// + /// Unit Tests for a constructor method that takes 5 nullable parameters. + /// + /// Type for the 1st argument. + /// Type for the 2nd argument. + /// Type for the 3rd argument. + /// Type for the 4th argument. + /// Type for the 5th argument. public interface ITestMethodWithNullableParameters { + /// + /// Check to ensure nullable parameters throw . + /// + /// The 1st nullable argument. + /// The 2nd nullable argument. + /// The 3rd nullable argument. + /// The 4th nullable argument. + /// The 5th nullable argument. + /// + /// The name of the parameter expected to throw an exception. + /// void ThrowsArgumentNullException( TArg1 arg1, TArg2 arg2, @@ -45,8 +125,29 @@ void ThrowsArgumentNullException( string expectedParameterNameForException); } + /// + /// Unit Tests for a constructor method that takes 6 nullable parameters. + /// + /// Type for the 1st argument. + /// Type for the 2nd argument. + /// Type for the 3rd argument. + /// Type for the 4th argument. + /// Type for the 5th argument. + /// Type for the 6th argument. public interface ITestMethodWithNullableParameters { + /// + /// Check to ensure nullable parameters throw . + /// + /// The 1st nullable argument. + /// The 2nd nullable argument. + /// The 3rd nullable argument. + /// The 4th nullable argument. + /// The 5th nullable argument. + /// The 6th nullable argument. + /// + /// The name of the parameter expected to throw an exception. + /// void ThrowsArgumentNullException( TArg1 arg1, TArg2 arg2, @@ -57,8 +158,31 @@ void ThrowsArgumentNullException( string expectedParameterNameForException); } + /// + /// Unit Tests for a constructor method that takes 7 nullable parameters. + /// + /// Type for the 1st argument. + /// Type for the 2nd argument. + /// Type for the 3rd argument. + /// Type for the 4th argument. + /// Type for the 5th argument. + /// Type for the 6th argument. + /// Type for the 7th argument. public interface ITestMethodWithNullableParameters { + /// + /// Check to ensure nullable parameters throw . + /// + /// The 1st nullable argument. + /// The 2nd nullable argument. + /// The 3rd nullable argument. + /// The 4th nullable argument. + /// The 5th nullable argument. + /// The 6th nullable argument. + /// The 7th nullable argument. + /// + /// The name of the parameter expected to throw an exception. + /// void ThrowsArgumentNullException( TArg1 arg1, TArg2 arg2, @@ -70,8 +194,33 @@ void ThrowsArgumentNullException( string expectedParameterNameForException); } + /// + /// Unit Tests for a constructor method that takes 8 nullable parameters. + /// + /// Type for the 1st argument. + /// Type for the 2nd argument. + /// Type for the 3rd argument. + /// Type for the 4th argument. + /// Type for the 5th argument. + /// Type for the 6th argument. + /// Type for the 7th argument. + /// Type for the 8th argument. public interface ITestMethodWithNullableParameters { + /// + /// Check to ensure nullable parameters throw . + /// + /// The 1st nullable argument. + /// The 2nd nullable argument. + /// The 3rd nullable argument. + /// The 4th nullable argument. + /// The 5th nullable argument. + /// The 6th nullable argument. + /// The 7th nullable argument. + /// The 8th nullable argument. + /// + /// The name of the parameter expected to throw an exception. + /// void ThrowsArgumentNullException( TArg1 arg1, TArg2 arg2, @@ -84,6 +233,18 @@ void ThrowsArgumentNullException( string expectedParameterNameForException); } + /// + /// Unit Tests for a constructor method that takes 9 nullable parameters. + /// + /// Type for the 1st argument. + /// Type for the 2nd argument. + /// Type for the 3rd argument. + /// Type for the 4th argument. + /// Type for the 5th argument. + /// Type for the 6th argument. + /// Type for the 7th argument. + /// Type for the 8th argument. + /// Type for the 9th argument. public interface ITestMethodWithNullableParameters< in TArg1, in TArg2, @@ -95,6 +256,21 @@ public interface ITestMethodWithNullableParameters< in TArg8, in TArg9> { + /// + /// Check to ensure nullable parameters throw . + /// + /// The 1st nullable argument. + /// The 2nd nullable argument. + /// The 3rd nullable argument. + /// The 4th nullable argument. + /// The 5th nullable argument. + /// The 6th nullable argument. + /// The 7th nullable argument. + /// The 8th nullable argument. + /// The 9th nullable argument. + /// + /// The name of the parameter expected to throw an exception. + /// void ThrowsArgumentNullException( TArg1 arg1, TArg2 arg2, @@ -108,6 +284,19 @@ void ThrowsArgumentNullException( string expectedParameterNameForException); } + /// + /// Unit Tests for a constructor method that takes 10 nullable parameters. + /// + /// Type for the 1st argument. + /// Type for the 2nd argument. + /// Type for the 3rd argument. + /// Type for the 4th argument. + /// Type for the 5th argument. + /// Type for the 6th argument. + /// Type for the 7th argument. + /// Type for the 8th argument. + /// Type for the 9th argument. + /// Type for the 10th argument. public interface ITestMethodWithNullableParameters< in TArg1, in TArg2, @@ -120,6 +309,22 @@ public interface ITestMethodWithNullableParameters< in TArg9, in TArg10> { + /// + /// Check to ensure nullable parameters throw . + /// + /// The 1st nullable argument. + /// The 2nd nullable argument. + /// The 3rd nullable argument. + /// The 4th nullable argument. + /// The 5th nullable argument. + /// The 6th nullable argument. + /// The 7th nullable argument. + /// The 8th nullable argument. + /// The 9th nullable argument. + /// The 10th nullable argument. + /// + /// The name of the parameter expected to throw an exception. + /// void ThrowsArgumentNullException( TArg1 arg1, TArg2 arg2, @@ -134,6 +339,20 @@ void ThrowsArgumentNullException( string expectedParameterNameForException); } + /// + /// Unit Tests for a constructor method that takes 11 nullable parameters. + /// + /// Type for the 1st argument. + /// Type for the 2nd argument. + /// Type for the 3rd argument. + /// Type for the 4th argument. + /// Type for the 5th argument. + /// Type for the 6th argument. + /// Type for the 7th argument. + /// Type for the 8th argument. + /// Type for the 9th argument. + /// Type for the 10th argument. + /// Type for the 11th argument. public interface ITestMethodWithNullableParameters< in TArg1, in TArg2, @@ -147,6 +366,23 @@ public interface ITestMethodWithNullableParameters< in TArg10, in TArg11> { + /// + /// Check to ensure nullable parameters throw . + /// + /// The 1st nullable argument. + /// The 2nd nullable argument. + /// The 3rd nullable argument. + /// The 4th nullable argument. + /// The 5th nullable argument. + /// The 6th nullable argument. + /// The 7th nullable argument. + /// The 8th nullable argument. + /// The 9th nullable argument. + /// The 10th nullable argument. + /// The 11th nullable argument. + /// + /// The name of the parameter expected to throw an exception. + /// void ThrowsArgumentNullException( TArg1 arg1, TArg2 arg2, @@ -162,6 +398,21 @@ void ThrowsArgumentNullException( string expectedParameterNameForException); } + /// + /// Unit Tests for a constructor method that takes 13 nullable parameters. + /// + /// Type for the 1st argument. + /// Type for the 2nd argument. + /// Type for the 3rd argument. + /// Type for the 4th argument. + /// Type for the 5th argument. + /// Type for the 6th argument. + /// Type for the 7th argument. + /// Type for the 8th argument. + /// Type for the 9th argument. + /// Type for the 10th argument. + /// Type for the 11th argument. + /// Type for the 12th argument. public interface ITestMethodWithNullableParameters< in TArg1, in TArg2, @@ -176,6 +427,24 @@ public interface ITestMethodWithNullableParameters< in TArg11, in TArg12> { + /// + /// Check to ensure nullable parameters throw . + /// + /// The 1st nullable argument. + /// The 2nd nullable argument. + /// The 3rd nullable argument. + /// The 4th nullable argument. + /// The 5th nullable argument. + /// The 6th nullable argument. + /// The 7th nullable argument. + /// The 8th nullable argument. + /// The 9th nullable argument. + /// The 10th nullable argument. + /// The 11th nullable argument. + /// The 12th nullable argument. + /// + /// The name of the parameter expected to throw an exception. + /// void ThrowsArgumentNullException( TArg1 arg1, TArg2 arg2, @@ -192,6 +461,22 @@ void ThrowsArgumentNullException( string expectedParameterNameForException); } + /// + /// Unit Tests for a constructor method that takes 13 nullable parameters. + /// + /// Type for the 1st argument. + /// Type for the 2nd argument. + /// Type for the 3rd argument. + /// Type for the 4th argument. + /// Type for the 5th argument. + /// Type for the 6th argument. + /// Type for the 7th argument. + /// Type for the 8th argument. + /// Type for the 9th argument. + /// Type for the 10th argument. + /// Type for the 11th argument. + /// Type for the 12th argument. + /// Type for the 13th argument. public interface ITestMethodWithNullableParameters< in TArg1, in TArg2, @@ -207,6 +492,25 @@ public interface ITestMethodWithNullableParameters< in TArg12, in TArg13> { + /// + /// Check to ensure nullable parameters throw . + /// + /// The 1st nullable argument. + /// The 2nd nullable argument. + /// The 3rd nullable argument. + /// The 4th nullable argument. + /// The 5th nullable argument. + /// The 6th nullable argument. + /// The 7th nullable argument. + /// The 8th nullable argument. + /// The 9th nullable argument. + /// The 10th nullable argument. + /// The 11th nullable argument. + /// The 12th nullable argument. + /// The 13th nullable argument. + /// + /// The name of the parameter expected to throw an exception. + /// void ThrowsArgumentNullException( TArg1 arg1, TArg2 arg2, @@ -224,6 +528,23 @@ void ThrowsArgumentNullException( string expectedParameterNameForException); } + /// + /// Unit Tests for a constructor method that takes 14 nullable parameters. + /// + /// Type for the 1st argument. + /// Type for the 2nd argument. + /// Type for the 3rd argument. + /// Type for the 4th argument. + /// Type for the 5th argument. + /// Type for the 6th argument. + /// Type for the 7th argument. + /// Type for the 8th argument. + /// Type for the 9th argument. + /// Type for the 10th argument. + /// Type for the 11th argument. + /// Type for the 12th argument. + /// Type for the 13th argument. + /// Type for the 14th argument. public interface ITestMethodWithNullableParameters< in TArg1, in TArg2, @@ -240,6 +561,26 @@ public interface ITestMethodWithNullableParameters< in TArg13, in TArg14> { + /// + /// Check to ensure nullable parameters throw . + /// + /// The 1st nullable argument. + /// The 2nd nullable argument. + /// The 3rd nullable argument. + /// The 4th nullable argument. + /// The 5th nullable argument. + /// The 6th nullable argument. + /// The 7th nullable argument. + /// The 8th nullable argument. + /// The 9th nullable argument. + /// The 10th nullable argument. + /// The 11th nullable argument. + /// The 12th nullable argument. + /// The 13th nullable argument. + /// The 14th nullable argument. + /// + /// The name of the parameter expected to throw an exception. + /// void ThrowsArgumentNullException( TArg1 arg1, TArg2 arg2, @@ -258,6 +599,24 @@ void ThrowsArgumentNullException( string expectedParameterNameForException); } + /// + /// Unit Tests for a constructor method that takes 15 nullable parameters. + /// + /// Type for the 1st argument. + /// Type for the 2nd argument. + /// Type for the 3rd argument. + /// Type for the 4th argument. + /// Type for the 5th argument. + /// Type for the 6th argument. + /// Type for the 7th argument. + /// Type for the 8th argument. + /// Type for the 9th argument. + /// Type for the 10th argument. + /// Type for the 11th argument. + /// Type for the 12th argument. + /// Type for the 13th argument. + /// Type for the 14th argument. + /// Type for the 15th argument. public interface ITestMethodWithNullableParameters< in TArg1, in TArg2, @@ -275,6 +634,27 @@ public interface ITestMethodWithNullableParameters< in TArg14, in TArg15> { + /// + /// Check to ensure nullable parameters throw . + /// + /// The 1st nullable argument. + /// The 2nd nullable argument. + /// The 3rd nullable argument. + /// The 4th nullable argument. + /// The 5th nullable argument. + /// The 6th nullable argument. + /// The 7th nullable argument. + /// The 8th nullable argument. + /// The 9th nullable argument. + /// The 10th nullable argument. + /// The 11th nullable argument. + /// The 12th nullable argument. + /// The 13th nullable argument. + /// The 14th nullable argument. + /// The 15th nullable argument. + /// + /// The name of the parameter expected to throw an exception. + /// void ThrowsArgumentNullException( TArg1 arg1, TArg2 arg2, @@ -294,6 +674,25 @@ void ThrowsArgumentNullException( string expectedParameterNameForException); } + /// + /// Unit Tests for a constructor method that takes 16 nullable parameters. + /// + /// Type for the 1st argument. + /// Type for the 2nd argument. + /// Type for the 3rd argument. + /// Type for the 4th argument. + /// Type for the 5th argument. + /// Type for the 6th argument. + /// Type for the 7th argument. + /// Type for the 8th argument. + /// Type for the 9th argument. + /// Type for the 10th argument. + /// Type for the 11th argument. + /// Type for the 12th argument. + /// Type for the 13th argument. + /// Type for the 14th argument. + /// Type for the 15th argument. + /// Type for the 16th argument. public interface ITestMethodWithNullableParameters< in TArg1, in TArg2, @@ -312,6 +711,28 @@ public interface ITestMethodWithNullableParameters< in TArg15, in TArg16> { + /// + /// Check to ensure nullable parameters throw . + /// + /// The 1st nullable argument. + /// The 2nd nullable argument. + /// The 3rd nullable argument. + /// The 4th nullable argument. + /// The 5th nullable argument. + /// The 6th nullable argument. + /// The 7th nullable argument. + /// The 8th nullable argument. + /// The 9th nullable argument. + /// The 10th nullable argument. + /// The 11th nullable argument. + /// The 12th nullable argument. + /// The 13th nullable argument. + /// The 14th nullable argument. + /// The 15th nullable argument. + /// The 16th nullable argument. + /// + /// The name of the parameter expected to throw an exception. + /// void ThrowsArgumentNullException( TArg1 arg1, TArg2 arg2, @@ -331,4 +752,5 @@ void ThrowsArgumentNullException( TArg16 arg16, string expectedParameterNameForException); } -} \ No newline at end of file +#pragma warning restore SA1402 // File may only contain a single type +} diff --git a/src/NetTestRegimentation/ITestMethodWithParameterValidation.cs b/src/NetTestRegimentation/ITestMethodWithParameterValidation.cs index 457c2cb..592f8fd 100644 --- a/src/NetTestRegimentation/ITestMethodWithParameterValidation.cs +++ b/src/NetTestRegimentation/ITestMethodWithParameterValidation.cs @@ -1,22 +1,66 @@ +// Copyright (c) 2019 dpvreony and Contributors. All rights reserved. +// This file is licensed to you under the MIT license. +// See the LICENSE file in the project root for full license information. + namespace NetTestRegimentation { +#pragma warning disable SA1402 // File may only contain a single type + /// + /// Unit Tests for method that contain 1 parameters that needs validation. + /// + /// Type for the 1st argument. public interface ITestMethodWithParameterValidation { + /// + /// Check to ensure parameters requiring validation throw . + /// + /// The argument that takes validation. + /// + /// The name of the parameter expected to throw an exception. + /// void ThrowsArgumentException( TArg arg, string expectedParameterNameForException); } + /// + /// Unit Tests for methods that contain sixteen parameters that need validation. + /// + /// Type for the 1st argument. + /// Type for the 2nd argument. public interface ITestMethodWithParameterValidation { + /// + /// Check to ensure parameters requiring validation throw . + /// + /// The 1st argument that takes validation. + /// The 2nd argument that takes validation. + /// + /// The name of the parameter expected to throw an exception. + /// void ThrowsArgumentException( TArg1 arg1, TArg2 arg2, string expectedParameterNameForException); } + /// + /// Unit Tests for methods that contain sixteen parameters that need validation. + /// + /// Type for the 1st argument. + /// Type for the 2nd argument. + /// Type for the 3rd argument. public interface ITestMethodWithParameterValidation { + /// + /// Check to ensure parameters requiring validation throw . + /// + /// The 1st argument that takes validation. + /// The 2nd argument that takes validation. + /// The 3rd argument that takes validation. + /// + /// The name of the parameter expected to throw an exception. + /// void ThrowsArgumentException( TArg1 arg1, TArg2 arg2, @@ -24,8 +68,25 @@ void ThrowsArgumentException( string expectedParameterNameForException); } + /// + /// Unit Tests for methods that contain sixteen parameters that need validation. + /// + /// Type for the 1st argument. + /// Type for the 2nd argument. + /// Type for the 3rd argument. + /// Type for the 4th argument. public interface ITestMethodWithParameterValidation { + /// + /// Check to ensure parameters requiring validation throw . + /// + /// The 1st argument that takes validation. + /// The 2nd argument that takes validation. + /// The 3rd argument that takes validation. + /// The 4th argument that takes validation. + /// + /// The name of the parameter expected to throw an exception. + /// void ThrowsArgumentException( TArg1 arg1, TArg2 arg2, @@ -34,8 +95,27 @@ void ThrowsArgumentException( string expectedParameterNameForException); } + /// + /// Unit Tests for methods that contain sixteen parameters that need validation. + /// + /// Type for the 1st argument. + /// Type for the 2nd argument. + /// Type for the 3rd argument. + /// Type for the 4th argument. + /// Type for the 5th argument. public interface ITestMethodWithParameterValidation { + /// + /// Check to ensure parameters requiring validation throw . + /// + /// The 1st argument that takes validation. + /// The 2nd argument that takes validation. + /// The 3rd argument that takes validation. + /// The 4th argument that takes validation. + /// The 5th argument that takes validation. + /// + /// The name of the parameter expected to throw an exception. + /// void ThrowsArgumentException( TArg1 arg1, TArg2 arg2, @@ -45,8 +125,29 @@ void ThrowsArgumentException( string expectedParameterNameForException); } + /// + /// Unit Tests for methods that contain sixteen parameters that need validation. + /// + /// Type for the 1st argument. + /// Type for the 2nd argument. + /// Type for the 3rd argument. + /// Type for the 4th argument. + /// Type for the 5th argument. + /// Type for the 6th argument. public interface ITestMethodWithParameterValidation { + /// + /// Check to ensure parameters requiring validation throw . + /// + /// The 1st argument that takes validation. + /// The 2nd argument that takes validation. + /// The 3rd argument that takes validation. + /// The 4th argument that takes validation. + /// The 5th argument that takes validation. + /// The 6th argument that takes validation. + /// + /// The name of the parameter expected to throw an exception. + /// void ThrowsArgumentException( TArg1 arg1, TArg2 arg2, @@ -57,8 +158,31 @@ void ThrowsArgumentException( string expectedParameterNameForException); } + /// + /// Unit Tests for methods that contain sixteen parameters that need validation. + /// + /// Type for the 1st argument. + /// Type for the 2nd argument. + /// Type for the 3rd argument. + /// Type for the 4th argument. + /// Type for the 5th argument. + /// Type for the 6th argument. + /// Type for the 7th argument. public interface ITestMethodWithParameterValidation { + /// + /// Check to ensure parameters requiring validation throw . + /// + /// The 1st argument that takes validation. + /// The 2nd argument that takes validation. + /// The 3rd argument that takes validation. + /// The 4th argument that takes validation. + /// The 5th argument that takes validation. + /// The 6th argument that takes validation. + /// The 7th argument that takes validation. + /// + /// The name of the parameter expected to throw an exception. + /// void ThrowsArgumentException( TArg1 arg1, TArg2 arg2, @@ -70,8 +194,33 @@ void ThrowsArgumentException( string expectedParameterNameForException); } + /// + /// Unit Tests for methods that contain sixteen parameters that need validation. + /// + /// Type for the 1st argument. + /// Type for the 2nd argument. + /// Type for the 3rd argument. + /// Type for the 4th argument. + /// Type for the 5th argument. + /// Type for the 6th argument. + /// Type for the 7th argument. + /// Type for the 8th argument. public interface ITestMethodWithParameterValidation { + /// + /// Check to ensure parameters requiring validation throw . + /// + /// The 1st argument that takes validation. + /// The 2nd argument that takes validation. + /// The 3rd argument that takes validation. + /// The 4th argument that takes validation. + /// The 5th argument that takes validation. + /// The 6th argument that takes validation. + /// The 7th argument that takes validation. + /// The 8th argument that takes validation. + /// + /// The name of the parameter expected to throw an exception. + /// void ThrowsArgumentException( TArg1 arg1, TArg2 arg2, @@ -84,6 +233,18 @@ void ThrowsArgumentException( string expectedParameterNameForException); } + /// + /// Unit Tests for methods that contain sixteen parameters that need validation. + /// + /// Type for the 1st argument. + /// Type for the 2nd argument. + /// Type for the 3rd argument. + /// Type for the 4th argument. + /// Type for the 5th argument. + /// Type for the 6th argument. + /// Type for the 7th argument. + /// Type for the 8th argument. + /// Type for the 9th argument. public interface ITestMethodWithParameterValidation< in TArg1, in TArg2, @@ -95,6 +256,21 @@ public interface ITestMethodWithParameterValidation< in TArg8, in TArg9> { + /// + /// Check to ensure parameters requiring validation throw . + /// + /// The 1st argument that takes validation. + /// The 2nd argument that takes validation. + /// The 3rd argument that takes validation. + /// The 4th argument that takes validation. + /// The 5th argument that takes validation. + /// The 6th argument that takes validation. + /// The 7th argument that takes validation. + /// The 8th argument that takes validation. + /// The 9th argument that takes validation. + /// + /// The name of the parameter expected to throw an exception. + /// void ThrowsArgumentException( TArg1 arg1, TArg2 arg2, @@ -108,6 +284,19 @@ void ThrowsArgumentException( string expectedParameterNameForException); } + /// + /// Unit Tests for methods that contain sixteen parameters that need validation. + /// + /// Type for the 1st argument. + /// Type for the 2nd argument. + /// Type for the 3rd argument. + /// Type for the 4th argument. + /// Type for the 5th argument. + /// Type for the 6th argument. + /// Type for the 7th argument. + /// Type for the 8th argument. + /// Type for the 9th argument. + /// Type for the 10th argument. public interface ITestMethodWithParameterValidation< in TArg1, in TArg2, @@ -120,6 +309,22 @@ public interface ITestMethodWithParameterValidation< in TArg9, in TArg10> { + /// + /// Check to ensure parameters requiring validation throw . + /// + /// The 1st argument that takes validation. + /// The 2nd argument that takes validation. + /// The 3rd argument that takes validation. + /// The 4th argument that takes validation. + /// The 5th argument that takes validation. + /// The 6th argument that takes validation. + /// The 7th argument that takes validation. + /// The 8th argument that takes validation. + /// The 9th argument that takes validation. + /// The 10th argument that takes validation. + /// + /// The name of the parameter expected to throw an exception. + /// void ThrowsArgumentException( TArg1 arg1, TArg2 arg2, @@ -134,6 +339,20 @@ void ThrowsArgumentException( string expectedParameterNameForException); } + /// + /// Unit Tests for methods that contain sixteen parameters that need validation. + /// + /// Type for the 1st argument. + /// Type for the 2nd argument. + /// Type for the 3rd argument. + /// Type for the 4th argument. + /// Type for the 5th argument. + /// Type for the 6th argument. + /// Type for the 7th argument. + /// Type for the 8th argument. + /// Type for the 9th argument. + /// Type for the 10th argument. + /// Type for the 11th argument. public interface ITestMethodWithParameterValidation< in TArg1, in TArg2, @@ -147,6 +366,23 @@ public interface ITestMethodWithParameterValidation< in TArg10, in TArg11> { + /// + /// Check to ensure parameters requiring validation throw . + /// + /// The 1st argument that takes validation. + /// The 2nd argument that takes validation. + /// The 3rd argument that takes validation. + /// The 4th argument that takes validation. + /// The 5th argument that takes validation. + /// The 6th argument that takes validation. + /// The 7th argument that takes validation. + /// The 8th argument that takes validation. + /// The 9th argument that takes validation. + /// The 10th argument that takes validation. + /// The 11th argument that takes validation. + /// + /// The name of the parameter expected to throw an exception. + /// void ThrowsArgumentException( TArg1 arg1, TArg2 arg2, @@ -162,6 +398,21 @@ void ThrowsArgumentException( string expectedParameterNameForException); } + /// + /// Unit Tests for methods that contain sixteen parameters that need validation. + /// + /// Type for the 1st argument. + /// Type for the 2nd argument. + /// Type for the 3rd argument. + /// Type for the 4th argument. + /// Type for the 5th argument. + /// Type for the 6th argument. + /// Type for the 7th argument. + /// Type for the 8th argument. + /// Type for the 9th argument. + /// Type for the 10th argument. + /// Type for the 11th argument. + /// Type for the 12th argument. public interface ITestMethodWithParameterValidation< in TArg1, in TArg2, @@ -176,6 +427,24 @@ public interface ITestMethodWithParameterValidation< in TArg11, in TArg12> { + /// + /// Check to ensure parameters requiring validation throw . + /// + /// The 1st argument that takes validation. + /// The 2nd argument that takes validation. + /// The 3rd argument that takes validation. + /// The 4th argument that takes validation. + /// The 5th argument that takes validation. + /// The 6th argument that takes validation. + /// The 7th argument that takes validation. + /// The 8th argument that takes validation. + /// The 9th argument that takes validation. + /// The 10th argument that takes validation. + /// The 11th argument that takes validation. + /// The 12th argument that takes validation. + /// + /// The name of the parameter expected to throw an exception. + /// void ThrowsArgumentException( TArg1 arg1, TArg2 arg2, @@ -192,6 +461,22 @@ void ThrowsArgumentException( string expectedParameterNameForException); } + /// + /// Unit Tests for methods that contain sixteen parameters that need validation. + /// + /// Type for the 1st argument. + /// Type for the 2nd argument. + /// Type for the 3rd argument. + /// Type for the 4th argument. + /// Type for the 5th argument. + /// Type for the 6th argument. + /// Type for the 7th argument. + /// Type for the 8th argument. + /// Type for the 9th argument. + /// Type for the 10th argument. + /// Type for the 11th argument. + /// Type for the 12th argument. + /// Type for the 13th argument. public interface ITestMethodWithParameterValidation< in TArg1, in TArg2, @@ -207,6 +492,25 @@ public interface ITestMethodWithParameterValidation< in TArg12, in TArg13> { + /// + /// Check to ensure parameters requiring validation throw . + /// + /// The 1st argument that takes validation. + /// The 2nd argument that takes validation. + /// The 3rd argument that takes validation. + /// The 4th argument that takes validation. + /// The 5th argument that takes validation. + /// The 6th argument that takes validation. + /// The 7th argument that takes validation. + /// The 8th argument that takes validation. + /// The 9th argument that takes validation. + /// The 10th argument that takes validation. + /// The 11th argument that takes validation. + /// The 12th argument that takes validation. + /// The 13th argument that takes validation. + /// + /// The name of the parameter expected to throw an exception. + /// void ThrowsArgumentException( TArg1 arg1, TArg2 arg2, @@ -224,6 +528,23 @@ void ThrowsArgumentException( string expectedParameterNameForException); } + /// + /// Unit Tests for methods that contain sixteen parameters that need validation. + /// + /// Type for the 1st argument. + /// Type for the 2nd argument. + /// Type for the 3rd argument. + /// Type for the 4th argument. + /// Type for the 5th argument. + /// Type for the 6th argument. + /// Type for the 7th argument. + /// Type for the 8th argument. + /// Type for the 9th argument. + /// Type for the 10th argument. + /// Type for the 11th argument. + /// Type for the 12th argument. + /// Type for the 13th argument. + /// Type for the 14th argument. public interface ITestMethodWithParameterValidation< in TArg1, in TArg2, @@ -240,6 +561,26 @@ public interface ITestMethodWithParameterValidation< in TArg13, in TArg14> { + /// + /// Check to ensure parameters requiring validation throw . + /// + /// The 1st argument that takes validation. + /// The 2nd argument that takes validation. + /// The 3rd argument that takes validation. + /// The 4th argument that takes validation. + /// The 5th argument that takes validation. + /// The 6th argument that takes validation. + /// The 7th argument that takes validation. + /// The 8th argument that takes validation. + /// The 9th argument that takes validation. + /// The 10th argument that takes validation. + /// The 11th argument that takes validation. + /// The 12th argument that takes validation. + /// The 13th argument that takes validation. + /// The 14th argument that takes validation. + /// + /// The name of the parameter expected to throw an exception. + /// void ThrowsArgumentException( TArg1 arg1, TArg2 arg2, @@ -258,6 +599,24 @@ void ThrowsArgumentException( string expectedParameterNameForException); } + /// + /// Unit Tests for methods that contain sixteen parameters that need validation. + /// + /// Type for the 1st argument. + /// Type for the 2nd argument. + /// Type for the 3rd argument. + /// Type for the 4th argument. + /// Type for the 5th argument. + /// Type for the 6th argument. + /// Type for the 7th argument. + /// Type for the 8th argument. + /// Type for the 9th argument. + /// Type for the 10th argument. + /// Type for the 11th argument. + /// Type for the 12th argument. + /// Type for the 13th argument. + /// Type for the 14th argument. + /// Type for the 15th argument. public interface ITestMethodWithParameterValidation< in TArg1, in TArg2, @@ -275,6 +634,27 @@ public interface ITestMethodWithParameterValidation< in TArg14, in TArg15> { + /// + /// Check to ensure parameters requiring validation throw . + /// + /// The 1st argument that takes validation. + /// The 2nd argument that takes validation. + /// The 3rd argument that takes validation. + /// The 4th argument that takes validation. + /// The 5th argument that takes validation. + /// The 6th argument that takes validation. + /// The 7th argument that takes validation. + /// The 8th argument that takes validation. + /// The 9th argument that takes validation. + /// The 10th argument that takes validation. + /// The 11th argument that takes validation. + /// The 12th argument that takes validation. + /// The 13th argument that takes validation. + /// The 14th argument that takes validation. + /// The 15th argument that takes validation. + /// + /// The name of the parameter expected to throw an exception. + /// void ThrowsArgumentException( TArg1 arg1, TArg2 arg2, @@ -294,6 +674,25 @@ void ThrowsArgumentException( string expectedParameterNameForException); } + /// + /// Unit Tests for methods that contain sixteen parameters that need validation. + /// + /// Type for the 1st argument. + /// Type for the 2nd argument. + /// Type for the 3rd argument. + /// Type for the 4th argument. + /// Type for the 5th argument. + /// Type for the 6th argument. + /// Type for the 7th argument. + /// Type for the 8th argument. + /// Type for the 9th argument. + /// Type for the 10th argument. + /// Type for the 11th argument. + /// Type for the 12th argument. + /// Type for the 13th argument. + /// Type for the 14th argument. + /// Type for the 15th argument. + /// Type for the 16th argument. public interface ITestMethodWithParameterValidation< in TArg1, in TArg2, @@ -312,6 +711,28 @@ public interface ITestMethodWithParameterValidation< in TArg15, in TArg16> { + /// + /// Check to ensure parameters requiring validation throw . + /// + /// The 1st argument that takes validation. + /// The 2nd argument that takes validation. + /// The 3rd argument that takes validation. + /// The 4th argument that takes validation. + /// The 5th argument that takes validation. + /// The 6th argument that takes validation. + /// The 7th argument that takes validation. + /// The 8th argument that takes validation. + /// The 9th argument that takes validation. + /// The 10th argument that takes validation. + /// The 11th argument that takes validation. + /// The 12th argument that takes validation. + /// The 13th argument that takes validation. + /// The 14th argument that takes validation. + /// The 15th argument that takes validation. + /// The 16th argument that takes validation. + /// + /// The name of the parameter expected to throw an exception. + /// void ThrowsArgumentException( TArg1 arg1, TArg2 arg2, @@ -331,4 +752,5 @@ void ThrowsArgumentException( TArg16 arg16, string expectedParameterNameForException); } -} \ No newline at end of file +#pragma warning restore SA1402 // File may only contain a single type +} diff --git a/src/NetTestRegimentation/ITestMethodWithRangeParameters.cs b/src/NetTestRegimentation/ITestMethodWithRangeParameters.cs index 19d7931..f782d6f 100644 --- a/src/NetTestRegimentation/ITestMethodWithRangeParameters.cs +++ b/src/NetTestRegimentation/ITestMethodWithRangeParameters.cs @@ -1,22 +1,77 @@ +// Copyright (c) 2019 dpvreony and Contributors. All rights reserved. +// This file is licensed to you under the MIT license. +// See the LICENSE file in the project root for full license information. + namespace NetTestRegimentation { +#pragma warning disable SA1402 // File may only contain a single type + /// + /// Unit Tests for a method that takes arguments that need range validation. + /// + public interface ITestMethodWithRangeParameters + { + /// + /// Check to ensure nullable parameters throw . + /// + void ThrowsArgumentOutOfRangeException(); + } + + /// + /// Unit Tests for a method that takes 1 parameter that needs range validation. + /// + /// Type for the argument. public interface ITestMethodWithRangeParameters { + /// + /// Check to ensure parameters requiring validation throw . + /// + /// The argument that takes validation. + /// + /// The name of the parameter expected to throw an exception. + /// void ThrowsArgumentOutOfRangeException( TArg arg, string expectedParameterNameForException); } + /// + /// Unit Tests for a method that takes 2 that need range validation. + /// + /// Type for the 1st argument. + /// Type for the 2nd argument. public interface ITestMethodWithRangeParameters { + /// + /// Check to ensure parameters requiring validation throw . + /// + /// The 1st argument that takes validation. + /// The 2nd argument that takes validation. + /// + /// The name of the parameter expected to throw an exception. + /// void ThrowsArgumentOutOfRangeException( TArg1 arg1, TArg2 arg2, string expectedParameterNameForException); } + /// + /// Unit Tests for a method that takes 3 that need range validation. + /// + /// Type for the 1st argument. + /// Type for the 2nd argument. + /// Type for the 3rd argument. public interface ITestMethodWithRangeParameters { + /// + /// Check to ensure parameters requiring validation throw . + /// + /// The 1st argument that takes validation. + /// The 2nd argument that takes validation. + /// The 3rd argument that takes validation. + /// + /// The name of the parameter expected to throw an exception. + /// void ThrowsArgumentOutOfRangeException( TArg1 arg1, TArg2 arg2, @@ -24,8 +79,25 @@ void ThrowsArgumentOutOfRangeException( string expectedParameterNameForException); } + /// + /// Unit Tests for a method that takes 4 that need range validation. + /// + /// Type for the 1st argument. + /// Type for the 2nd argument. + /// Type for the 3rd argument. + /// Type for the 4th argument. public interface ITestMethodWithRangeParameters { + /// + /// Check to ensure parameters requiring validation throw . + /// + /// The 1st argument that takes validation. + /// The 2nd argument that takes validation. + /// The 3rd argument that takes validation. + /// The 4th argument that takes validation. + /// + /// The name of the parameter expected to throw an exception. + /// void ThrowsArgumentOutOfRangeException( TArg1 arg1, TArg2 arg2, @@ -34,8 +106,27 @@ void ThrowsArgumentOutOfRangeException( string expectedParameterNameForException); } + /// + /// Unit Tests for a method that takes 5 that need range validation. + /// + /// Type for the 1st argument. + /// Type for the 2nd argument. + /// Type for the 3rd argument. + /// Type for the 4th argument. + /// Type for the 5th argument. public interface ITestMethodWithRangeParameters { + /// + /// Check to ensure parameters requiring validation throw . + /// + /// The 1st argument that takes validation. + /// The 2nd argument that takes validation. + /// The 3rd argument that takes validation. + /// The 4th argument that takes validation. + /// The 5th argument that takes validation. + /// + /// The name of the parameter expected to throw an exception. + /// void ThrowsArgumentOutOfRangeException( TArg1 arg1, TArg2 arg2, @@ -45,8 +136,29 @@ void ThrowsArgumentOutOfRangeException( string expectedParameterNameForException); } + /// + /// Unit Tests for a method that takes 6 that need range validation. + /// + /// Type for the 1st argument. + /// Type for the 2nd argument. + /// Type for the 3rd argument. + /// Type for the 4th argument. + /// Type for the 5th argument. + /// Type for the 6th argument. public interface ITestMethodWithRangeParameters { + /// + /// Check to ensure parameters requiring validation throw . + /// + /// The 1st argument that takes validation. + /// The 2nd argument that takes validation. + /// The 3rd argument that takes validation. + /// The 4th argument that takes validation. + /// The 5th argument that takes validation. + /// The 6th argument that takes validation. + /// + /// The name of the parameter expected to throw an exception. + /// void ThrowsArgumentOutOfRangeException( TArg1 arg1, TArg2 arg2, @@ -57,8 +169,31 @@ void ThrowsArgumentOutOfRangeException( string expectedParameterNameForException); } + /// + /// Unit Tests for a method that takes 7 that need range validation. + /// + /// Type for the 1st argument. + /// Type for the 2nd argument. + /// Type for the 3rd argument. + /// Type for the 4th argument. + /// Type for the 5th argument. + /// Type for the 6th argument. + /// Type for the 7th argument. public interface ITestMethodWithRangeParameters { + /// + /// Check to ensure parameters requiring validation throw . + /// + /// The 1st argument that takes validation. + /// The 2nd argument that takes validation. + /// The 3rd argument that takes validation. + /// The 4th argument that takes validation. + /// The 5th argument that takes validation. + /// The 6th argument that takes validation. + /// The 7th argument that takes validation. + /// + /// The name of the parameter expected to throw an exception. + /// void ThrowsArgumentOutOfRangeException( TArg1 arg1, TArg2 arg2, @@ -70,8 +205,33 @@ void ThrowsArgumentOutOfRangeException( string expectedParameterNameForException); } + /// + /// Unit Tests for a method that takes 8 that need range validation. + /// + /// Type for the 1st argument. + /// Type for the 2nd argument. + /// Type for the 3rd argument. + /// Type for the 4th argument. + /// Type for the 5th argument. + /// Type for the 6th argument. + /// Type for the 7th argument. + /// Type for the 8th argument. public interface ITestMethodWithRangeParameters { + /// + /// Check to ensure parameters requiring validation throw . + /// + /// The 1st argument that takes validation. + /// The 2nd argument that takes validation. + /// The 3rd argument that takes validation. + /// The 4th argument that takes validation. + /// The 5th argument that takes validation. + /// The 6th argument that takes validation. + /// The 7th argument that takes validation. + /// The 8th argument that takes validation. + /// + /// The name of the parameter expected to throw an exception. + /// void ThrowsArgumentOutOfRangeException( TArg1 arg1, TArg2 arg2, @@ -84,6 +244,18 @@ void ThrowsArgumentOutOfRangeException( string expectedParameterNameForException); } + /// + /// Unit Tests for a method that takes 9 that need range validation. + /// + /// Type for the 1st argument. + /// Type for the 2nd argument. + /// Type for the 3rd argument. + /// Type for the 4th argument. + /// Type for the 5th argument. + /// Type for the 6th argument. + /// Type for the 7th argument. + /// Type for the 8th argument. + /// Type for the 9th argument. public interface ITestMethodWithRangeParameters< in TArg1, in TArg2, @@ -95,6 +267,21 @@ public interface ITestMethodWithRangeParameters< in TArg8, in TArg9> { + /// + /// Check to ensure parameters requiring validation throw . + /// + /// The 1st argument that takes validation. + /// The 2nd argument that takes validation. + /// The 3rd argument that takes validation. + /// The 4th argument that takes validation. + /// The 5th argument that takes validation. + /// The 6th argument that takes validation. + /// The 7th argument that takes validation. + /// The 8th argument that takes validation. + /// The 9th argument that takes validation. + /// + /// The name of the parameter expected to throw an exception. + /// void ThrowsArgumentOutOfRangeException( TArg1 arg1, TArg2 arg2, @@ -108,6 +295,19 @@ void ThrowsArgumentOutOfRangeException( string expectedParameterNameForException); } + /// + /// Unit Tests for a method that takes 10 that need range validation. + /// + /// Type for the 1st argument. + /// Type for the 2nd argument. + /// Type for the 3rd argument. + /// Type for the 4th argument. + /// Type for the 5th argument. + /// Type for the 6th argument. + /// Type for the 7th argument. + /// Type for the 8th argument. + /// Type for the 9th argument. + /// Type for the 10th argument. public interface ITestMethodWithRangeParameters< in TArg1, in TArg2, @@ -120,6 +320,22 @@ public interface ITestMethodWithRangeParameters< in TArg9, in TArg10> { + /// + /// Check to ensure parameters requiring validation throw . + /// + /// The 1st argument that takes validation. + /// The 2nd argument that takes validation. + /// The 3rd argument that takes validation. + /// The 4th argument that takes validation. + /// The 5th argument that takes validation. + /// The 6th argument that takes validation. + /// The 7th argument that takes validation. + /// The 8th argument that takes validation. + /// The 9th argument that takes validation. + /// The 10th argument that takes validation. + /// + /// The name of the parameter expected to throw an exception. + /// void ThrowsArgumentOutOfRangeException( TArg1 arg1, TArg2 arg2, @@ -134,6 +350,20 @@ void ThrowsArgumentOutOfRangeException( string expectedParameterNameForException); } + /// + /// Unit Tests for a method that takes 11 that need range validation. + /// + /// Type for the 1st argument. + /// Type for the 2nd argument. + /// Type for the 3rd argument. + /// Type for the 4th argument. + /// Type for the 5th argument. + /// Type for the 6th argument. + /// Type for the 7th argument. + /// Type for the 8th argument. + /// Type for the 9th argument. + /// Type for the 10th argument. + /// Type for the 11th argument. public interface ITestMethodWithRangeParameters< in TArg1, in TArg2, @@ -147,6 +377,23 @@ public interface ITestMethodWithRangeParameters< in TArg10, in TArg11> { + /// + /// Check to ensure parameters requiring validation throw . + /// + /// The 1st argument that takes validation. + /// The 2nd argument that takes validation. + /// The 3rd argument that takes validation. + /// The 4th argument that takes validation. + /// The 5th argument that takes validation. + /// The 6th argument that takes validation. + /// The 7th argument that takes validation. + /// The 8th argument that takes validation. + /// The 9th argument that takes validation. + /// The 10th argument that takes validation. + /// The 11th argument that takes validation. + /// + /// The name of the parameter expected to throw an exception. + /// void ThrowsArgumentOutOfRangeException( TArg1 arg1, TArg2 arg2, @@ -162,6 +409,21 @@ void ThrowsArgumentOutOfRangeException( string expectedParameterNameForException); } + /// + /// Unit Tests for a method that takes 12 that need range validation. + /// + /// Type for the 1st argument. + /// Type for the 2nd argument. + /// Type for the 3rd argument. + /// Type for the 4th argument. + /// Type for the 5th argument. + /// Type for the 6th argument. + /// Type for the 7th argument. + /// Type for the 8th argument. + /// Type for the 9th argument. + /// Type for the 10th argument. + /// Type for the 11th argument. + /// Type for the 12th argument. public interface ITestMethodWithRangeParameters< in TArg1, in TArg2, @@ -176,6 +438,24 @@ public interface ITestMethodWithRangeParameters< in TArg11, in TArg12> { + /// + /// Check to ensure parameters requiring validation throw . + /// + /// The 1st argument that takes validation. + /// The 2nd argument that takes validation. + /// The 3rd argument that takes validation. + /// The 4th argument that takes validation. + /// The 5th argument that takes validation. + /// The 6th argument that takes validation. + /// The 7th argument that takes validation. + /// The 8th argument that takes validation. + /// The 9th argument that takes validation. + /// The 10th argument that takes validation. + /// The 11th argument that takes validation. + /// The 12th argument that takes validation. + /// + /// The name of the parameter expected to throw an exception. + /// void ThrowsArgumentOutOfRangeException( TArg1 arg1, TArg2 arg2, @@ -192,6 +472,22 @@ void ThrowsArgumentOutOfRangeException( string expectedParameterNameForException); } + /// + /// Unit Tests for a method that takes 13 that need range validation. + /// + /// Type for the 1st argument. + /// Type for the 2nd argument. + /// Type for the 3rd argument. + /// Type for the 4th argument. + /// Type for the 5th argument. + /// Type for the 6th argument. + /// Type for the 7th argument. + /// Type for the 8th argument. + /// Type for the 9th argument. + /// Type for the 10th argument. + /// Type for the 11th argument. + /// Type for the 12th argument. + /// Type for the 13th argument. public interface ITestMethodWithRangeParameters< in TArg1, in TArg2, @@ -207,6 +503,25 @@ public interface ITestMethodWithRangeParameters< in TArg12, in TArg13> { + /// + /// Check to ensure parameters requiring validation throw . + /// + /// The 1st argument that takes validation. + /// The 2nd argument that takes validation. + /// The 3rd argument that takes validation. + /// The 4th argument that takes validation. + /// The 5th argument that takes validation. + /// The 6th argument that takes validation. + /// The 7th argument that takes validation. + /// The 8th argument that takes validation. + /// The 9th argument that takes validation. + /// The 10th argument that takes validation. + /// The 11th argument that takes validation. + /// The 12th argument that takes validation. + /// The 13th argument that takes validation. + /// + /// The name of the parameter expected to throw an exception. + /// void ThrowsArgumentOutOfRangeException( TArg1 arg1, TArg2 arg2, @@ -224,6 +539,23 @@ void ThrowsArgumentOutOfRangeException( string expectedParameterNameForException); } + /// + /// Unit Tests for a method that takes 14 that need range validation. + /// + /// Type for the 1st argument. + /// Type for the 2nd argument. + /// Type for the 3rd argument. + /// Type for the 4th argument. + /// Type for the 5th argument. + /// Type for the 6th argument. + /// Type for the 7th argument. + /// Type for the 8th argument. + /// Type for the 9th argument. + /// Type for the 10th argument. + /// Type for the 11th argument. + /// Type for the 12th argument. + /// Type for the 13th argument. + /// Type for the 14th argument. public interface ITestMethodWithRangeParameters< in TArg1, in TArg2, @@ -240,6 +572,26 @@ public interface ITestMethodWithRangeParameters< in TArg13, in TArg14> { + /// + /// Check to ensure parameters requiring validation throw . + /// + /// The 1st argument that takes validation. + /// The 2nd argument that takes validation. + /// The 3rd argument that takes validation. + /// The 4th argument that takes validation. + /// The 5th argument that takes validation. + /// The 6th argument that takes validation. + /// The 7th argument that takes validation. + /// The 8th argument that takes validation. + /// The 9th argument that takes validation. + /// The 10th argument that takes validation. + /// The 11th argument that takes validation. + /// The 12th argument that takes validation. + /// The 13th argument that takes validation. + /// The 14th argument that takes validation. + /// + /// The name of the parameter expected to throw an exception. + /// void ThrowsArgumentOutOfRangeException( TArg1 arg1, TArg2 arg2, @@ -258,6 +610,24 @@ void ThrowsArgumentOutOfRangeException( string expectedParameterNameForException); } + /// + /// Unit Tests for a method that takes 15 that need range validation. + /// + /// Type for the 1st argument. + /// Type for the 2nd argument. + /// Type for the 3rd argument. + /// Type for the 4th argument. + /// Type for the 5th argument. + /// Type for the 6th argument. + /// Type for the 7th argument. + /// Type for the 8th argument. + /// Type for the 9th argument. + /// Type for the 10th argument. + /// Type for the 11th argument. + /// Type for the 12th argument. + /// Type for the 13th argument. + /// Type for the 14th argument. + /// Type for the 15th argument. public interface ITestMethodWithRangeParameters< in TArg1, in TArg2, @@ -275,6 +645,27 @@ public interface ITestMethodWithRangeParameters< in TArg14, in TArg15> { + /// + /// Check to ensure parameters requiring validation throw . + /// + /// The 1st argument that takes validation. + /// The 2nd argument that takes validation. + /// The 3rd argument that takes validation. + /// The 4th argument that takes validation. + /// The 5th argument that takes validation. + /// The 6th argument that takes validation. + /// The 7th argument that takes validation. + /// The 8th argument that takes validation. + /// The 9th argument that takes validation. + /// The 10th argument that takes validation. + /// The 11th argument that takes validation. + /// The 12th argument that takes validation. + /// The 13th argument that takes validation. + /// The 14th argument that takes validation. + /// The 15th argument that takes validation. + /// + /// The name of the parameter expected to throw an exception. + /// void ThrowsArgumentOutOfRangeException( TArg1 arg1, TArg2 arg2, @@ -294,6 +685,25 @@ void ThrowsArgumentOutOfRangeException( string expectedParameterNameForException); } + /// + /// Unit Tests for a method that takes 16 parameters that need range validation. + /// + /// Type for the 1st argument. + /// Type for the 2nd argument. + /// Type for the 3rd argument. + /// Type for the 4th argument. + /// Type for the 5th argument. + /// Type for the 6th argument. + /// Type for the 7th argument. + /// Type for the 8th argument. + /// Type for the 9th argument. + /// Type for the 10th argument. + /// Type for the 11th argument. + /// Type for the 12th argument. + /// Type for the 13th argument. + /// Type for the 14th argument. + /// Type for the 15th argument. + /// Type for the 16th argument. public interface ITestMethodWithRangeParameters< in TArg1, in TArg2, @@ -312,6 +722,28 @@ public interface ITestMethodWithRangeParameters< in TArg15, in TArg16> { + /// + /// Check to ensure parameters requiring validation throw . + /// + /// The 1st argument that takes validation. + /// The 2nd argument that takes validation. + /// The 3rd argument that takes validation. + /// The 4th argument that takes validation. + /// The 5th argument that takes validation. + /// The 6th argument that takes validation. + /// The 7th argument that takes validation. + /// The 8th argument that takes validation. + /// The 9th argument that takes validation. + /// The 10th argument that takes validation. + /// The 11th argument that takes validation. + /// The 12th argument that takes validation. + /// The 13th argument that takes validation. + /// The 14th argument that takes validation. + /// The 15th argument that takes validation. + /// The 16th argument that takes validation. + /// + /// The name of the parameter expected to throw an exception. + /// void ThrowsArgumentOutOfRangeException( TArg1 arg1, TArg2 arg2, @@ -331,5 +763,5 @@ void ThrowsArgumentOutOfRangeException( TArg16 arg16, string expectedParameterNameForException); } - +#pragma warning restore SA1402 // File may only contain a single type } diff --git a/src/docfx_project/.gitignore b/src/docfx_project/.gitignore new file mode 100644 index 0000000..4378419 --- /dev/null +++ b/src/docfx_project/.gitignore @@ -0,0 +1,9 @@ +############### +# folder # +############### +/**/DROP/ +/**/TEMP/ +/**/packages/ +/**/bin/ +/**/obj/ +_site diff --git a/src/docfx_project/api/.gitignore b/src/docfx_project/api/.gitignore new file mode 100644 index 0000000..e8079a3 --- /dev/null +++ b/src/docfx_project/api/.gitignore @@ -0,0 +1,5 @@ +############### +# temp file # +############### +*.yml +.manifest diff --git a/src/docfx_project/api/index.md b/src/docfx_project/api/index.md new file mode 100644 index 0000000..78dc9c0 --- /dev/null +++ b/src/docfx_project/api/index.md @@ -0,0 +1,2 @@ +# PLACEHOLDER +TODO: Add .NET projects to the *src* folder and run `docfx` to generate **REAL** *API Documentation*! diff --git a/src/docfx_project/articles/intro.md b/src/docfx_project/articles/intro.md new file mode 100644 index 0000000..c0478ce --- /dev/null +++ b/src/docfx_project/articles/intro.md @@ -0,0 +1 @@ +# Add your introductions here! diff --git a/src/docfx_project/articles/toc.yml b/src/docfx_project/articles/toc.yml new file mode 100644 index 0000000..ff89ef1 --- /dev/null +++ b/src/docfx_project/articles/toc.yml @@ -0,0 +1,2 @@ +- name: Introduction + href: intro.md diff --git a/src/docfx_project/docfx.json b/src/docfx_project/docfx.json new file mode 100644 index 0000000..ee5620c --- /dev/null +++ b/src/docfx_project/docfx.json @@ -0,0 +1,64 @@ +{ + "metadata": [ + { + "src": [ + { + "files": [ + "../src/**.csproj" + ] + } + ], + "dest": "api", + "disableGitFeatures": false, + "disableDefaultFilter": false + } + ], + "build": { + "content": [ + { + "files": [ + "api/**.yml", + "api/index.md" + ] + }, + { + "files": [ + "articles/**.md", + "articles/**/toc.yml", + "toc.yml", + "*.md" + ] + } + ], + "resource": [ + { + "files": [ + "images/**" + ] + } + ], + "overwrite": [ + { + "files": [ + "apidoc/**.md" + ], + "exclude": [ + "obj/**", + "_site/**" + ] + } + ], + "dest": "_site", + "globalMetadataFiles": [], + "fileMetadataFiles": [], + "template": [ + "default" + ], + "postProcessors": [], + "markdownEngineName": "markdig", + "noLangKeyword": false, + "keepFileLink": false, + "cleanupCacheHistory": false, + "disableGitFeatures": false + } +} \ No newline at end of file diff --git a/src/docfx_project/index.md b/src/docfx_project/index.md new file mode 100644 index 0000000..3ae2506 --- /dev/null +++ b/src/docfx_project/index.md @@ -0,0 +1,4 @@ +# This is the **HOMEPAGE**. +Refer to [Markdown](http://daringfireball.net/projects/markdown/) for how to write markdown files. +## Quick Start Notes: +1. Add images to the *images* folder if the file is referencing an image. diff --git a/src/docfx_project/toc.yml b/src/docfx_project/toc.yml new file mode 100644 index 0000000..59f8010 --- /dev/null +++ b/src/docfx_project/toc.yml @@ -0,0 +1,5 @@ +- name: Articles + href: articles/ +- name: Api Documentation + href: api/ + homepage: api/index.md diff --git a/src/stylecop.json b/src/stylecop.json index 247267d..ee8cdf5 100644 --- a/src/stylecop.json +++ b/src/stylecop.json @@ -36,6 +36,6 @@ "orderingRules": { "usingDirectivesPlacement": "outsideNamespace", "systemUsingDirectivesFirst": true - }, + } } }