Investigate Skipped Tests [HZ-5288] (#1029)

emreyigit · web-flow · commit 6f488829e358 · 2025-12-24T16:38:00.000+03:00
Investigated skipped tests, and enabled useful ones. There are still
some tests other than kerberos and cloud which are fine. These are not
related with product directly but some internal framework specific thing
to verify and the understanding.

The tests are investigated;
```
Skipped net8.0.Hazelcast.Tests.Cloud.CloudTests.SampleClient [&lt; 1 ms]
  Skipped net8.0.Hazelcast.Tests.Cloud.ServerlessCloudTests.RcPathTest [&lt; 1 ms]
  Skipped net8.0.Hazelcast.Tests.Cloud.ServerlessCloudTests.TestCloud(True,True) [&lt; 1 ms]
  Skipped net8.0.Hazelcast.Tests.Cloud.ServerlessCloudTests.TestCloud(True,False) [&lt; 1 ms]
  Skipped net8.0.Hazelcast.Tests.Cloud.ServerlessCloudTests.TestCloud(False,True) [&lt; 1 ms]
  Skipped net8.0.Hazelcast.Tests.Cloud.ServerlessCloudTests.TestCloud(False,False) [&lt; 1 ms]
  Skipped net8.0.Hazelcast.Tests.Cloud.ServerlessCloudTests.TestCloudWithResume(True,True) [&lt; 1 ms]
  Skipped net8.0.Hazelcast.Tests.Cloud.ServerlessCloudTests.TestCloudWithResume(True,False) [&lt; 1 ms]
  Skipped net8.0.Hazelcast.Tests.Cloud.ServerlessCloudTests.TestCloudWithResume(False,True) [&lt; 1 ms]
  Skipped net8.0.Hazelcast.Tests.Cloud.ServerlessCloudTests.TestCloudWithResume(False,False) [&lt; 1 ms]
  Skipped net8.0.Hazelcast.Tests.Clustering.MembersLifecycleTests.Test [&lt; 1 ms]
  Skipped net8.0.Hazelcast.Tests.Configuration.ConfigurationCollectionBinding.GetListInvalidValues [&lt; 1 ms]
  Skipped net8.0.Hazelcast.Tests.Configuration.Dynamic.DynamicConfigureMapTests.DefaultOptionsEncodeToSameMessageAsJava [&lt; 1 ms]
  Skipped net8.0.Hazelcast.Tests.Configuration.Dynamic.DynamicConfigureRingBufferTests.DefaultOptionsEncodeToSameMessageAsJava [&lt; 1 ms]
  Skipped net8.0.Hazelcast.Tests.DotNet.AsyncTests.Throwing1 [&lt; 1 ms]
  Skipped net8.0.Hazelcast.Tests.DotNet.AsyncTests.Throwing2 [&lt; 1 ms]
  Skipped net8.0.Hazelcast.Tests.DotNet.AsyncTests.Throwing3 [&lt; 1 ms]
  Skipped net8.0.Hazelcast.Tests.DotNet.AsyncTests.Throwing4 [&lt; 1 ms]
  Skipped net8.0.Hazelcast.Tests.NearCache.NearCacheRecoversFromDistortionsTest.CanConnectToCluster [&lt; 1 ms]
  Skipped net8.0.Hazelcast.Tests.NearCache.NearCacheRecoversFromDistortionsTest.NearCacheRecoversFromDistortions [&lt; 1 ms]
  Skipped net8.0.Hazelcast.Tests.Networking.NetworkingTests.CanRetryAndTimeout [&lt; 1 ms]
  Skipped net8.0.Hazelcast.Tests.Networking.NetworkingTests.Cluster [&lt; 1 ms]
  Skipped net8.0.Hazelcast.Tests.Networking.SocketConnectionTests.ReadPipeLoop_3 [&lt; 1 ms]
  Skipped net8.0.Hazelcast.Tests.Remote.ClientCollectionTestBase.TestCollectionUnsubscribeWitDispose [&lt; 1 ms]
  Skipped net8.0.Hazelcast.Tests.Remote.ClientMapTest.TestAddInterceptor [&lt; 1 ms]
  Skipped net8.0.Hazelcast.Tests.Remote.ClientCollectionTestBase.TestCollectionUnsubscribeWitDispose [&lt; 1 ms]
  Skipped net8.0.Hazelcast.Tests.Remote.ClientCollectionTestBase.TestCollectionUnsubscribeWitDispose [&lt; 1 ms]
  Skipped net8.0.Hazelcast.Tests.Remote.HeartbeatTests.DemoTest [&lt; 1 ms]
  Skipped net8.0.Hazelcast.Tests.Remote.HeartbeatTests.Heartbeat [&lt; 1 ms]
  Skipped net8.0.Hazelcast.Tests.Serialization.Compact.CompactQaTests.ExceptionPreventsClientFromReconnecting(True) [&lt; 1 ms]
  Skipped net8.0.Hazelcast.Tests.Serialization.Compact.CompactQaTests.ExceptionPreventsClientFromReconnecting(False) [&lt; 1 ms]
  Skipped net8.0.Hazelcast.Tests.Serialization.Compact.CompactQaTests.MemberAddressMatch [&lt; 1 ms]
  Skipped net8.0.Hazelcast.Tests.Support.Issue501.Reproduce(True) [&lt; 1 ms]
  Skipped net8.0.Hazelcast.Tests.Support.Issue501.Reproduce(False) [&lt; 1 ms]
  Skipped net8.0.Hazelcast.Tests.Testing.FeatureConditionIgnoresTest.WouldFail [&lt; 1 ms]
  Skipped net8.0.Hazelcast.Tests.Testing.NUnitTests.Timeout [&lt; 1 ms]
  Skipped net8.0.Hazelcast.Tests.Testing.TestConditionIgnoresTest.WouldFail [&lt; 1 ms]
  Skipped net8.0.Hazelcast.Tests.Testing.TestConditionsTestsBase.CanDoSomethingOn2 [&lt; 1 ms]
  Skipped net8.0.Hazelcast.Tests.Testing.TestConditionsTestsBase.CannotDoSomethingOn1 [&lt; 1 ms]
```
diff --git a/src/Hazelcast.Net.Tests/Clustering/MembersLifecycleTests.cs b/src/Hazelcast.Net.Tests/Clustering/MembersLifecycleTests.cs
@@ -27,7 +27,6 @@
 namespace Hazelcast.Tests.Clustering
 {
     [TestFixture]
-    [Explicit("Stress tests, take time.")]
     public class MembersLifecycleTests : MultiMembersRemoteTestBase
     {
         private const int RunCount = 16;
diff --git a/src/Hazelcast.Net.Tests/Configuration/ConfigurationCollectionBindingTests.cs b/src/Hazelcast.Net.Tests/Configuration/ConfigurationCollectionBindingTests.cs
@@ -71,7 +71,6 @@ public void GetListNullValues()
         }
 
         [Test]
-        [Ignore("Our binder throws on purpose.")]
         public void GetListInvalidValues()
         {
             var input = new Dictionary<string, string>
@@ -84,11 +83,8 @@ public void GetListInvalidValues()
             configurationBuilder.AddInMemoryCollection(input);
             var config = configurationBuilder.Build();
             var list = new List<bool>();
-            config.GetSection("InvalidList").HzBind(list);
 
-            //Assert.Single(list);
-            Assert.AreEqual(list.Count, 1);
-            Assert.True(list[0]);
+            Assert.Throws<InvalidOperationException>(()=>config.GetSection("InvalidList").HzBind(list));
         }
 
         [Test]
diff --git a/src/Hazelcast.Net.Tests/Configuration/Dynamic/DynamicConfigureMapTests.cs b/src/Hazelcast.Net.Tests/Configuration/Dynamic/DynamicConfigureMapTests.cs
@@ -217,7 +217,7 @@ await client.DynamicOptions.ConfigureMapAsync("map-name", options =>
     }
 
     [Test]
-    [ServerCondition("[5.4]")]
+    [ServerCondition("5.4")]
     public async Task DefaultOptionsEncodeToSameMessageAsJava()
     {
         const string script = @"
diff --git a/src/Hazelcast.Net.Tests/Configuration/Dynamic/DynamicConfigureRingBufferTests.cs b/src/Hazelcast.Net.Tests/Configuration/Dynamic/DynamicConfigureRingBufferTests.cs
@@ -49,7 +49,7 @@ await client.DynamicOptions.ConfigureRingbufferAsync("buffer-name", options =>
     }
 
     [Test]
-    [ServerCondition("[5.4]")]
+    [ServerCondition("5.4")]
     public async Task DefaultOptionsEncodeToSameMessageAsJava()
     {
         // CI error: trying to invoke this:
diff --git a/src/Hazelcast.Net.Tests/NearCache/NearCacheRecoversFromDistortionsTest.cs b/src/Hazelcast.Net.Tests/NearCache/NearCacheRecoversFromDistortionsTest.cs
@@ -21,7 +21,6 @@
 namespace Hazelcast.Tests.NearCache
 {
     [TestFixture]
-    [KnownIssue(305, "fails on Linux")]
     public class NearCacheRecoversFromDistortionsTest : NearCacheTestBase
     {
         private IHazelcastClient _client;
diff --git a/src/Hazelcast.Net.Tests/Networking/NetworkingTests.cs b/src/Hazelcast.Net.Tests/Networking/NetworkingTests.cs
@@ -239,7 +239,6 @@ await AssertEx.ThrowsAsync<OperationCanceledException>(async ()
 
         [Test]
         [Timeout(10_000)]
-        [KnownIssue(0, "Breaks on GitHub Actions")] // TODO we should deal with this
         public async Task CanRetryAndTimeout()
         {
             var address = NetworkAddress.Parse("127.0.0.1:" + TestEndPointPort.GetNext());
diff --git a/src/Hazelcast.Net.Tests/Networking/SocketConnectionTests.cs b/src/Hazelcast.Net.Tests/Networking/SocketConnectionTests.cs
@@ -346,7 +346,6 @@ public async Task ReadPipeLoop_2()
         }
 
         [Test]
-        [KnownIssue(0, "Breaks on GitHub Actions")]
         public async Task ReadPipeLoop_3()
         {
             //using var _ = EnableHConsoleForTest();
diff --git a/src/Hazelcast.Net.Tests/Remote/ClientCollectionTestBase.cs b/src/Hazelcast.Net.Tests/Remote/ClientCollectionTestBase.cs
@@ -265,6 +265,8 @@ public async Task TestCollectionUnsubscribeWitDispose()
             await Task.Delay(4_000);
             Assert.That(eventsCount, Is.Zero);
         }
+        
+
 
         [Test]
         public async Task TestCollectionGetAsyncEnumerator()
diff --git a/src/Hazelcast.Net.Tests/Remote/ClientTests.cs b/src/Hazelcast.Net.Tests/Remote/ClientTests.cs
@@ -12,9 +12,12 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 using System;
+using System.Text;
+using System.Threading;
 using System.Threading.Tasks;
 using Hazelcast.Configuration;
 using Hazelcast.Testing;
+using Hazelcast.Testing.Remote;
 using Microsoft.Extensions.Configuration;
 using NUnit.Framework;
 
@@ -40,16 +43,16 @@ public async Task ClientCanConnect()
         [Test]
         public async Task ClientStartingClientWithConfig()
         {
-            var clientStarting =  HazelcastClientFactory.GetNewStartingClient(CreateHazelcastOptions());
+            var clientStarting = HazelcastClientFactory.GetNewStartingClient(CreateHazelcastOptions());
             await clientStarting.Task;
             await clientStarting.Client.DisposeAsync();
         }
-        
+
         [Test]
         public async Task ClientStatringClientWithConfig2()
         {
             var o = CreateHazelcastOptions();
-            var clientStarting =  HazelcastClientFactory.GetNewStartingClient(options=>
+            var clientStarting = HazelcastClientFactory.GetNewStartingClient(options =>
             {
                 options.Networking.Addresses.Clear();
                 options.Networking.Addresses.Add("127.0.0.1:5701");
@@ -66,8 +69,8 @@ public async Task ClientCanConnectAsync()
 
             //using var _ = HConsole.Capture(options => options
             //    .Set(x => x.SetLevel(1)));
-            
-            Assert.Throws<ArgumentNullException>(() => HazelcastClientFactory.GetNewStartingClient((HazelcastOptions)null));
+
+            Assert.Throws<ArgumentNullException>(() => HazelcastClientFactory.GetNewStartingClient((HazelcastOptions) null));
 
             var clientStart = HazelcastClientFactory.GetNewStartingClient(CreateHazelcastOptions());
             var client = clientStart.Client;
@@ -99,7 +102,7 @@ public async Task StartingFailoverClientCanConnect()
             await startingClient.Task;
             await startingClient.Client.DisposeAsync();
         }
-        
+
         [Test]
         [Category("enterprise")] // Failover is an Enterprise feature
         public async Task StartingFailoverClientCanConnect2()
@@ -113,7 +116,7 @@ public async Task StartingFailoverClientCanConnect2()
             await startingClient.Task;
             await startingClient.Client.DisposeAsync();
         }
-        
+
         [Test]
         [Category("enterprise")] // Failover is an Enterprise feature
         public async Task FailoverClientCanConnect2()
@@ -126,7 +129,7 @@ public async Task FailoverClientCanConnect2()
             var client = await HazelcastClientFactory.StartNewFailoverClientAsync(opt =>
             {
                 opt.Clients.Add(CreateHazelcastOptions());
-                opt.TryCount=1;
+                opt.TryCount = 1;
             });
 
             await client.DisposeAsync();
@@ -141,7 +144,7 @@ public async Task FailoverClientCanConnectAsync()
             //using var _ = HConsole.Capture(options => options
             //    .Set(x => x.SetLevel(1)));
 
-            Assert.Throws<ArgumentNullException>(() => HazelcastClientFactory.GetNewStartingFailoverClient((HazelcastFailoverOptions)null));
+            Assert.Throws<ArgumentNullException>(() => HazelcastClientFactory.GetNewStartingFailoverClient((HazelcastFailoverOptions) null));
 
             var clientStart = HazelcastClientFactory.GetNewStartingFailoverClient(CreateHazelcastFailoverOptions());
             var client = clientStart.Client;
@@ -164,5 +167,36 @@ private HazelcastFailoverOptions CreateHazelcastFailoverOptions()
 
             return failoverOptions;
         }
+
+        [Test]
+        [Ignore("DisposeAsync should unsubscribe events")]
+        public async Task TestSubscriptionsRemovedDuringDispose()
+        {
+            var client = await HazelcastClientFactory.StartNewClientAsync(CreateHazelcastOptions());
+
+            var mapName = "map-test-subscriptions-removed-during-dispose";
+            var map = await client.GetMapAsync<int, int>(mapName);
+            var eventsCount = 0;
+            var sid = await map.SubscribeAsync(events => events
+                .EntryAdded((sender, args) => { Interlocked.Increment(ref eventsCount); }));
+
+            Assert.AreEqual(0, await map.GetSizeAsync());
+            await map.PutAsync(1, 1);
+            await AssertEx.SucceedsEventually(() => Assert.NotZero(eventsCount), 5000, 200);
+            
+            await map.DisposeAsync();
+            
+            var script = @"
+
+var nodeEngineImpl = com.hazelcast.instance.impl.TestUtil.getNode(instance_0).nodeEngine;
+var es = nodeEngineImpl.getEventService();
+var hasIt = es.hasEventRegistration(""hz:impl:mapService"",""" + mapName + "\");" +
+                         @" result = hasIt ? ""True"":""False"";  ";
+
+            
+            var response = await RcClient.ExecuteOnControllerAsync(RcCluster.Id, script, Lang.JAVASCRIPT, CancellationToken.None);
+            
+            Assert.False(Convert.ToBoolean(Encoding.UTF8.GetString(response.Result)));
+        }
     }
 }
diff --git a/src/Hazelcast.Net.Tests/Remote/HeartbeatTests.cs b/src/Hazelcast.Net.Tests/Remote/HeartbeatTests.cs
@@ -26,7 +26,6 @@
 namespace Hazelcast.Tests.Remote
 {
     [TestFixture]
-    [Explicit("Takes time")]
     public class HeartbeatTests : SingleMemberRemoteTestBase
     {
         protected override HazelcastOptions CreateHazelcastOptions()
diff --git a/src/Hazelcast.Net.Tests/Serialization/Compact/CompactQaTests.cs b/src/Hazelcast.Net.Tests/Serialization/Compact/CompactQaTests.cs
@@ -16,6 +16,7 @@
 using System.Linq;
 using System.Threading;
 using System.Threading.Tasks;
+using Hazelcast.Clustering;
 using Hazelcast.Core;
 using Hazelcast.Exceptions;
 using Hazelcast.Messaging;
@@ -35,7 +36,7 @@ namespace Hazelcast.Tests.Serialization.Compact;
 public class CompactQaTests : ClusterRemoteTestBase
 {
     [Test]
-    [Explicit("See comment in test.")]
+    // [Explicit("See comment in test.")]
     public async Task MemberAddressMatch()
     {
         HConsole.Configure(options => options.ConfigureDefaults(this));
@@ -56,21 +57,19 @@ public async Task MemberAddressMatch()
         await using var client = await HazelcastClientFactory.StartNewClientAsync(options);
     }
 
-    [TestCase(true)]
-    [TestCase(false)]
-    [Explicit]
-    public async Task ExceptionPreventsClientFromReconnecting(bool recover)
+    [Test]
+    public async Task ExceptionPreventsClientFromReconnecting()
     {
         HConsole.Configure(options => options.ConfigureDefaults(this));
 
         // in case a test times out, NUnit just reports that it failed, without further
         // details - in fact, it does not even say that the test timed out - so by wrapping
         // the actual test method this way, we make sure that the test "fails" instead of
         // timing out, and we get proper output (eg HConsole output)
-        await ExceptionPreventsClientFromReconnectingTask(recover).CfAwait(TimeSpan.FromSeconds(60));
+        await ExceptionPreventsClientFromReconnectingTask().CfAwait(TimeSpan.FromSeconds(60));
     }
 
-    private async Task ExceptionPreventsClientFromReconnectingTask(bool recover)
+    private async Task ExceptionPreventsClientFromReconnectingTask()
     {
         var throwException = false;
 
@@ -81,13 +80,8 @@ private async Task ExceptionPreventsClientFromReconnectingTask(bool recover)
         // use a clean client + hook into cluster messaging to capture messages (before client starts)
         var options = CreateHazelcastOptions();
         options.Messaging.RetryTimeoutSeconds = 20;
-        await using var client = HazelcastClientFactory.CreateClient(options);
-        // use an internal-level handler, exceptions in user-level handlers are caught
-        client.Cluster.Connections.ConnectionOpened += (_, _, _, _, _) =>
-        {
-            if (throwException) throw new Exception("bang!");
-            return default;
-        };
+        await using HazelcastClient client = HazelcastClientFactory.CreateClient(options);
+        var conQueue = (MemberConnectionQueue) client.Cluster.Members.MemberConnectionRequests;
         await client.StartAsync(CancellationToken.None);
 
         var map = await client.GetMapAsync<int, IGenericRecord>("bar");
@@ -99,46 +93,31 @@ private async Task ExceptionPreventsClientFromReconnectingTask(bool recover)
         await RcClient.StopMemberWaitRemovedAsync(client, RcCluster, member).CfAwait();
 
         // trigger exceptions
-        throwException = true;
-        if (recover)
-        {
-            async Task RecoverAfter(int delayMilliseconds)
-            {
-                await Task.Delay(delayMilliseconds);
-                throwException = false;
-            }
+        Volatile.Write(ref throwException, true);
+        await conQueue.SuspendAsync();
+
 
-            var recoverTask = RecoverAfter(5000); // fire-and-forget
+        async Task RecoverAfter(int delayMilliseconds)
+        {
+            await Task.Delay(delayMilliseconds);
+            Volatile.Write(ref throwException, false);
+            conQueue.Resume();
         }
 
+        var recoverTask = RecoverAfter(5000); // fire-and-forget
+
+
         HConsole.WriteLine(this, "-------- START MEMBER --------");
 
         // start another member
         member = await RcClient.StartMemberAsync(RcCluster).CfAwait();
 
         HConsole.WriteLine(this, "-------- PUT ASYNC --------");
 
-        if (recover)
-        {
-            // this will eventually complete once we're able to reconnect
-            await map.PutAsync(2, GenericRecordBuilder.Compact("bar2").Build()).CfAwait();
-        }
-        else
-        {
-            // this will never complete because we'll never be able to reconnect
-            //
-            // Java: ReconnectMode can be OFF, ON (blocking invocations) or ASYNC (not blocking, triggers HazelcastClientOfflineException)
-            // .NET: ReconnectMode can be DoNotReconnect = OFF, ReconnectSync or ReconnectAsync - but these two have the same effect
-            //
-            // In Java, ASYNC causes any invocation to *immediately* fail with HazelcastClientOfflineException if the client is
-            // reconnecting, whereas ON causes the invocation to be retried, and it may eventually fail with OperationTimeoutException.
-            //
-            // In .NET, invocations are tried (and retried) while the client is reconnecting, until either the client reconnects and
-            // the invocation succeeds, or it times out. So, essentially, .NET is ON and it makes sense that we get a TaskTimeoutException
-            // below.
-
-            await AssertEx.ThrowsAsync<TaskTimeoutException>(async () => await map.PutAsync(2, GenericRecordBuilder.Compact("bar2").Build()).CfAwait());
-        }
+
+        // this will eventually complete once we're able to reconnect
+        await map.PutAsync(2, GenericRecordBuilder.Compact("bar2").Build()).CfAwait();
+
 
         HConsole.WriteLine(this, "-------- STOP MEMBER --------");
 
@@ -242,4 +221,4 @@ protected override HazelcastOptionsBuilder CreateHazelcastOptionsBuilder()
     {
         return base.CreateHazelcastOptionsBuilder().WithHConsoleLogger();
     }
-}
+}

Original file line number	Diff line number	Diff line change
`@@ -27,7 +27,6 @@`
`27`	`27`	`namespace Hazelcast.Tests.Clustering`
`28`	`28`	`{`
`29`	`29`	`[TestFixture]`
`30`		`- [Explicit("Stress tests, take time.")]`
`31`	`30`	`public class MembersLifecycleTests : MultiMembersRemoteTestBase`
`32`	`31`	`{`
`33`	`32`	`private const int RunCount = 16;`
Original file line number	Diff line number	Diff line change
`@@ -71,7 +71,6 @@ public void GetListNullValues()`
`71`	`71`	`}`
`72`	`72`
`73`	`73`	`[Test]`
`74`		`- [Ignore("Our binder throws on purpose.")]`
`75`	`74`	`public void GetListInvalidValues()`
`76`	`75`	`{`
`77`	`76`	`var input = new Dictionary<string, string>`
`@@ -84,11 +83,8 @@ public void GetListInvalidValues()`
`84`	`83`	`configurationBuilder.AddInMemoryCollection(input);`
`85`	`84`	`var config = configurationBuilder.Build();`
`86`	`85`	`var list = new List<bool>();`
`87`		`- config.GetSection("InvalidList").HzBind(list);`
`88`	`86`
`89`		`- //Assert.Single(list);`
`90`		`- Assert.AreEqual(list.Count, 1);`
`91`		`- Assert.True(list[0]);`
	`87`	`+ Assert.Throws<InvalidOperationException>(()=>config.GetSection("InvalidList").HzBind(list));`
`92`	`88`	`}`
`93`	`89`
`94`	`90`	`[Test]`
Original file line number	Diff line number	Diff line change
`@@ -217,7 +217,7 @@ await client.DynamicOptions.ConfigureMapAsync("map-name", options =>`
`217`	`217`	`}`
`218`	`218`
`219`	`219`	`[Test]`
`220`		`- [ServerCondition("[5.4]")]`
	`220`	`+ [ServerCondition("5.4")]`
`221`	`221`	`public async Task DefaultOptionsEncodeToSameMessageAsJava()`
`222`	`222`	`{`
`223`	`223`	`const string script = @"`
Original file line number	Diff line number	Diff line change
`@@ -49,7 +49,7 @@ await client.DynamicOptions.ConfigureRingbufferAsync("buffer-name", options =>`
`49`	`49`	`}`
`50`	`50`
`51`	`51`	`[Test]`
`52`		`- [ServerCondition("[5.4]")]`
	`52`	`+ [ServerCondition("5.4")]`
`53`	`53`	`public async Task DefaultOptionsEncodeToSameMessageAsJava()`
`54`	`54`	`{`
`55`	`55`	`// CI error: trying to invoke this:`
Original file line number	Diff line number	Diff line change
`@@ -21,7 +21,6 @@`
`21`	`21`	`namespace Hazelcast.Tests.NearCache`
`22`	`22`	`{`
`23`	`23`	`[TestFixture]`
`24`		`- [KnownIssue(305, "fails on Linux")]`
`25`	`24`	`public class NearCacheRecoversFromDistortionsTest : NearCacheTestBase`
`26`	`25`	`{`
`27`	`26`	`private IHazelcastClient _client;`
Original file line number	Diff line number	Diff line change
`@@ -239,7 +239,6 @@ await AssertEx.ThrowsAsync<OperationCanceledException>(async ()`
`239`	`239`
`240`	`240`	`[Test]`
`241`	`241`	`[Timeout(10_000)]`
`242`		`- [KnownIssue(0, "Breaks on GitHub Actions")] // TODO we should deal with this`
`243`	`242`	`public async Task CanRetryAndTimeout()`
`244`	`243`	`{`
`245`	`244`	`var address = NetworkAddress.Parse("127.0.0.1:" + TestEndPointPort.GetNext());`
Original file line number	Diff line number	Diff line change
`@@ -346,7 +346,6 @@ public async Task ReadPipeLoop_2()`
`346`	`346`	`}`
`347`	`347`
`348`	`348`	`[Test]`
`349`		`- [KnownIssue(0, "Breaks on GitHub Actions")]`
`350`	`349`	`public async Task ReadPipeLoop_3()`
`351`	`350`	`{`
`352`	`351`	`//using var _ = EnableHConsoleForTest();`
Original file line number	Diff line number	Diff line change
`@@ -265,6 +265,8 @@ public async Task TestCollectionUnsubscribeWitDispose()`
`265`	`265`	`await Task.Delay(4_000);`
`266`	`266`	`Assert.That(eventsCount, Is.Zero);`
`267`	`267`	`}`
	`268`	`+`
	`269`	`+`
`268`	`270`
`269`	`271`	`[Test]`
`270`	`272`	`public async Task TestCollectionGetAsyncEnumerator()`
Original file line number	Diff line number	Diff line change
`@@ -26,7 +26,6 @@`
`26`	`26`	`namespace Hazelcast.Tests.Remote`
`27`	`27`	`{`
`28`	`28`	`[TestFixture]`
`29`		`- [Explicit("Takes time")]`
`30`	`29`	`public class HeartbeatTests : SingleMemberRemoteTestBase`
`31`	`30`	`{`
`32`	`31`	`protected override HazelcastOptions CreateHazelcastOptions()`