From 9b4cf94e0ac256772d35fefc490c15f96c776369 Mon Sep 17 00:00:00 2001
From: DavoudEshtehari <61173489+DavoudEshtehari@users.noreply.github.com>
Date: Wed, 28 Apr 2021 11:15:55 -0700
Subject: [PATCH] Improve configurable retry logic tests (#1026)

---
 BUILDGUIDE.md                                 | 123 +++++-----
 build.proj                                    |   1 +
 src/Microsoft.Data.SqlClient.sln              |   3 +
 .../CustomConfigurableRetryLogic.cs           |   6 +-
 .../CustomRetryLogicProvider.csproj           |  24 ++
 .../ManualTests/DataCommon/DataTestUtility.cs |   2 -
 ....Data.SqlClient.ManualTesting.Tests.csproj |  22 +-
 ...ssLibrary_CustomConfigurableRetryLogic.dll | Bin 10240 -> 0 bytes
 ...ssLibrary_CustomConfigurableRetryLogic.dll | Bin 10240 -> 0 bytes
 .../RetryLogic/SqlCommandReliabilityTest.cs   | 214 +++++++++---------
 .../SqlConfigurationManagerReliabilityTest.cs |  32 +--
 11 files changed, 230 insertions(+), 197 deletions(-)
 rename src/Microsoft.Data.SqlClient/tests/{ManualTests/SQL/RetryLogic/Resources => CustomConfigurableRetryLogic}/CustomConfigurableRetryLogic.cs (94%)
 create mode 100644 src/Microsoft.Data.SqlClient/tests/CustomConfigurableRetryLogic/CustomRetryLogicProvider.csproj
 delete mode 100644 src/Microsoft.Data.SqlClient/tests/ManualTests/SQL/RetryLogic/Resources/netcoreapp/ClassLibrary_CustomConfigurableRetryLogic.dll
 delete mode 100644 src/Microsoft.Data.SqlClient/tests/ManualTests/SQL/RetryLogic/Resources/netfx/ClassLibrary_CustomConfigurableRetryLogic.dll

diff --git a/BUILDGUIDE.md b/BUILDGUIDE.md
index abb3f31e86..5a7d0080e1 100644
--- a/BUILDGUIDE.md
+++ b/BUILDGUIDE.md
@@ -21,12 +21,12 @@ Once the environment is setup properly, execute the desired set of commands belo
 
 ```bash
 > msbuild /p:Configuration=Release
-# Builds the driver in 'Release' Configuration.
+# Builds the driver in 'Release' Configuration for `AnyCPU` platform.
 ```
 
 ```bash
 > msbuild /p:Platform=Win32
-# Builds the .NET Framework  (NetFx) driver for Win32 (x86) platform on Windows.
+# Builds the .NET Framework (NetFx) driver for Win32 (x86) platform on Windows in 'Debug' Configuration.
 ```
 
 ```bash
@@ -64,35 +64,37 @@ Once the environment is setup properly, execute the desired set of commands belo
 
 ```bash
 > msbuild /t:BuildTestsNetCore
-# Build the tests for the .NET Core driver. Default .NET Core version is 2.1.
+# Build the tests for the .NET Core driver in 'Debug' Configuration. Default .NET Core version is 2.1.
 ```
 
 ```bash
 > msbuild /t:BuildTestsNetFx
-# Build the tests for the .NET Framework (NetFx) driver. Default .NET Framework version is 4.6.
+# Build the tests for the .NET Framework (NetFx) driver in 'Debug' Configuration. Default .NET Framework version is 4.6.1.
 ```
 
 ## Run Functional Tests
 
-Windows (`netfx x86`):
-```bash
-> dotnet test "src\Microsoft.Data.SqlClient\tests\FunctionalTests\Microsoft.Data.SqlClient.Tests.csproj" /p:Platform="Win32" /p:Configuration="Release" /p:TestTargetOS="Windowsnetfx" --no-build -v n --filter "category!=nonnetfxtests&category!=failing&category!=nonwindowstests"
-```
+- Windows (`netfx x86`):
+  ```bash
+  > dotnet test "src\Microsoft.Data.SqlClient\tests\FunctionalTests\Microsoft.Data.SqlClient.Tests.csproj" /p:Platform="Win32" /p:Configuration="Release" /p:TestTargetOS="Windowsnetfx" --no-build -v n --filter "category!=nonnetfxtests&category!=failing&category!=nonwindowstests"
+  ```
 
-Windows (`netfx x64`):
-```bash
-> dotnet test "src\Microsoft.Data.SqlClient\tests\FunctionalTests\Microsoft.Data.SqlClient.Tests.csproj" /p:Platform="x64" /p:Configuration="Release" /p:TestTargetOS="Windowsnetfx" --no-build -v n --filter "category!=nonnetfxtests&category!=failing&category!=nonwindowstests"
-```
+- Windows (`netfx x64`):
+  ```bash
+  > dotnet test "src\Microsoft.Data.SqlClient\tests\FunctionalTests\Microsoft.Data.SqlClient.Tests.csproj" /p:Platform="x64" /p:Configuration="Release" /p:TestTargetOS="Windowsnetfx" --no-build -v n --filter "category!=nonnetfxtests&category!=failing&category!=nonwindowstests"
+  ```
 
-Windows (`netcoreapp`):
-```bash
-> dotnet test "src\Microsoft.Data.SqlClient\tests\FunctionalTests\Microsoft.Data.SqlClient.Tests.csproj" /p:Platform="AnyCPU" /p:Configuration="Release" /p:TestTargetOS="Windowsnetcoreapp" --no-build -v n --filter "category!=nonnetcoreapptests&category!=failing&category!=nonwindowstests"
-```
+- AnyCPU:
 
-Unix (`netcoreapp`):
-```bash
-> dotnet test "src/Microsoft.Data.SqlClient/tests/FunctionalTests/Microsoft.Data.SqlClient.Tests.csproj" /p:Platform="AnyCPU" /p:Configuration="Release" /p:TestTargetOS="Unixnetcoreapp" --no-build -v n --filter "category!=nonnetcoreapptests&category!=failing&category!=nonlinuxtests&category!=nonuaptests"
-```
+  Windows (`netcoreapp`):
+  ```bash
+  > dotnet test "src\Microsoft.Data.SqlClient\tests\FunctionalTests\Microsoft.Data.SqlClient.Tests.csproj" /p:Platform="AnyCPU" /p:Configuration="Release" /p:TestTargetOS="Windowsnetcoreapp" --no-build -v n --filter "category!=nonnetcoreapptests&category!=failing&category!=nonwindowstests"
+  ```
+
+  Unix (`netcoreapp`):
+  ```bash
+  > dotnet test "src/Microsoft.Data.SqlClient/tests/FunctionalTests/Microsoft.Data.SqlClient.Tests.csproj" /p:Platform="AnyCPU" /p:Configuration="Release" /p:TestTargetOS="Unixnetcoreapp" --no-build -v n --filter "category!=nonnetcoreapptests&category!=failing&category!=nonlinuxtests&category!=nonuaptests"
+  ```
 
 ## Run Manual Tests
 
@@ -102,46 +104,53 @@ Manual Tests require the below setup to run:
 * Databases "NORTHWIND" and "UdtTestDb" present in SQL Server, created using SQL scripts [createNorthwindDb.sql](tools/testsql/createNorthwindDb.sql) and [createUdtTestDb.sql](tools/testsql/createUdtTestDb.sql). To setup an Azure Database with "NORTHWIND" tables, use SQL Script: [createNorthwindAzureDb.sql](tools/testsql/createNorthwindAzureDb.sql).
 * Make a copy of the configuration file [config.default.json](src/Microsoft.Data.SqlClient/tests/tools/Microsoft.Data.SqlClient.TestUtilities/config.default.json) and rename it to `config.json`. Update the values in `config.json`:
 
-|Property|Description|Value|
-|------|--------|-------------------|
-|TCPConnectionString | Connection String for a TCP enabled SQL Server instance. | `Server={servername};Database={Database_Name};Trusted_Connection=True;` <br/> OR `Data Source={servername};Initial Catalog={Database_Name};Integrated Security=True;`|
-|NPConnectionString | Connection String for a Named Pipes enabled SQL Server instance.| `Server=\\{servername}\pipe\sql\query;Database={Database_Name};Trusted_Connection=True;` <br/> OR <br/> `Data Source=np:{servername};Initial Catalog={Database_Name};Integrated Security=True;`|
-|TCPConnectionStringHGSVBS | (Optional) Connection String for a TCP enabled SQL Server with Host Guardian Service (HGS) attestation protocol configuration. | `Server=tcp:{servername}; Database={Database_Name}; UID={UID}; PWD={PWD}; Attestation Protocol = HGS; Enclave Attestation Url = {AttestationURL};`|
-|AADAuthorityURL | (Optional) Identifies the OAuth2 authority resource for `Server` specified in `AADPasswordConnectionString` | `https://login.windows.net/<tenant>`, where `<tenant>` is the tenant ID of the Azure Active Directory (Azure AD) tenant |
-|AADPasswordConnectionString | (Optional) Connection String for testing Azure Active Directory Password Authentication. | `Data Source={server.database.windows.net}; Initial Catalog={Azure_DB_Name};Authentication=Active Directory Password; User ID={AAD_User}; Password={AAD_User_Password};`|
-|AADSecurePrincipalId | (Optional) The Application Id of a registered application which has been granted permission to the database defined in the AADPasswordConnectionString. | {Application ID} |
-|AADSecurePrincipalSecret | (Optional) A Secret defined for a registered application which has been granted permission to the database defined in the AADPasswordConnectionString. | {Secret} |
-|AzureKeyVaultURL | (Optional) Azure Key Vault Identifier URL | `https://{keyvaultname}.vault.azure.net/` |
-|AzureKeyVaultTenantId | (Optional) The Azure Active Directory tenant (directory) Id of the service principal. | _{Tenant ID of Active Directory}_ |
-|AzureKeyVaultClientId | (Optional) "Application (client) ID" of an Active Directory registered application, granted access to the Azure Key Vault specified in `AZURE_KEY_VAULT_URL`. Requires the key permissions Get, List, Import, Decrypt, Encrypt, Unwrap, Wrap, Verify, and Sign. | _{Client Application ID}_ |
-|AzureKeyVaultClientSecret | (Optional) "Client Secret" of the Active Directory registered application, granted access to the Azure Key Vault specified in `AZURE_KEY_VAULT_URL` | _{Client Application Secret}_ |
-|SupportsLocalDb | (Optional) Whether or not a LocalDb instance of SQL Server is installed on the machine running the tests. |`true` OR `false`|
-|SupportsIntegratedSecurity | (Optional) Whether or not the USER running tests has integrated security access to the target SQL Server.| `true` OR `false`|
-|SupportsFileStream | (Optional) Whether or not FileStream is enabled on SQL Server| `true` OR `false`|
-|UseManagedSNIOnWindows | (Optional) Enables testing with Managed SNI on Windows| `true` OR `false`|
-|IsAzureSynpase | (Optional) When set to 'true', test suite runs compatible tests for Azure Synapse/Parallel Data Warehouse. | `true` OR `false`|
-
-Commands to run tests:
-
-Windows (`netfx x86`):
-```bash
-> dotnet test "src\Microsoft.Data.SqlClient\tests\ManualTests\Microsoft.Data.SqlClient.ManualTesting.Tests.csproj" /p:Platform="Win32" /p:Configuration="Release" /p:TestTargetOS="Windowsnetfx" --no-build -v n --filter "category!=nonnetfxtests&category!=failing&category!=nonwindowstests"
-```
+  |Property|Description|Value|
+  |------|--------|-------------------|
+  |TCPConnectionString | Connection String for a TCP enabled SQL Server instance. | `Server={servername};Database={Database_Name};Trusted_Connection=True;` <br/> OR `Data Source={servername};Initial Catalog={Database_Name};Integrated Security=True;`|
+  |NPConnectionString | Connection String for a Named Pipes enabled SQL Server instance.| `Server=\\{servername}\pipe\sql\query;Database={Database_Name};Trusted_Connection=True;` <br/> OR <br/> `Data Source=np:{servername};Initial Catalog={Database_Name};Integrated Security=True;`|
+  |TCPConnectionStringHGSVBS | (Optional) Connection String for a TCP enabled SQL Server with Host Guardian Service (HGS) attestation protocol configuration. | `Server=tcp:{servername}; Database={Database_Name}; UID={UID}; PWD={PWD}; Attestation Protocol = HGS; Enclave Attestation Url = {AttestationURL};`|
+  |AADAuthorityURL | (Optional) Identifies the OAuth2 authority resource for `Server` specified in `AADPasswordConnectionString` | `https://login.windows.net/<tenant>`, where `<tenant>` is the tenant ID of the Azure Active Directory (Azure AD) tenant |
+  |AADPasswordConnectionString | (Optional) Connection String for testing Azure Active Directory Password Authentication. | `Data Source={server.database.windows.net}; Initial Catalog={Azure_DB_Name};Authentication=Active Directory Password; User ID={AAD_User}; Password={AAD_User_Password};`|
+  |AADSecurePrincipalId | (Optional) The Application Id of a registered application which has been granted permission to the database defined in the AADPasswordConnectionString. | {Application ID} |
+  |AADSecurePrincipalSecret | (Optional) A Secret defined for a registered application which has been granted permission to the database defined in the AADPasswordConnectionString. | {Secret} |
+  |AzureKeyVaultURL | (Optional) Azure Key Vault Identifier URL | `https://{keyvaultname}.vault.azure.net/` |
+  |AzureKeyVaultTenantId | (Optional) The Azure Active Directory tenant (directory) Id of the service principal. | _{Tenant ID of Active Directory}_ |
+  |AzureKeyVaultClientId | (Optional) "Application (client) ID" of an Active Directory registered application, granted access to the Azure Key Vault specified in `AZURE_KEY_VAULT_URL`. Requires the key permissions Get, List, Import, Decrypt, Encrypt, Unwrap, Wrap, Verify, and Sign. | _{Client Application ID}_ |
+  |AzureKeyVaultClientSecret | (Optional) "Client Secret" of the Active Directory registered application, granted access to the Azure Key Vault specified in `AZURE_KEY_VAULT_URL` | _{Client Application Secret}_ |
+  |SupportsLocalDb | (Optional) Whether or not a LocalDb instance of SQL Server is installed on the machine running the tests. |`true` OR `false`|
+  |SupportsIntegratedSecurity | (Optional) Whether or not the USER running tests has integrated security access to the target SQL Server.| `true` OR `false`|
+  |SupportsFileStream | (Optional) Whether or not FileStream is enabled on SQL Server| `true` OR `false`|
+  |UseManagedSNIOnWindows | (Optional) Enables testing with Managed SNI on Windows| `true` OR `false`|
+  |IsAzureSynpase | (Optional) When set to 'true', test suite runs compatible tests for Azure Synapse/Parallel Data Warehouse. | `true` OR `false`|
+
+### Commands to run Manual Tests:
+
+  - Windows (`netfx x86`):
+    ```bash
+    > dotnet test "src\Microsoft.Data.SqlClient\tests\ManualTests\Microsoft.Data.SqlClient.ManualTesting.Tests.csproj" /p:Platform="Win32" /p:Configuration="Release" /p:TestTargetOS="Windowsnetfx" --no-build -v n --filter "category!=nonnetfxtests&category!=failing&category!=nonwindowstests"
+    ```
 
-Windows (`netfx x64`):
-```bash
-> dotnet test "src\Microsoft.Data.SqlClient\tests\ManualTests\Microsoft.Data.SqlClient.ManualTesting.Tests.csproj" /p:Platform="x64" /p:Configuration="Release" /p:TestTargetOS="Windowsnetfx" --no-build -v n --filter "category!=nonnetfxtests&category!=failing&category!=nonwindowstests"
-```
+  - Windows (`netfx x64`):
+    ```bash
+    > dotnet test "src\Microsoft.Data.SqlClient\tests\ManualTests\Microsoft.Data.SqlClient.ManualTesting.Tests.csproj" /p:Platform="x64" /p:Configuration="Release" /p:TestTargetOS="Windowsnetfx" --no-build -v n --filter "category!=nonnetfxtests&category!=failing&category!=nonwindowstests"
+    ```
 
-Windows (`netcoreapp`):
-```bash
-> dotnet test "src\Microsoft.Data.SqlClient\tests\ManualTests\Microsoft.Data.SqlClient.ManualTesting.Tests.csproj" /p:Platform="AnyCPU" /p:Configuration="Release" /p:TestTargetOS="Windowsnetcoreapp" --no-build -v n --filter "category!=nonnetcoreapptests&category!=failing&category!=nonwindowstests"
-```
+  - AnyCPU:
 
-Unix (`netcoreapp`):
-```bash
-> dotnet test "src/Microsoft.Data.SqlClient/tests/ManualTests/Microsoft.Data.SqlClient.ManualTesting.Tests.csproj" /p:Platform="AnyCPU" /p:Configuration="Release" /p:TestTargetOS="Unixnetcoreapp" --no-build -v n --filter "category!=nonnetcoreapptests&category!=failing&category!=nonlinuxtests&category!=nonuaptests"
-```
+    Windows (`netfx`):
+    ```bash
+    > dotnet test "src\Microsoft.Data.SqlClient\tests\ManualTests\Microsoft.Data.SqlClient.ManualTesting.Tests.csproj" /p:Platform="AnyCPU" /p:Configuration="Release" /p:TestTargetOS="Windowsnetfx" --no-build -v n --filter "category!=nonnetfxtests&category!=failing&category!=nonwindowstests"
+    ```
+
+    Windows (`netcoreapp`):
+    ```bash
+    > dotnet test "src\Microsoft.Data.SqlClient\tests\ManualTests\Microsoft.Data.SqlClient.ManualTesting.Tests.csproj" /p:Platform="AnyCPU" /p:Configuration="Release" /p:TestTargetOS="Windowsnetcoreapp" --no-build -v n --filter "category!=nonnetcoreapptests&category!=failing&category!=nonwindowstests"
+    ```
+
+    Unix (`netcoreapp`):
+    ```bash
+    > dotnet test "src/Microsoft.Data.SqlClient/tests/ManualTests/Microsoft.Data.SqlClient.ManualTesting.Tests.csproj" /p:Platform="AnyCPU" /p:Configuration="Release" /p:TestTargetOS="Unixnetcoreapp" --no-build -v n --filter "category!=nonnetcoreapptests&category!=failing&category!=nonlinuxtests&category!=nonuaptests"
+    ```
 
 ## Run A Single Test
 ```bash
diff --git a/build.proj b/build.proj
index 428008a4a8..9d59894bf0 100644
--- a/build.proj
+++ b/build.proj
@@ -48,6 +48,7 @@
     <ManualTests Include="**/tools/Microsoft.DotNet.XUnitExtensions/Microsoft.DotNet.XUnitExtensions.csproj" />
     <ManualTests Include="**/tools/Microsoft.Data.SqlClient.TestUtilities/Microsoft.Data.SqlClient.TestUtilities.csproj"/>
     <ManualTests Include="**/tools/CoreFx.Private.TestUtilities/CoreFx.Private.TestUtilities.csproj" />
+    <ManualTests Include="**/CustomConfigurableRetryLogic/CustomRetryLogicProvider.csproj" />
     <ManualTests Include="**/ManualTests/Microsoft.Data.SqlClient.ManualTesting.Tests.csproj" />
   </ItemGroup>
 
diff --git a/src/Microsoft.Data.SqlClient.sln b/src/Microsoft.Data.SqlClient.sln
index 127672b0f9..a03e196464 100644
--- a/src/Microsoft.Data.SqlClient.sln
+++ b/src/Microsoft.Data.SqlClient.sln
@@ -172,6 +172,8 @@ Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.Data.SqlClient.Te
 EndProject
 Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.Data.SqlClient.ExtUtilities", "Microsoft.Data.SqlClient\tests\tools\Microsoft.Data.SqlClient.ExtUtilities\Microsoft.Data.SqlClient.ExtUtilities.csproj", "{E4C08DCE-DC29-4FEB-B655-1E7287DB5A2B}"
 EndProject
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "CustomRetryLogicProvider", "Microsoft.Data.SqlClient\tests\CustomConfigurableRetryLogic\CustomRetryLogicProvider.csproj", "{B499E477-C9B1-4087-A5CF-5C762D90E433}"
+EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
 		Debug|Any CPU = Debug|Any CPU
@@ -1159,6 +1161,7 @@ Global
 		{E7336BFB-8521-423A-A140-3123F9065C5D} = {0CC4817A-12F3-4357-912C-09315FAAD008}
 		{89D6D382-9B36-43C9-A912-03802FDA8E36} = {0CC4817A-12F3-4357-912C-09315FAAD008}
 		{E4C08DCE-DC29-4FEB-B655-1E7287DB5A2B} = {0CC4817A-12F3-4357-912C-09315FAAD008}
+		{B499E477-C9B1-4087-A5CF-5C762D90E433} = {0CC4817A-12F3-4357-912C-09315FAAD008}
 	EndGlobalSection
 	GlobalSection(ExtensibilityGlobals) = postSolution
 		SolutionGuid = {01D48116-37A2-4D33-B9EC-94793C702431}
diff --git a/src/Microsoft.Data.SqlClient/tests/ManualTests/SQL/RetryLogic/Resources/CustomConfigurableRetryLogic.cs b/src/Microsoft.Data.SqlClient/tests/CustomConfigurableRetryLogic/CustomConfigurableRetryLogic.cs
similarity index 94%
rename from src/Microsoft.Data.SqlClient/tests/ManualTests/SQL/RetryLogic/Resources/CustomConfigurableRetryLogic.cs
rename to src/Microsoft.Data.SqlClient/tests/CustomConfigurableRetryLogic/CustomConfigurableRetryLogic.cs
index 4a1d16bbe7..8908857e4a 100644
--- a/src/Microsoft.Data.SqlClient/tests/ManualTests/SQL/RetryLogic/Resources/CustomConfigurableRetryLogic.cs
+++ b/src/Microsoft.Data.SqlClient/tests/CustomConfigurableRetryLogic/CustomConfigurableRetryLogic.cs
@@ -6,9 +6,9 @@
 using System.Collections.Generic;
 using System.Threading;
 using System.Threading.Tasks;
-using Microsoft.Data.SqlClient;
 
-namespace ClassLibrary
+// These types have been created just to test the configurable retry logic manager in the Manual tests project.
+namespace Microsoft.Data.SqlClient.Tests
 {
     public class CustomConfigurableRetryLogic
     {
@@ -27,8 +27,8 @@ public class CustomConfigurableRetryLogicEx
     {
         public SqlRetryLogicBaseProvider GetDefaultRetry(SqlRetryLogicOption option = null)
         {
+            // Trying to get access to a provider inside a custom implementation.
             SqlRetryLogicBaseProvider provider = new SqlCommand().RetryLogicProvider;
-            Console.WriteLine(provider.RetryLogic.NumberOfTries);
             return new CustomRetryLogicProvider(option?.NumberOfTries ?? 1);
         }
     }
diff --git a/src/Microsoft.Data.SqlClient/tests/CustomConfigurableRetryLogic/CustomRetryLogicProvider.csproj b/src/Microsoft.Data.SqlClient/tests/CustomConfigurableRetryLogic/CustomRetryLogicProvider.csproj
new file mode 100644
index 0000000000..16d5397566
--- /dev/null
+++ b/src/Microsoft.Data.SqlClient/tests/CustomConfigurableRetryLogic/CustomRetryLogicProvider.csproj
@@ -0,0 +1,24 @@
+<Project Sdk="Microsoft.NET.Sdk">
+  <PropertyGroup>
+    <AssemblyName>ExternalConfigurableRetryLogic</AssemblyName>
+    <TargetGroup Condition="$(TargetFramework.StartsWith('net4'))">netfx</TargetGroup>
+    <TargetGroup Condition="$(TargetGroup) == ''">netcoreapp</TargetGroup>
+    <OSGroup Condition="'$(OSGroup)' == ''">$(OS)</OSGroup>
+    <TargetsWindows Condition="'$(OSGroup)'=='Windows_NT'">true</TargetsWindows>
+    <TargetsUnix Condition="'$(OSGroup)'=='Unix'">true</TargetsUnix>
+    <EnableDefaultCompileItems>false</EnableDefaultCompileItems>
+    <Configurations>Debug;Release;net461-Release;net461-Debug;netcoreapp2.1-Debug;netcoreapp2.1-Release;netcoreapp3.1-Debug;netcoreapp3.1-Release</Configurations>
+    <Platforms>AnyCPU;x86;x64</Platforms>
+    <IntermediateOutputPath>$(ObjFolder)$(Configuration).$(Platform).$(AssemblyName)</IntermediateOutputPath>
+    <OutputPath>$(BinFolder)$(Configuration).$(Platform).$(AssemblyName)</OutputPath>
+  </PropertyGroup>
+  <ItemGroup>
+    <Compile Include="CustomConfigurableRetryLogic.cs" />
+  </ItemGroup>
+  <ItemGroup>
+    <ProjectReference Condition="'$(TargetGroup)'=='netcoreapp' AND $(ReferenceType)=='Project'" Include="$(NetCoreSource)src\Microsoft.Data.SqlClient.csproj" />
+    <ProjectReference Condition="'$(TargetGroup)'=='netfx' AND $(ReferenceType)=='Project'" Include="$(NetFxSource)src\Microsoft.Data.SqlClient.csproj" />
+    <ProjectReference Condition="$(ReferenceType.Contains('NetStandard'))" Include="$(TestsPath)NSLibrary\Microsoft.Data.SqlClient.NSLibrary.csproj" />
+    <PackageReference Condition="$(ReferenceType)=='Package'" Include="Microsoft.Data.SqlClient" Version="$(TestMicrosoftDataSqlClientVersion)" />
+  </ItemGroup>
+</Project>
diff --git a/src/Microsoft.Data.SqlClient/tests/ManualTests/DataCommon/DataTestUtility.cs b/src/Microsoft.Data.SqlClient/tests/ManualTests/DataCommon/DataTestUtility.cs
index 58dd79df04..a97a16a05d 100644
--- a/src/Microsoft.Data.SqlClient/tests/ManualTests/DataCommon/DataTestUtility.cs
+++ b/src/Microsoft.Data.SqlClient/tests/ManualTests/DataCommon/DataTestUtility.cs
@@ -15,8 +15,6 @@
 using Microsoft.Identity.Client;
 using Microsoft.Data.SqlClient.TestUtilities;
 using Xunit;
-using Azure.Security.KeyVault.Keys;
-using Azure.Identity;
 
 namespace Microsoft.Data.SqlClient.ManualTesting.Tests
 {
diff --git a/src/Microsoft.Data.SqlClient/tests/ManualTests/Microsoft.Data.SqlClient.ManualTesting.Tests.csproj b/src/Microsoft.Data.SqlClient/tests/ManualTests/Microsoft.Data.SqlClient.ManualTesting.Tests.csproj
index def31ffc10..0878e72f74 100644
--- a/src/Microsoft.Data.SqlClient/tests/ManualTests/Microsoft.Data.SqlClient.ManualTesting.Tests.csproj
+++ b/src/Microsoft.Data.SqlClient/tests/ManualTests/Microsoft.Data.SqlClient.ManualTesting.Tests.csproj
@@ -70,8 +70,10 @@
       <Link>Common\System\Collections\DictionaryExtensions.cs</Link>
     </Compile>
     <Compile Include="DataCommon\AADUtility.cs" />
-    <None Include="SQL\RetryLogic\Resources\CustomConfigurableRetryLogic.cs" />
     <Compile Include="SQL\RetryLogic\RetryLogicConfigHelper.cs" />
+    <Compile Include="SQL\RetryLogic\RetryLogicTestHelper.cs" />
+    <Compile Include="SQL\RetryLogic\SqlCommandReliabilityTest.cs" />
+    <Compile Include="SQL\RetryLogic\SqlConnectionReliabilityTest.cs" />
     <Compile Include="SQL\SqlBulkCopyTest\OrderHint.cs" />
     <Compile Include="SQL\SqlBulkCopyTest\OrderHintAsync.cs" />
     <Compile Include="SQL\SqlBulkCopyTest\OrderHintDuplicateColumn.cs" />
@@ -195,9 +197,6 @@
     <Compile Include="SQL\RandomStressTest\SqlRandomTypeInfoCollection.cs" />
     <Compile Include="SQL\RandomStressTest\SqlRandomTypesForSqlServer.cs" />
     <Compile Include="SQL\RandomStressTest\RandomStressTest.cs" />
-    <Compile Include="SQL\RetryLogic\RetryLogicTestHelper.cs" />
-    <Compile Include="SQL\RetryLogic\SqlConnectionReliabilityTest.cs" />
-    <Compile Include="SQL\RetryLogic\SqlCommandReliabilityTest.cs" />
     <Compile Include="SQL\SplitPacketTest\SplitPacketTest.cs" />
     <Compile Include="SQL\SqlNotificationTest\SqlNotificationTest.cs" />
     <Compile Include="SQL\TransactionTest\TransactionTest.cs" />
@@ -292,6 +291,7 @@
     <ProjectReference Condition="'$(TargetGroup)'=='netfx' AND $(ReferenceType)=='Project'" Include="$(NetFxSource)src\Microsoft.Data.SqlClient.csproj" />
     <ProjectReference Condition="$(ReferenceType.Contains('NetStandard'))" Include="$(TestsPath)NSLibrary\Microsoft.Data.SqlClient.NSLibrary.csproj" />
     <PackageReference Condition="$(ReferenceType)=='Package'" Include="Microsoft.Data.SqlClient" Version="$(TestMicrosoftDataSqlClientVersion)" />
+    <ProjectReference Include="$(TestsPath)CustomConfigurableRetryLogic\CustomRetryLogicProvider.csproj" />
   </ItemGroup>
   <!-- Azure Key Vault provider is not compatible with .NET Framework 4.6 and can only be used with .NET Framework 4.6.1 and above. -->
   <ItemGroup Condition="$(TargetFramework) != 'net46'">
@@ -313,18 +313,4 @@
   <ItemGroup>
     <None Condition="'$(TargetGroup)'=='netfx' AND $(ReferenceType)=='Project'" Include="$(BinFolder)$(Configuration).AnyCPU\Microsoft.Data.SqlClient\netfx\**\*SNI*.dll" CopyToOutputDirectory="PreserveNewest" />
   </ItemGroup>
-  <!--These files are compiled by 'netcoreapp2.1'target framework-->
-  <ItemGroup Condition="'$(TargetGroup)'=='netcoreapp' AND $(ReferenceType)=='Project'">
-      <ContentWithTargetPath Include="SQL\RetryLogic\Resources\netcoreapp\ClassLibrary_CustomConfigurableRetryLogic.dll">
-        <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
-        <TargetPath>ClassLibrary_CustomConfigurableRetryLogic.dll</TargetPath>
-      </ContentWithTargetPath>
-  </ItemGroup>
-  <!--These files are compiled by 'net461' target framework-->
-  <ItemGroup Condition="'$(TargetGroup)'=='netfx' AND $(ReferenceType)=='Project'">
-      <ContentWithTargetPath Include="SQL\RetryLogic\Resources\netfx\ClassLibrary_CustomConfigurableRetryLogic.dll">
-        <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
-        <TargetPath>ClassLibrary_CustomConfigurableRetryLogic.dll</TargetPath>
-      </ContentWithTargetPath>
-  </ItemGroup>
 </Project>
diff --git a/src/Microsoft.Data.SqlClient/tests/ManualTests/SQL/RetryLogic/Resources/netcoreapp/ClassLibrary_CustomConfigurableRetryLogic.dll b/src/Microsoft.Data.SqlClient/tests/ManualTests/SQL/RetryLogic/Resources/netcoreapp/ClassLibrary_CustomConfigurableRetryLogic.dll
deleted file mode 100644
index fcc2a8ee94c395cf9069be2838082011336caa9a..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 10240
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

diff --git a/src/Microsoft.Data.SqlClient/tests/ManualTests/SQL/RetryLogic/Resources/netfx/ClassLibrary_CustomConfigurableRetryLogic.dll b/src/Microsoft.Data.SqlClient/tests/ManualTests/SQL/RetryLogic/Resources/netfx/ClassLibrary_CustomConfigurableRetryLogic.dll
deleted file mode 100644
index 186e676a69645e9e89828f51bdfec353be7d688a..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 10240
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

diff --git a/src/Microsoft.Data.SqlClient/tests/ManualTests/SQL/RetryLogic/SqlCommandReliabilityTest.cs b/src/Microsoft.Data.SqlClient/tests/ManualTests/SQL/RetryLogic/SqlCommandReliabilityTest.cs
index 296a70dfd8..234b60c9e6 100644
--- a/src/Microsoft.Data.SqlClient/tests/ManualTests/SQL/RetryLogic/SqlCommandReliabilityTest.cs
+++ b/src/Microsoft.Data.SqlClient/tests/ManualTests/SQL/RetryLogic/SqlCommandReliabilityTest.cs
@@ -506,122 +506,134 @@ public async void RetryExecuteAsyncCancel(string cnnString, SqlRetryLogicBasePro
         [MemberData(nameof(RetryLogicTestHelper.GetConnectionAndRetryStrategyInvalidCommand), parameters: new object[] { 2 }, MemberType = typeof(RetryLogicTestHelper))]
         public void ConcurrentExecution(string cnnString, SqlRetryLogicBaseProvider provider)
         {
-            var cnnStr = new SqlConnectionStringBuilder(cnnString) { MultipleActiveResultSets = true, ConnectTimeout = 0 }.ConnectionString;
             int numberOfTries = provider.RetryLogic.NumberOfTries;
             string query = "SELECT bad command";
             int retriesCount = 0;
-            int concurrentExecution = 5;
+            int concurrentExecution = 3;
             provider.Retrying += (s, e) => Interlocked.Increment(ref retriesCount);
 
-            using (SqlConnection cnn = new SqlConnection(cnnStr))
+            Parallel.For(0, concurrentExecution,
+            i =>
             {
-                cnn.Open();
-
-                Parallel.For(0, concurrentExecution,
-                i =>
+                using (SqlConnection cnn = new SqlConnection(cnnString))
+                using (SqlCommand cmd = cnn.CreateCommand())
                 {
-                    using (SqlCommand cmd = cnn.CreateCommand())
-                    {
-                        cmd.RetryLogicProvider = provider;
-                        cmd.CommandText = query;
-                        Assert.Throws<AggregateException>(() => cmd.ExecuteScalar());
-                    }
-                });
-                Assert.Equal(numberOfTries * concurrentExecution, retriesCount + concurrentExecution);
-
-                retriesCount = 0;
-                Parallel.For(0, concurrentExecution,
-                i =>
+                    cnn.Open();
+                    cmd.RetryLogicProvider = provider;
+                    cmd.CommandText = query;
+                    Assert.Throws<AggregateException>(() => cmd.ExecuteScalar());
+                }
+            });
+            Assert.Equal(numberOfTries * concurrentExecution, retriesCount + concurrentExecution);
+
+            retriesCount = 0;
+            Parallel.For(0, concurrentExecution,
+            i =>
+            {
+                using (SqlConnection cnn = new SqlConnection(cnnString))
+                using (SqlCommand cmd = cnn.CreateCommand())
                 {
-                    using (SqlCommand cmd = cnn.CreateCommand())
-                    {
-                        cmd.RetryLogicProvider = provider;
-                        cmd.CommandText = query;
-                        Assert.Throws<AggregateException>(() => cmd.ExecuteNonQuery());
-                    }
-                });
-                Assert.Equal(numberOfTries * concurrentExecution, retriesCount + concurrentExecution);
-
-                retriesCount = 0;
-                Parallel.For(0, concurrentExecution,
-                i =>
+                    cnn.Open();
+                    cmd.RetryLogicProvider = provider;
+                    cmd.CommandText = query;
+                    Assert.Throws<AggregateException>(() => cmd.ExecuteNonQuery());
+                }
+            });
+            Assert.Equal(numberOfTries * concurrentExecution, retriesCount + concurrentExecution);
+
+            retriesCount = 0;
+            Parallel.For(0, concurrentExecution,
+            i =>
+            {
+                using (SqlConnection cnn = new SqlConnection(cnnString))
+                using (SqlCommand cmd = cnn.CreateCommand())
                 {
-                    using (SqlCommand cmd = cnn.CreateCommand())
-                    {
-                        cmd.RetryLogicProvider = provider;
-                        cmd.CommandText = query;
-                        Assert.Throws<AggregateException>(() => cmd.ExecuteReader());
-                    }
-                });
-                Assert.Equal(numberOfTries * concurrentExecution, retriesCount + concurrentExecution);
-
-                retriesCount = 0;
-                Parallel.For(0, concurrentExecution,
-                i =>
+                    cnn.Open();
+                    cmd.RetryLogicProvider = provider;
+                    cmd.CommandText = query;
+                    Assert.Throws<AggregateException>(() => cmd.ExecuteReader());
+                }
+            });
+            Assert.Equal(numberOfTries * concurrentExecution, retriesCount + concurrentExecution);
+
+            retriesCount = 0;
+            Parallel.For(0, concurrentExecution,
+            i =>
+            {
+                using (SqlConnection cnn = new SqlConnection(cnnString))
+                using (SqlCommand cmd = cnn.CreateCommand())
                 {
-                    using (SqlCommand cmd = cnn.CreateCommand())
-                    {
-                        cmd.RetryLogicProvider = provider;
-                        cmd.CommandText = query + " FOR XML AUTO";
-                        Assert.Throws<AggregateException>(() => cmd.ExecuteXmlReader());
-                    }
-                });
-                Assert.Equal(numberOfTries * concurrentExecution, retriesCount + concurrentExecution);
-
-                retriesCount = 0;
-                Parallel.For(0, concurrentExecution,
-                i =>
+                    cnn.Open();
+                    cmd.RetryLogicProvider = provider;
+                    cmd.CommandText = query + " FOR XML AUTO";
+                    Assert.Throws<AggregateException>(() => cmd.ExecuteXmlReader());
+                }
+            });
+            Assert.Equal(numberOfTries * concurrentExecution, retriesCount + concurrentExecution);
+
+            retriesCount = 0;
+            Parallel.For(0, concurrentExecution,
+            i =>
+            {
+                using (SqlConnection cnn = new SqlConnection(cnnString))
+                using (SqlCommand cmd = cnn.CreateCommand())
                 {
-                    using (SqlCommand cmd = cnn.CreateCommand())
-                    {
-                        cmd.RetryLogicProvider = provider;
-                        cmd.CommandText = query;
-                        Assert.ThrowsAsync<AggregateException>(() => cmd.ExecuteScalarAsync()).Wait();
-                    }
-                });
-                Assert.Equal(numberOfTries * concurrentExecution, retriesCount + concurrentExecution);
-
-                retriesCount = 0;
-                Parallel.For(0, concurrentExecution,
-                i =>
+                    cnn.Open();
+                    cmd.RetryLogicProvider = provider;
+                    cmd.CommandText = query;
+                    Assert.ThrowsAsync<AggregateException>(() => cmd.ExecuteScalarAsync()).Wait();
+                }
+            });
+            Assert.Equal(numberOfTries * concurrentExecution, retriesCount + concurrentExecution);
+
+            retriesCount = 0;
+            Parallel.For(0, concurrentExecution,
+            i =>
+            {
+                using (SqlConnection cnn = new SqlConnection(cnnString))
+                using (SqlCommand cmd = cnn.CreateCommand())
                 {
-                    using (SqlCommand cmd = cnn.CreateCommand())
-                    {
-                        cmd.RetryLogicProvider = provider;
-                        cmd.CommandText = query;
-                        Assert.ThrowsAsync<AggregateException>(() => cmd.ExecuteNonQueryAsync()).Wait();
-                    }
-                });
-                Assert.Equal(numberOfTries * concurrentExecution, retriesCount + concurrentExecution);
-
-                retriesCount = 0;
-                Parallel.For(0, concurrentExecution,
-                i =>
+                    cnn.Open();
+                    cmd.RetryLogicProvider = provider;
+                    cmd.CommandText = query;
+                    Assert.ThrowsAsync<AggregateException>(() => cmd.ExecuteNonQueryAsync()).Wait();
+                }
+            });
+            Assert.Equal(numberOfTries * concurrentExecution, retriesCount + concurrentExecution);
+
+            retriesCount = 0;
+            Parallel.For(0, concurrentExecution,
+            i =>
+            {
+                using (SqlConnection cnn = new SqlConnection(cnnString))
+                using (SqlCommand cmd = cnn.CreateCommand())
                 {
-                    using (SqlCommand cmd = cnn.CreateCommand())
-                    {
-                        cmd.RetryLogicProvider = provider;
-                        cmd.CommandText = query;
-                        Assert.ThrowsAsync<AggregateException>(() => cmd.ExecuteReaderAsync()).Wait();
-                    }
-                });
-                Assert.Equal(numberOfTries * concurrentExecution, retriesCount + concurrentExecution);
-
-                retriesCount = 0;
-                Parallel.For(0, concurrentExecution,
-                i =>
+                    cnn.Open();
+                    cmd.RetryLogicProvider = provider;
+                    cmd.CommandText = query;
+                    Assert.ThrowsAsync<AggregateException>(() => cmd.ExecuteReaderAsync()).Wait();
+                }
+            });
+            Assert.Equal(numberOfTries * concurrentExecution, retriesCount + concurrentExecution);
+
+            // TODO: there is a known issue by ExecuteXmlReaderAsync that should be solved first- issue #44
+            /*
+            retriesCount = 0;
+            Parallel.For(0, concurrentExecution,
+            i =>
+            {
+                using (SqlConnection cnn = new SqlConnection(cnnString))
+                using (SqlCommand cmd = cnn.CreateCommand())
                 {
-                    using (SqlCommand cmd = cnn.CreateCommand())
-                    {
-                        cmd.RetryLogicProvider = provider;
-                        cmd.CommandText = query + " FOR XML AUTO";
-                        Assert.ThrowsAsync<AggregateException>(() => cmd.ExecuteXmlReaderAsync()).Wait();
-                    }
-                });
-                Assert.Equal(numberOfTries * concurrentExecution, retriesCount + concurrentExecution);
-            }
+                    cnn.Open();
+                    cmd.RetryLogicProvider = provider;
+                    cmd.CommandText = query + " FOR XML AUTO";
+                    Assert.ThrowsAsync<AggregateException>(() => cmd.ExecuteXmlReaderAsync()).Wait();
+                }
+            });
+            Assert.Equal(numberOfTries * concurrentExecution, retriesCount + concurrentExecution);
+            */
         }
-
         #endregion
 
         #region private members
diff --git a/src/Microsoft.Data.SqlClient/tests/ManualTests/SQL/RetryLogic/SqlConfigurationManagerReliabilityTest.cs b/src/Microsoft.Data.SqlClient/tests/ManualTests/SQL/RetryLogic/SqlConfigurationManagerReliabilityTest.cs
index 781e2f7472..ca1bd1ce87 100644
--- a/src/Microsoft.Data.SqlClient/tests/ManualTests/SQL/RetryLogic/SqlConfigurationManagerReliabilityTest.cs
+++ b/src/Microsoft.Data.SqlClient/tests/ManualTests/SQL/RetryLogic/SqlConfigurationManagerReliabilityTest.cs
@@ -72,13 +72,13 @@ public void LoadValidInternalTypesWithoutEnablingSwitch(string method1, string m
 
         #region External Functions
         [ConditionalTheory(typeof(DataTestUtility), nameof(DataTestUtility.AreConnStringsSetup))]
-        [InlineData("ClassLibrary.StaticCustomConfigurableRetryLogic, ClassLibrary_CustomConfigurableRetryLogic", "GetDefaultRetry_static")]
-        [InlineData("ClassLibrary.StructCustomConfigurableRetryLogic, ClassLibrary_CustomConfigurableRetryLogic", "GetDefaultRetry_static")]
-        [InlineData("ClassLibrary.StructCustomConfigurableRetryLogic, ClassLibrary_CustomConfigurableRetryLogic", "GetDefaultRetry")]
-        [InlineData("ClassLibrary.CustomConfigurableRetryLogic, ClassLibrary_CustomConfigurableRetryLogic", "GetDefaultRetry_static")]
-        [InlineData("ClassLibrary.CustomConfigurableRetryLogic, ClassLibrary_CustomConfigurableRetryLogic", "GetDefaultRetry")]
-        [InlineData("ClassLibrary.CustomConfigurableRetryLogic, ClassLibrary_CustomConfigurableRetryLogic, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null", "GetDefaultRetry")]
-        [InlineData("ClassLibrary.CustomConfigurableRetryLogicEx, ClassLibrary_CustomConfigurableRetryLogic", "GetDefaultRetry")]
+        [InlineData("Microsoft.Data.SqlClient.Tests.StaticCustomConfigurableRetryLogic, ExternalConfigurableRetryLogic", "GetDefaultRetry_static")]
+        [InlineData("Microsoft.Data.SqlClient.Tests.StructCustomConfigurableRetryLogic, ExternalConfigurableRetryLogic", "GetDefaultRetry_static")]
+        [InlineData("Microsoft.Data.SqlClient.Tests.StructCustomConfigurableRetryLogic, ExternalConfigurableRetryLogic", "GetDefaultRetry")]
+        [InlineData("Microsoft.Data.SqlClient.Tests.CustomConfigurableRetryLogic, ExternalConfigurableRetryLogic", "GetDefaultRetry_static")]
+        [InlineData("Microsoft.Data.SqlClient.Tests.CustomConfigurableRetryLogic, ExternalConfigurableRetryLogic", "GetDefaultRetry")]
+        [InlineData("Microsoft.Data.SqlClient.Tests.CustomConfigurableRetryLogic, ExternalConfigurableRetryLogic, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null", "GetDefaultRetry")]
+        [InlineData("Microsoft.Data.SqlClient.Tests.CustomConfigurableRetryLogicEx, ExternalConfigurableRetryLogic", "GetDefaultRetry")]
         public void LoadCustomMethod(string typeName, string methodName)
         {
             bool switchValue = true;
@@ -101,16 +101,16 @@ public void LoadCustomMethod(string typeName, string methodName)
         }
 
         [ConditionalTheory(typeof(DataTestUtility), nameof(DataTestUtility.AreConnStringsSetup))]
-        [InlineData("ClassLibrary.Invalid, ClassLibrary_CustomConfigurableRetryLogic", "GetDefaultRetry_static")]
-        [InlineData("ClassLibrary.Invalid, ClassLibrary_CustomConfigurableRetryLogic", "GetDefaultRetry")]
-        [InlineData("ClassLibrary.CustomConfigurableRetryLogic, ClassLibrary_Invalid", "GetDefaultRetry_static")]
-        [InlineData("ClassLibrary.StaticCustomConfigurableRetryLogic, ClassLibrary_Invalid", "GetDefaultRetry_static")]
-        [InlineData("ClassLibrary.StructCustomConfigurableRetryLogic, ClassLibrary_Invalid", "GetDefaultRetry")]
+        [InlineData("ClassLibrary.Invalid, ExternalConfigurableRetryLogic", "GetDefaultRetry_static")]
+        [InlineData("ClassLibrary.Invalid, ExternalConfigurableRetryLogic", "GetDefaultRetry")]
+        [InlineData("Microsoft.Data.SqlClient.Tests.CustomConfigurableRetryLogic, ClassLibrary_Invalid", "GetDefaultRetry_static")]
+        [InlineData("Microsoft.Data.SqlClient.Tests.StaticCustomConfigurableRetryLogic, ClassLibrary_Invalid", "GetDefaultRetry_static")]
+        [InlineData("Microsoft.Data.SqlClient.Tests.StructCustomConfigurableRetryLogic, ClassLibrary_Invalid", "GetDefaultRetry")]
         // Type and method name are case sensitive.
-        [InlineData("ClassLibrary.StaticCustomConfigurableRetryLogic, ClassLibrary_CustomConfigurableRetryLogic", "GETDEFAULTRETRY_STATIC")]
-        [InlineData("ClassLibrary.STRUCTCUSTOMCONFIGURABLERETRYLOGIC, ClassLibrary_CustomConfigurableRetryLogic", "GetDefaultRetry")]
-        [InlineData("CLASSLIBRARY.CustomConfigurableRetryLogic, ClassLibrary_CustomConfigurableRetryLogic", "GetDefaultRetry_static")]
-        [InlineData("ClassLibrary.CustomConfigurableRetryLogic, ClassLibrary_CustomConfigurableRetryLogic", "getdefaultretry")]
+        [InlineData("Microsoft.Data.SqlClient.Tests.StaticCustomConfigurableRetryLogic, ExternalConfigurableRetryLogic", "GETDEFAULTRETRY_STATIC")]
+        [InlineData("Microsoft.Data.SqlClient.Tests.STRUCTCUSTOMCONFIGURABLERETRYLOGIC, ExternalConfigurableRetryLogic", "GetDefaultRetry")]
+        [InlineData("MICROSOFT.DATA.SQLCLIENT.TESTS.CustomConfigurableRetryLogic, ExternalConfigurableRetryLogic", "GetDefaultRetry_static")]
+        [InlineData("Microsoft.Data.SqlClient.Tests.CustomConfigurableRetryLogic, ExternalConfigurableRetryLogic", "getdefaultretry")]
         public void LoadInvalidCustomRetryLogicType(string typeName, string methodName)
         {
             bool switchValue = true;