Clear pool for all Oracle drivers.

src/NHibernate.Test/TestCase.cs

@@ -13,9 +13,7 @@
 using NUnit.Framework;
 using NUnit.Framework.Interfaces;
 using System.Text;
-using NHibernate.Dialect;
 using NHibernate.Driver;
-using Oracle.ManagedDataAccess.Client;
 
 namespace NHibernate.Test
 {
@@ -314,16 +312,24 @@ protected virtual DebugSessionFactory BuildSessionFactory()
 
 		private void Cleanup()
 		{
-			Sfi?.Close();
-
 			// Clear connection pool for Oracle to avoid problem that was manifested with https://github.com/nhibernate/nhibernate-core/pull/1517:
 			// As it seems Oracle can cache returned types for query for given connection.
 			// So exception can be thrown if two tests execute same query but with different types in result (like for Entity.Id int and Entity.Id Guid)
-			if (Dialect is Oracle8iDialect)
+			switch (Sfi?.ConnectionProvider.Driver)
 			{
-				OracleConnection.ClearAllPools();
+				case OracleClientDriver oraSysData:
+					oraSysData.ClearPool(null);
+					break;
+				case OracleDataClientDriver oraUnmanaged:
+					oraUnmanaged.ClearPool(null);
+					break;
+				case OracleManagedDataClientDriver oraManaged:
+					oraManaged.ClearPool(null);
+					break;
 			}
 
+			Sfi?.Close();
+
 			_sessionFactory = null;
 			cfg = null;
 		}

src/NHibernate/Driver/FirebirdClientDriver.cs

@@ -1,9 +1,7 @@
-using System;
 using System.Collections.Generic;
 using System.Data;
 using System.Data.Common;
 using System.Linq;
-using System.Reflection;
 using System.Text.RegularExpressions;
 using NHibernate.Dialect;
 using NHibernate.SqlCommand;
@@ -128,39 +126,16 @@ private string GetFbTypeForParam(SqlType sqlType)
 			return _fbDialect.GetCastTypeName(sqlType);
 		}
 
-		private static volatile MethodInfo _clearPool;
-		private static volatile MethodInfo _clearAllPools;
-
 		/// <summary>
 		/// Clears the connection pool.
 		/// </summary>
 		/// <param name="connectionString">The connection string of connections for which to clear the pool.
 		/// <c>null</c> for clearing them all.</param>
 		public void ClearPool(string connectionString)
 		{
-			// In case of concurrent threads, may initialize many times. We do not care.
-			// Members are volatile for avoiding it gets used while its constructor is not yet ended.
-			if (_clearPool == null || _clearAllPools == null)
-			{
-				using (var clearConnection = CreateConnection())
-				{
-					var connectionType = clearConnection.GetType();
-					_clearPool = connectionType.GetMethod("ClearPool") ?? throw new InvalidOperationException("Unable to resolve ClearPool method.");
-					_clearAllPools = connectionType.GetMethod("ClearAllPools") ?? throw new InvalidOperationException("Unable to resolve ClearAllPools method.");
-				}
-			}
-
-			if (connectionString != null)
-			{
-				using (var clearConnection = CreateConnection())
-				{
-					clearConnection.ConnectionString = connectionString;
-					_clearPool.Invoke(null, new object[] {clearConnection});
-				}
-				return;
-			}
-
-			_clearAllPools.Invoke(null, Array.Empty<object>());
+			// Do not move in a base class common to different connection types, or it may not clear
+			// expected pool.
+			PoolHelper<FirebirdClientDriver>.ClearPool(this, connectionString);
 		}
 
 		/// <summary>

src/NHibernate/Driver/OracleClientDriver.cs

@@ -59,5 +59,17 @@ protected override void OnBeforePrepare(DbCommand command)
 				" does not support CallableStatement syntax (stored procedures)." +
 				" Consider using OracleDataClientDriver instead.");
 		}
+
+		/// <summary>
+		/// Clears the connection pool.
+		/// </summary>
+		/// <param name="connectionString">The connection string of connections for which to clear the pool.
+		/// <c>null</c> for clearing them all.</param>
+		public void ClearPool(string connectionString)
+		{
+			// Do not move in a base class common to different connection types, or it may not clear
+			// expected pool.
+			PoolHelper<OracleClientDriver>.ClearPool(this, connectionString);
+		}
 	}
-}
+}

src/NHibernate/Driver/OracleDataClientDriver.cs

@@ -15,5 +15,17 @@ public OracleDataClientDriver()
 			: base("Oracle.DataAccess")
 		{
 		}
+
+		/// <summary>
+		/// Clears the connection pool.
+		/// </summary>
+		/// <param name="connectionString">The connection string of connections for which to clear the pool.
+		/// <c>null</c> for clearing them all.</param>
+		public void ClearPool(string connectionString)
+		{
+			// Do not move in a base class common to different connection types, or it may not clear
+			// expected pool.
+			PoolHelper<OracleDataClientDriver>.ClearPool(this, connectionString);
+		}
 	}
-}
+}

src/NHibernate/Driver/OracleDataClientDriverBase.cs

@@ -2,7 +2,6 @@
 using System.Collections.Generic;
 using System.Data;
 using System.Data.Common;
-using System.Reflection;
 using NHibernate.AdoNet;
 using NHibernate.Engine.Query;
 using NHibernate.SqlTypes;

src/NHibernate/Driver/OracleManagedDataClientDriver.cs

@@ -17,5 +17,17 @@ public OracleManagedDataClientDriver()
 		}
 
 		public override bool HasDelayedDistributedTransactionCompletion => true;
+
+		/// <summary>
+		/// Clears the connection pool.
+		/// </summary>
+		/// <param name="connectionString">The connection string of connections for which to clear the pool.
+		/// <c>null</c> for clearing them all.</param>
+		public void ClearPool(string connectionString)
+		{
+			// Do not move in a base class common to different connection types, or it may not clear
+			// expected pool.
+			PoolHelper<OracleManagedDataClientDriver>.ClearPool(this, connectionString);
+		}
 	}
 }

src/NHibernate/Driver/ReflectionBasedDriver.cs

@@ -1,5 +1,6 @@
 using System;
 using System.Data.Common;
+using System.Reflection;
 using NHibernate.Util;
 
 namespace NHibernate.Driver
@@ -70,5 +71,58 @@ public override DbCommand CreateCommand()
 		{
 			return connectionCommandProvider.CreateCommand();
 		}
+
+		/// <summary>
+		/// Helper for clearing connection pools used by a reflection driver. Assumes the connection has a parameter-less
+		/// <c>ClearAllPools</c> method and a <c>ClearPool</c> method taking as argument a connection.
+		/// </summary>
+		/// <typeparam name="T">The driver type for which the pool has to be cleared. This driver type must
+		/// always use the same connection type.</typeparam>
+		/// <remarks>Having <c>ClearAllPools</c> and <c>ClearPool</c> is a common pattern. <c>SqlConnection</c>,
+		/// <c>OracleConnection</c> (managed, un-managed and from <c>System.Data</c>), <c>FirebirdConnection</c>
+		/// <c>NpgsqlConnection</c>, <c>MySqlConnection</c> and <c>SQLiteConnection</c> have them.
+		/// (<c>SqlCeConnection</c>, <c>OdbcConnection</c> and <c>OleDbConnection</c> lack them.)</remarks>
+		protected static class PoolHelper<T> where T : IDriver
+		{
+			// Static field in generic class => one field per concrete type used. This is exactly what
+			// we need here, do not move the generic argument to the method. Otherwise it will cache the
+			// method info of the first driver type used, and reuse it for other driver types, which
+			// would fail.
+			private static volatile MethodInfo _clearPool;
+			private static volatile MethodInfo _clearAllPools;
+
+			/// <summary>
+			/// Clears the connection pool.
+			/// </summary>
+			/// <param name="driver">The driver for which the connection pool has to be cleared.</param>
+			/// <param name="connectionString">The connection string of connections for which to clear the pool.
+			/// <c>null</c> for clearing them all.</param>
+			internal static void ClearPool(T driver, string connectionString)
+			{
+				// In case of concurrent threads, may initialize many times. We do not care.
+				// Members are volatile for avoiding they get used while their constructor is not yet ended.
+				if (_clearPool == null || _clearAllPools == null)
+				{
+					using (var clearConnection = driver.CreateConnection())
+					{
+						var connectionType = clearConnection.GetType();
+						_clearPool = connectionType.GetMethod("ClearPool") ?? throw new InvalidOperationException("Unable to resolve ClearPool method.");
+						_clearAllPools = connectionType.GetMethod("ClearAllPools") ?? throw new InvalidOperationException("Unable to resolve ClearAllPools method.");
+					}
+				}
+
+				if (connectionString != null)
+				{
+					using (var clearConnection = driver.CreateConnection())
+					{
+						clearConnection.ConnectionString = connectionString;
+						_clearPool.Invoke(null, new object[] {clearConnection});
+					}
+					return;
+				}
+
+				_clearAllPools.Invoke(null, Array.Empty<object>());
+			}
+		}
 	}
-}
+}