updates

KirillKurdyukov · KirillKurdyukov · commit be64b16cd98b · 2025-07-31T13:31:54.000+03:00
diff --git a/src/Ydb.Sdk/src/Ado/Session/ISession.cs b/src/Ydb.Sdk/src/Ado/Session/ISession.cs
@@ -23,5 +23,5 @@ ValueTask<IServerStream<ExecuteQueryResponsePart>> ExecuteQuery(
 
     void OnNotSuccessStatusCode(StatusCode code);
 
-    ValueTask Close();
+    void Close();
 }
diff --git a/src/Ydb.Sdk/src/Ado/Session/ImplicitSession.cs b/src/Ydb.Sdk/src/Ado/Session/ImplicitSession.cs
@@ -48,7 +48,9 @@ public void OnNotSuccessStatusCode(StatusCode code)
     {
     }
 
-    public ValueTask Close() => ValueTask.CompletedTask;
+    public void Close()
+    {
+    }
 
     private static YdbException NotSupportedTransaction =>
         new(StatusCode.BadRequest, "Transactions are not supported in implicit sessions");
diff --git a/src/Ydb.Sdk/src/Ado/Session/PoolingSessionSource.cs b/src/Ydb.Sdk/src/Ado/Session/PoolingSessionSource.cs
@@ -185,13 +185,13 @@ private void WakeUpWaiter()
         } // wake up waiter!
     }
 
-    public ValueTask Return(T session)
+    public void Return(T session)
     {
         if (session.IsBroken || IsDisposed)
         {
             CloseSession(session);
 
-            return IsDisposed ? TryDisposeCore() : ValueTask.CompletedTask;
+            return;
         }
 
         // Statement order is important
@@ -202,15 +202,13 @@ public ValueTask Return(T session)
         {
             if (waiter.TrySetResult(session))
             {
-                return ValueTask.CompletedTask;
+                return;
             }
         }
 
         _idleSessions.Push(session);
 
         WakeUpWaiter();
-
-        return ValueTask.CompletedTask;
     }
 
     private void CloseSession(T session)
@@ -273,11 +271,24 @@ public async ValueTask DisposeAsync()
             }
         }
 
-        await TryDisposeCore();
-    }
+        var spinWait = new SpinWait();
+        do
+        {
+            for (var i = 0; i < _maxSessionSize; i++)
+            {
+                var session = Volatile.Read(ref _sessions[i]);
 
-    private ValueTask TryDisposeCore() =>
-        _numSessions == 0 ? _sessionFactory.DisposeAsync() : ValueTask.CompletedTask;
+                if (session != null && session.CompareAndSet(PoolingSessionState.In, PoolingSessionState.Clean))
+                {
+                    CloseSession(session);
+                }
+            }
+
+            spinWait.SpinOnce();
+        } while (_numSessions > 0);
+
+        await _sessionFactory.DisposeAsync();
+    }
 }
 
 internal interface IPoolingSessionFactory<T> : IAsyncDisposable where T : PoolingSessionBase<T>
@@ -330,5 +341,5 @@ public abstract ValueTask<IServerStream<ExecuteQueryResponsePart>> ExecuteQuery(
 
     public abstract void OnNotSuccessStatusCode(StatusCode code);
 
-    public ValueTask Close() => _source.Return((T)this);
+    public void Close() => _source.Return((T)this);
 }
diff --git a/src/Ydb.Sdk/src/Ado/YdbConnection.cs b/src/Ydb.Sdk/src/Ado/YdbConnection.cs
@@ -143,7 +143,7 @@ public override async Task CloseAsync()
         }
         finally
         {
-            await _session.Close();
+            _session.Close();
         }
     }
 
diff --git a/src/Ydb.Sdk/src/Services/Query/SessionPool.cs b/src/Ydb.Sdk/src/Services/Query/SessionPool.cs
@@ -180,7 +180,7 @@ public ValueTask<IServerStream<ExecuteQueryResponsePart>> ExecuteQuery(
 
     public new void OnNotSuccessStatusCode(StatusCode code) => base.OnNotSuccessStatusCode(code);
 
-    public ValueTask Close() => Release();
+    public void Close() => Release().AsTask().GetAwaiter().GetResult();
 
     public async Task CommitTransaction(string txId, CancellationToken cancellationToken = default)
     {
diff --git a/src/Ydb.Sdk/test/Ydb.Sdk.Ado.Benchmarks/SessionSourceBenchmark.cs b/src/Ydb.Sdk/test/Ydb.Sdk.Ado.Benchmarks/SessionSourceBenchmark.cs
@@ -25,7 +25,7 @@ public void Setup()
     public async Task SingleThreaded_OpenClose()
     {
         var session = await _poolingSessionSource.OpenSession();
-        await session.Close();
+        session.Close();
     }
 
     [Benchmark]
@@ -39,7 +39,7 @@ public async Task MultiThreaded_OpenClose()
             {
                 var session = await _poolingSessionSource.OpenSession();
                 await Task.Yield();
-                await session.Close();
+                session.Close();
             });
         }
 
@@ -58,7 +58,7 @@ public async Task HighContention_OpenClose()
             {
                 var session = await _poolingSessionSource.OpenSession();
                 await Task.Yield();
-                await session.Close();
+                session.Close();
             });
         }
 
@@ -79,7 +79,7 @@ public async Task SessionReuse_Pattern()
                 {
                     var session = await _poolingSessionSource.OpenSession();
                     await Task.Yield();
-                    await session.Close();
+                    session.Close();
                 }
             });
         }
@@ -102,7 +102,7 @@ public async Task SessionReuse_HighContention_Pattern()
                 {
                     var session = await _poolingSessionSource.OpenSession();
                     await Task.Yield();
-                    await session.Close();
+                    session.Close();
                 }
             });
         }
@@ -124,7 +124,7 @@ public async Task SessionReuse_HighIterations_Pattern()
                 {
                     var session = await _poolingSessionSource.OpenSession();
                     await Task.Yield();
-                    await session.Close();
+                    session.Close();
                 }
             });
         }
diff --git a/src/Ydb.Sdk/test/Ydb.Sdk.Ado.Tests/Session/PoolingSessionSourceMockTests.cs b/src/Ydb.Sdk/test/Ydb.Sdk.Ado.Tests/Session/PoolingSessionSourceMockTests.cs
@@ -20,7 +20,7 @@ public async Task Reuse_Session_Before_Creating_new()
             new YdbConnectionStringBuilder());
         var session = await sessionSource.OpenSession();
         var sessionId = session.SessionId();
-        await session.Close();
+        session.Close();
         session = await sessionSource.OpenSession();
         Assert.Equal(sessionId, session.SessionId());
     }
@@ -58,7 +58,7 @@ public async Task Creating_Session_Throw_Exception()
                         // ReSharper disable once AccessToModifiedClosure
                         Interlocked.Increment(ref countSuccess);
                         Assert.True(session.SessionId() > maxSessionSize * 2);
-                        await session.Close();
+                        session.Close();
                     }
                     catch (YdbException e)
                     {
@@ -95,7 +95,7 @@ public async Task HighContention_OpenClose_NotCanceledException()
                     var session = await sessionSource.OpenSession();
                     Assert.True(session.SessionId() <= maxSessionSize);
                     await Task.Yield();
-                    await session.Close();
+                    session.Close();
                 });
             }
 
@@ -124,26 +124,25 @@ public async Task DisposeAsync_Cancel_WaitersSession()
             waitingSessionTasks.Add(Task.Run(async () =>
             {
                 var session = await sessionSource.OpenSession();
-                await session.Close();
+                session.Close();
             }));
         }
 
-        await sessionSource.DisposeAsync();
+        var disposeTask = Task.Run(async () => await sessionSource.DisposeAsync());
         Assert.Equal(maxSessionSize, mockFactory.NumSession);
-        Assert.Equal("Session Source is disposed.",
-            (await Assert.ThrowsAsync<YdbException>(async () => await sessionSource.OpenSession())).Message);
 
         for (var i = 0; i < maxSessionSize; i++)
         {
-            await Assert.ThrowsAsync<TaskCanceledException>(() => waitingSessionTasks[i]);
+            openSessions[i].Close();
         }
 
+        await disposeTask;
+        Assert.Equal(0, mockFactory.NumSession);
         for (var i = 0; i < maxSessionSize; i++)
         {
-            await openSessions[i].Close();
+            await Assert.ThrowsAnyAsync<Exception>(() => waitingSessionTasks[i]);
         }
 
-        Assert.Equal(0, mockFactory.NumSession);
         Assert.Equal("Session Source is disposed.",
             (await Assert.ThrowsAsync<YdbException>(async () => await sessionSource.OpenSession())).Message);
     }
@@ -184,7 +183,7 @@ public async Task StressTest_DisposeAsync_Close_Driver()
                     {
                         var session = await sessionSource.OpenSession();
                         await Task.Yield();
-                        await session.Close();
+                        session.Close();
                     }
                     catch (YdbException e)
                     {
@@ -226,7 +225,7 @@ public async Task IdleTimeout_MinSessionSize_CloseNumSessionsMinusMinSessionCoun
 
         foreach (var it in openSessions)
         {
-            await it.Close();
+            it.Close();
         }
 
         await Task.Delay(TimeSpan.FromSeconds(idleTimeoutSeconds * 5)); // cleaning idle sessions
@@ -240,7 +239,7 @@ public async Task IdleTimeout_MinSessionSize_CloseNumSessionsMinusMinSessionCoun
 
         foreach (var it in openSessionTasks)
         {
-            await (await it).Close();
+            (await it).Close();
         }
 
         Assert.Equal(minSessionSize, mockFactory.NumSession);
@@ -273,7 +272,7 @@ public async Task StressTest_HighContention_OpenClose()
                     while (!cts.IsCancellationRequested)
                     {
                         var session = await sessionSource.OpenSession(cts.Token);
-                        await session.Close();
+                        session.Close();
                         await Task.Delay(Random.Shared.Next(maxSessionSize), cts.Token);
                     }
                 }
@@ -302,7 +301,7 @@ public async Task Get_Session_From_Exhausted_Pool()
         cts.CancelAfter(500);
 
         await Assert.ThrowsAsync<TaskCanceledException>(async () => await sessionSource.OpenSession(cts.Token));
-        await session.Close();
+        session.Close();
 
         Assert.Equal(1, mockFactory.NumSession);
         Assert.Equal(1, mockFactory.SessionOpenedCount);
@@ -323,7 +322,7 @@ public async Task Return_IsBroken_Session()
         for (var it = 0; it < maxSessionSize * 2; it++)
         {
             var session = await sessionSource.OpenSession();
-            await session.Close();
+            session.Close();
         }
 
         Assert.Equal(0, mockFactory.NumSession);
@@ -352,7 +351,7 @@ public async Task CheckIdleSession_WhenIsBrokenInStack_CreateNewSession()
 
         foreach (var session in openSessions)
         {
-            await session.Close();
+            session.Close();
         }
 
         Assert.Equal(maxSessionSize, mockFactory.NumSession);
@@ -362,7 +361,7 @@ public async Task CheckIdleSession_WhenIsBrokenInStack_CreateNewSession()
         {
             var session = await sessionSource.OpenSession();
             isBroken = false;
-            await session.Close();
+            session.Close();
         }
 
         Assert.Equal(1, mockFactory.NumSession);
diff --git a/src/Ydb.Sdk/test/Ydb.Sdk.Ado.Tests/YdbConnectionTests.cs b/src/Ydb.Sdk/test/Ydb.Sdk.Ado.Tests/YdbConnectionTests.cs
@@ -293,10 +293,8 @@ private List<Task> GenerateTasks(string connectionString) => Enumerable.Range(0,
             ydbConnection.ConnectionString = connectionString;
             await ydbConnection.OpenAsync();
         }
-        catch (YdbException e)
+        catch (YdbException)
         {
-            Assert.Equal(StatusCode.Unspecified, e.Code);
-            Assert.Equal("Session Source is disposed.", e.Message);
             Interlocked.Add(ref _counter, i);
             return;
         }

Original file line number	Diff line number	Diff line change
`@@ -23,5 +23,5 @@ ValueTask<IServerStream<ExecuteQueryResponsePart>> ExecuteQuery(`
`23`	`23`
`24`	`24`	`void OnNotSuccessStatusCode(StatusCode code);`
`25`	`25`
`26`		`- ValueTask Close();`
	`26`	`+ void Close();`
`27`	`27`	`}`
Original file line number	Diff line number	Diff line change
`@@ -48,7 +48,9 @@ public void OnNotSuccessStatusCode(StatusCode code)`
`48`	`48`	`{`
`49`	`49`	`}`
`50`	`50`
`51`		`- public ValueTask Close() => ValueTask.CompletedTask;`
	`51`	`+ public void Close()`
	`52`	`+ {`
	`53`	`+ }`
`52`	`54`
`53`	`55`	`private static YdbException NotSupportedTransaction =>`
`54`	`56`	`new(StatusCode.BadRequest, "Transactions are not supported in implicit sessions");`
Original file line number	Diff line number	Diff line change
`@@ -185,13 +185,13 @@ private void WakeUpWaiter()`
`185`	`185`	`} // wake up waiter!`
`186`	`186`	`}`
`187`	`187`
`188`		`- public ValueTask Return(T session)`
	`188`	`+ public void Return(T session)`
`189`	`189`	`{`
`190`	`190`	`if (session.IsBroken \|\| IsDisposed)`
`191`	`191`	`{`
`192`	`192`	`CloseSession(session);`
`193`	`193`
`194`		`- return IsDisposed ? TryDisposeCore() : ValueTask.CompletedTask;`
	`194`	`+ return;`
`195`	`195`	`}`
`196`	`196`
`197`	`197`	`// Statement order is important`
`@@ -202,15 +202,13 @@ public ValueTask Return(T session)`
`202`	`202`	`{`
`203`	`203`	`if (waiter.TrySetResult(session))`
`204`	`204`	`{`
`205`		`- return ValueTask.CompletedTask;`
	`205`	`+ return;`
`206`	`206`	`}`
`207`	`207`	`}`
`208`	`208`
`209`	`209`	`_idleSessions.Push(session);`
`210`	`210`
`211`	`211`	`WakeUpWaiter();`
`212`		`-`
`213`		`- return ValueTask.CompletedTask;`
`214`	`212`	`}`
`215`	`213`
`216`	`214`	`private void CloseSession(T session)`
`@@ -273,11 +271,24 @@ public async ValueTask DisposeAsync()`
`273`	`271`	`}`
`274`	`272`	`}`
`275`	`273`
`276`		`- await TryDisposeCore();`
`277`		`- }`
	`274`	`+ var spinWait = new SpinWait();`
	`275`	`+ do`
	`276`	`+ {`
	`277`	`+ for (var i = 0; i < _maxSessionSize; i++)`
	`278`	`+ {`
	`279`	`+ var session = Volatile.Read(ref _sessions[i]);`
`278`	`280`
`279`		`- private ValueTask TryDisposeCore() =>`
`280`		`- _numSessions == 0 ? _sessionFactory.DisposeAsync() : ValueTask.CompletedTask;`
	`281`	`+ if (session != null && session.CompareAndSet(PoolingSessionState.In, PoolingSessionState.Clean))`
	`282`	`+ {`
	`283`	`+ CloseSession(session);`
	`284`	`+ }`
	`285`	`+ }`
	`286`	`+`
	`287`	`+ spinWait.SpinOnce();`
	`288`	`+ } while (_numSessions > 0);`
	`289`	`+`
	`290`	`+ await _sessionFactory.DisposeAsync();`
	`291`	`+ }`
`281`	`292`	`}`
`282`	`293`
`283`	`294`	`internal interface IPoolingSessionFactory<T> : IAsyncDisposable where T : PoolingSessionBase<T>`
`@@ -330,5 +341,5 @@ public abstract ValueTask<IServerStream<ExecuteQueryResponsePart>> ExecuteQuery(`
`330`	`341`
`331`	`342`	`public abstract void OnNotSuccessStatusCode(StatusCode code);`
`332`	`343`
`333`		`- public ValueTask Close() => _source.Return((T)this);`
	`344`	`+ public void Close() => _source.Return((T)this);`
`334`	`345`	`}`
Original file line number	Diff line number	Diff line change
`@@ -143,7 +143,7 @@ public override async Task CloseAsync()`
`143`	`143`	`}`
`144`	`144`	`finally`
`145`	`145`	`{`
`146`		`- await _session.Close();`
	`146`	`+ _session.Close();`
`147`	`147`	`}`
`148`	`148`	`}`
`149`	`149`
Original file line number	Diff line number	Diff line change
`@@ -180,7 +180,7 @@ public ValueTask<IServerStream<ExecuteQueryResponsePart>> ExecuteQuery(`
`180`	`180`
`181`	`181`	`public new void OnNotSuccessStatusCode(StatusCode code) => base.OnNotSuccessStatusCode(code);`
`182`	`182`
`183`		`- public ValueTask Close() => Release();`
	`183`	`+ public void Close() => Release().AsTask().GetAwaiter().GetResult();`
`184`	`184`
`185`	`185`	`public async Task CommitTransaction(string txId, CancellationToken cancellationToken = default)`
`186`	`186`	`{`
Original file line number	Diff line number	Diff line change
`@@ -25,7 +25,7 @@ public void Setup()`
`25`	`25`	`public async Task SingleThreaded_OpenClose()`
`26`	`26`	`{`
`27`	`27`	`var session = await _poolingSessionSource.OpenSession();`
`28`		`- await session.Close();`
	`28`	`+ session.Close();`
`29`	`29`	`}`
`30`	`30`
`31`	`31`	`[Benchmark]`
`@@ -39,7 +39,7 @@ public async Task MultiThreaded_OpenClose()`
`39`	`39`	`{`
`40`	`40`	`var session = await _poolingSessionSource.OpenSession();`
`41`	`41`	`await Task.Yield();`
`42`		`- await session.Close();`
	`42`	`+ session.Close();`
`43`	`43`	`});`
`44`	`44`	`}`
`45`	`45`
`@@ -58,7 +58,7 @@ public async Task HighContention_OpenClose()`
`58`	`58`	`{`
`59`	`59`	`var session = await _poolingSessionSource.OpenSession();`
`60`	`60`	`await Task.Yield();`
`61`		`- await session.Close();`
	`61`	`+ session.Close();`
`62`	`62`	`});`
`63`	`63`	`}`
`64`	`64`
`@@ -79,7 +79,7 @@ public async Task SessionReuse_Pattern()`
`79`	`79`	`{`
`80`	`80`	`var session = await _poolingSessionSource.OpenSession();`
`81`	`81`	`await Task.Yield();`
`82`		`- await session.Close();`
	`82`	`+ session.Close();`
`83`	`83`	`}`
`84`	`84`	`});`
`85`	`85`	`}`
`@@ -102,7 +102,7 @@ public async Task SessionReuse_HighContention_Pattern()`
`102`	`102`	`{`
`103`	`103`	`var session = await _poolingSessionSource.OpenSession();`
`104`	`104`	`await Task.Yield();`
`105`		`- await session.Close();`
	`105`	`+ session.Close();`
`106`	`106`	`}`
`107`	`107`	`});`
`108`	`108`	`}`
`@@ -124,7 +124,7 @@ public async Task SessionReuse_HighIterations_Pattern()`
`124`	`124`	`{`
`125`	`125`	`var session = await _poolingSessionSource.OpenSession();`
`126`	`126`	`await Task.Yield();`
`127`		`- await session.Close();`
	`127`	`+ session.Close();`
`128`	`128`	`}`
`129`	`129`	`});`
`130`	`130`	`}`
Original file line number	Diff line number	Diff line change
`@@ -20,7 +20,7 @@ public async Task Reuse_Session_Before_Creating_new()`
`20`	`20`	`new YdbConnectionStringBuilder());`
`21`	`21`	`var session = await sessionSource.OpenSession();`
`22`	`22`	`var sessionId = session.SessionId();`
`23`		`- await session.Close();`
	`23`	`+ session.Close();`
`24`	`24`	`session = await sessionSource.OpenSession();`
`25`	`25`	`Assert.Equal(sessionId, session.SessionId());`
`26`	`26`	`}`
`@@ -58,7 +58,7 @@ public async Task Creating_Session_Throw_Exception()`
`58`	`58`	`// ReSharper disable once AccessToModifiedClosure`
`59`	`59`	`Interlocked.Increment(ref countSuccess);`
`60`	`60`	`Assert.True(session.SessionId() > maxSessionSize * 2);`
`61`		`- await session.Close();`
	`61`	`+ session.Close();`
`62`	`62`	`}`
`63`	`63`	`catch (YdbException e)`
`64`	`64`	`{`
`@@ -95,7 +95,7 @@ public async Task HighContention_OpenClose_NotCanceledException()`
`95`	`95`	`var session = await sessionSource.OpenSession();`
`96`	`96`	`Assert.True(session.SessionId() <= maxSessionSize);`
`97`	`97`	`await Task.Yield();`
`98`		`- await session.Close();`
	`98`	`+ session.Close();`
`99`	`99`	`});`
`100`	`100`	`}`
`101`	`101`
`@@ -124,26 +124,25 @@ public async Task DisposeAsync_Cancel_WaitersSession()`
`124`	`124`	`waitingSessionTasks.Add(Task.Run(async () =>`
`125`	`125`	`{`
`126`	`126`	`var session = await sessionSource.OpenSession();`
`127`		`- await session.Close();`
	`127`	`+ session.Close();`
`128`	`128`	`}));`
`129`	`129`	`}`
`130`	`130`
`131`		`- await sessionSource.DisposeAsync();`
	`131`	`+ var disposeTask = Task.Run(async () => await sessionSource.DisposeAsync());`
`132`	`132`	`Assert.Equal(maxSessionSize, mockFactory.NumSession);`
`133`		`- Assert.Equal("Session Source is disposed.",`
`134`		`- (await Assert.ThrowsAsync<YdbException>(async () => await sessionSource.OpenSession())).Message);`
`135`	`133`
`136`	`134`	`for (var i = 0; i < maxSessionSize; i++)`
`137`	`135`	`{`
`138`		`- await Assert.ThrowsAsync<TaskCanceledException>(() => waitingSessionTasks[i]);`
	`136`	`+ openSessions[i].Close();`
`139`	`137`	`}`
`140`	`138`
	`139`	`+ await disposeTask;`
	`140`	`+ Assert.Equal(0, mockFactory.NumSession);`
`141`	`141`	`for (var i = 0; i < maxSessionSize; i++)`
`142`	`142`	`{`
`143`		`- await openSessions[i].Close();`
	`143`	`+ await Assert.ThrowsAnyAsync<Exception>(() => waitingSessionTasks[i]);`
`144`	`144`	`}`
`145`	`145`
`146`		`- Assert.Equal(0, mockFactory.NumSession);`
`147`	`146`	`Assert.Equal("Session Source is disposed.",`
`148`	`147`	`(await Assert.ThrowsAsync<YdbException>(async () => await sessionSource.OpenSession())).Message);`
`149`	`148`	`}`
`@@ -184,7 +183,7 @@ public async Task StressTest_DisposeAsync_Close_Driver()`
`184`	`183`	`{`
`185`	`184`	`var session = await sessionSource.OpenSession();`
`186`	`185`	`await Task.Yield();`
`187`		`- await session.Close();`
	`186`	`+ session.Close();`
`188`	`187`	`}`
`189`	`188`	`catch (YdbException e)`
`190`	`189`	`{`
`@@ -226,7 +225,7 @@ public async Task IdleTimeout_MinSessionSize_CloseNumSessionsMinusMinSessionCoun`
`226`	`225`
`227`	`226`	`foreach (var it in openSessions)`
`228`	`227`	`{`
`229`		`- await it.Close();`
	`228`	`+ it.Close();`
`230`	`229`	`}`
`231`	`230`
`232`	`231`	`await Task.Delay(TimeSpan.FromSeconds(idleTimeoutSeconds * 5)); // cleaning idle sessions`
`@@ -240,7 +239,7 @@ public async Task IdleTimeout_MinSessionSize_CloseNumSessionsMinusMinSessionCoun`
`240`	`239`
`241`	`240`	`foreach (var it in openSessionTasks)`
`242`	`241`	`{`
`243`		`- await (await it).Close();`
	`242`	`+ (await it).Close();`
`244`	`243`	`}`
`245`	`244`
`246`	`245`	`Assert.Equal(minSessionSize, mockFactory.NumSession);`
`@@ -273,7 +272,7 @@ public async Task StressTest_HighContention_OpenClose()`
`273`	`272`	`while (!cts.IsCancellationRequested)`
`274`	`273`	`{`
`275`	`274`	`var session = await sessionSource.OpenSession(cts.Token);`
`276`		`- await session.Close();`
	`275`	`+ session.Close();`
`277`	`276`	`await Task.Delay(Random.Shared.Next(maxSessionSize), cts.Token);`
`278`	`277`	`}`
`279`	`278`	`}`
`@@ -302,7 +301,7 @@ public async Task Get_Session_From_Exhausted_Pool()`
`302`	`301`	`cts.CancelAfter(500);`
`303`	`302`
`304`	`303`	`await Assert.ThrowsAsync<TaskCanceledException>(async () => await sessionSource.OpenSession(cts.Token));`
`305`		`- await session.Close();`
	`304`	`+ session.Close();`
`306`	`305`
`307`	`306`	`Assert.Equal(1, mockFactory.NumSession);`
`308`	`307`	`Assert.Equal(1, mockFactory.SessionOpenedCount);`
`@@ -323,7 +322,7 @@ public async Task Return_IsBroken_Session()`
`323`	`322`	`for (var it = 0; it < maxSessionSize * 2; it++)`
`324`	`323`	`{`
`325`	`324`	`var session = await sessionSource.OpenSession();`
`326`		`- await session.Close();`
	`325`	`+ session.Close();`
`327`	`326`	`}`
`328`	`327`
`329`	`328`	`Assert.Equal(0, mockFactory.NumSession);`
`@@ -352,7 +351,7 @@ public async Task CheckIdleSession_WhenIsBrokenInStack_CreateNewSession()`
`352`	`351`
`353`	`352`	`foreach (var session in openSessions)`
`354`	`353`	`{`
`355`		`- await session.Close();`
	`354`	`+ session.Close();`
`356`	`355`	`}`
`357`	`356`
`358`	`357`	`Assert.Equal(maxSessionSize, mockFactory.NumSession);`
`@@ -362,7 +361,7 @@ public async Task CheckIdleSession_WhenIsBrokenInStack_CreateNewSession()`
`362`	`361`	`{`
`363`	`362`	`var session = await sessionSource.OpenSession();`
`364`	`363`	`isBroken = false;`
`365`		`- await session.Close();`
	`364`	`+ session.Close();`
`366`	`365`	`}`
`367`	`366`
`368`	`367`	`Assert.Equal(1, mockFactory.NumSession);`
Original file line number	Diff line number	Diff line change
`@@ -293,10 +293,8 @@ private List<Task> GenerateTasks(string connectionString) => Enumerable.Range(0,`
`293`	`293`	`ydbConnection.ConnectionString = connectionString;`
`294`	`294`	`await ydbConnection.OpenAsync();`
`295`	`295`	`}`
`296`		`- catch (YdbException e)`
	`296`	`+ catch (YdbException)`
`297`	`297`	`{`
`298`		`- Assert.Equal(StatusCode.Unspecified, e.Code);`
`299`		`- Assert.Equal("Session Source is disposed.", e.Message);`
`300`	`298`	`Interlocked.Add(ref _counter, i);`
`301`	`299`	`return;`
`302`	`300`	`}`