~rename base test class to SingleClusterSystemXCTestCase to make it more clear

ktoso · ktoso · commit 717fdabfbf1e · 2022-08-16T14:57:46.000+09:00
diff --git a/Sources/DistributedActorsTestKit/Cluster/ClusteredActorSystemsXCTestCase.swift b/Sources/DistributedActorsTestKit/Cluster/ClusteredActorSystemsXCTestCase.swift
@@ -236,7 +236,7 @@ open class ClusteredActorSystemsXCTestCase: XCTestCase {
 // MARK: Printing information
 
 extension ClusteredActorSystemsXCTestCase {
-    public func pinfoMembership(_ system: ClusterSystem, file: StaticString = #filePath, line: UInt = #line) {
+    public func pinfoMembership(_ system: ClusterSystem, file: StaticString = #fileID, line: UInt = #line) {
         let testKit = self.testKit(system)
         let p = testKit.makeTestProbe(expecting: Cluster.Membership.self)
 
diff --git a/Sources/DistributedActorsTestKit/ClusterSystemXCTestCase.swift b/Sources/DistributedActorsTestKit/ClusterSystemXCTestCase.swift
@@ -19,7 +19,7 @@ import NIO
 import XCTest
 
 /// Base class to handle the repetitive setUp/tearDown code involved in most `ClusterSystem` requiring tests.
-open class ClusterSystemXCTestCase: ClusteredActorSystemsXCTestCase {
+open class SingleClusterSystemXCTestCase: ClusteredActorSystemsXCTestCase {
     public var system: ClusterSystem {
         guard let node = self._nodes.first else {
             fatalError("No system spawned!")
diff --git a/Tests/DistributedActorsTestKitTests/ActorTestProbeTests.swift b/Tests/DistributedActorsTestKitTests/ActorTestProbeTests.swift
@@ -16,7 +16,7 @@ import DistributedActors
 @testable import DistributedActorsTestKit
 import XCTest
 
-final class ActorTestProbeTests: ClusterSystemXCTestCase {
+final class ActorTestProbeTests: SingleClusterSystemXCTestCase {
 
     func test_maybeExpectMessage_shouldReturnTheReceivedMessage() throws {
         let probe = self.testKit.makeTestProbe("p2", expecting: String.self)
@@ -52,7 +52,7 @@ final class ActorTestProbeTests: ClusterSystemXCTestCase {
         try watchingProbe.expectTerminated(watchedProbe.ref)
     }
 
-    func test_expectMessageAnyOrderSuccess() throws {
+    func test_expectMessageAnyOrderSuccess() async throws {
         let p = self.testKit.makeTestProbe(expecting: String.self)
         let messages = ["test1", "test2", "test3", "test4"]
 
diff --git a/Tests/DistributedActorsTests/ActorAskTests.swift b/Tests/DistributedActorsTests/ActorAskTests.swift
@@ -17,7 +17,7 @@ import DistributedActorsTestKit
 import Foundation
 import XCTest
 
-final class ActorAskTests: ClusterSystemXCTestCase {
+final class ActorAskTests: SingleClusterSystemXCTestCase {
     struct TestMessage: Codable {
         let replyTo: _ActorRef<String>
     }
diff --git a/Tests/DistributedActorsTests/ActorIsolationFailureHandlingTests.swift b/Tests/DistributedActorsTests/ActorIsolationFailureHandlingTests.swift
@@ -17,7 +17,7 @@ import DistributedActorsTestKit
 import Foundation
 import XCTest
 
-final class ActorIsolationFailureHandlingTests: ClusterSystemXCTestCase {
+final class ActorIsolationFailureHandlingTests: SingleClusterSystemXCTestCase {
     private enum SimpleTestError: Error {
         case simpleError(reason: String)
     }
diff --git a/Tests/DistributedActorsTests/ActorLeakingTests.swift b/Tests/DistributedActorsTests/ActorLeakingTests.swift
@@ -19,7 +19,7 @@ import DistributedActorsTestKit
 import Foundation
 import XCTest
 
-final class ActorLeakingTests: ClusterSystemXCTestCase {
+final class ActorLeakingTests: SingleClusterSystemXCTestCase {
     struct NotEnoughActorsAlive: Error {
         let expected: Int
         let current: Int
diff --git a/Tests/DistributedActorsTests/ActorLifecycleTests.swift b/Tests/DistributedActorsTests/ActorLifecycleTests.swift
@@ -17,7 +17,7 @@ import DistributedActorsTestKit
 import Foundation
 import XCTest
 
-class ActorLifecycleTests: ClusterSystemXCTestCase {
+class ActorLifecycleTests: SingleClusterSystemXCTestCase {
     // ==== ------------------------------------------------------------------------------------------------------------
     // MARK: starting actors
 
diff --git a/Tests/DistributedActorsTests/ActorLoggingTests.swift b/Tests/DistributedActorsTests/ActorLoggingTests.swift
@@ -17,7 +17,7 @@ import DistributedActorsTestKit
 import Foundation
 import XCTest
 
-final class ActorLoggingTests: ClusterSystemXCTestCase {
+final class ActorLoggingTests: SingleClusterSystemXCTestCase {
     var exampleSenderPath: ActorPath!
 
     override func setUp() {
diff --git a/Tests/DistributedActorsTests/ActorRefAdapterTests.swift b/Tests/DistributedActorsTests/ActorRefAdapterTests.swift
@@ -17,7 +17,7 @@ import DistributedActorsTestKit
 import Foundation
 import XCTest
 
-class _ActorRefAdapterTests: ClusterSystemXCTestCase {
+class _ActorRefAdapterTests: SingleClusterSystemXCTestCase {
     func test_adaptedRef_shouldConvertMessages() throws {
         let probe = self.testKit.makeTestProbe(expecting: String.self)
         let refProbe = self.testKit.makeTestProbe(expecting: _ActorRef<Int>.self)
diff --git a/Tests/DistributedActorsTests/ActorSubReceiveTests.swift b/Tests/DistributedActorsTests/ActorSubReceiveTests.swift
@@ -17,7 +17,7 @@ import DistributedActorsTestKit
 import Foundation
 import XCTest
 
-final class ActorSubReceiveTests: ClusterSystemXCTestCase {
+final class ActorSubReceiveTests: SingleClusterSystemXCTestCase {
     func test_subReceive_shouldBeAbleToReceiveMessages() throws {
         let p = self.testKit.makeTestProbe(expecting: String.self)
         let refProbe = self.testKit.makeTestProbe(expecting: _ActorRef<String>.self)
diff --git a/Tests/DistributedActorsTests/BehaviorCanonicalizeTests.swift b/Tests/DistributedActorsTests/BehaviorCanonicalizeTests.swift
@@ -17,7 +17,7 @@ import DistributedActorsTestKit
 import Foundation
 import XCTest
 
-final class BehaviorCanonicalizeTests: ClusterSystemXCTestCase {
+final class BehaviorCanonicalizeTests: SingleClusterSystemXCTestCase {
     func test_canonicalize_nestedSetupBehaviors() throws {
         let p: ActorTestProbe<String> = self.testKit.makeTestProbe("canonicalizeProbe1")
 
diff --git a/Tests/DistributedActorsTests/BehaviorTests.swift b/Tests/DistributedActorsTests/BehaviorTests.swift
@@ -19,7 +19,7 @@ import Foundation
 import NIO
 import XCTest
 
-final class BehaviorTests: ClusterSystemXCTestCase {
+final class BehaviorTests: SingleClusterSystemXCTestCase {
     public struct TestMessage: Codable {
         let message: String
         let replyTo: _ActorRef<String>
diff --git a/Tests/DistributedActorsTests/Clocks/Protobuf/VersionVector+SerializationTests.swift b/Tests/DistributedActorsTests/Clocks/Protobuf/VersionVector+SerializationTests.swift
@@ -16,7 +16,7 @@
 import DistributedActorsTestKit
 import XCTest
 
-final class VersionVectorSerializationTests: ClusterSystemXCTestCase {
+final class VersionVectorSerializationTests: SingleClusterSystemXCTestCase {
     var node: UniqueNode {
         self.system.cluster.uniqueNode
     }
diff --git a/Tests/DistributedActorsTests/Cluster/ClusterDiscoveryTests.swift b/Tests/DistributedActorsTests/Cluster/ClusterDiscoveryTests.swift
@@ -19,7 +19,7 @@ import NIO
 import ServiceDiscovery
 import XCTest
 
-final class ClusterDiscoveryTests: ClusterSystemXCTestCase {
+final class ClusterDiscoveryTests: SingleClusterSystemXCTestCase {
     let A = Cluster.Member(node: UniqueNode(node: Node(systemName: "A", host: "1.1.1.1", port: 7337), nid: .random()), status: .up)
     let B = Cluster.Member(node: UniqueNode(node: Node(systemName: "B", host: "2.2.2.2", port: 8228), nid: .random()), status: .up)
 
diff --git a/Tests/DistributedActorsTests/Cluster/ClusterEventStreamTests.swift b/Tests/DistributedActorsTests/Cluster/ClusterEventStreamTests.swift
@@ -17,7 +17,7 @@ import DistributedActorsTestKit
 import NIO
 import XCTest
 
-final class ClusterEventStreamTests: ClusterSystemXCTestCase, @unchecked Sendable {
+final class ClusterEventStreamTests: SingleClusterSystemXCTestCase, @unchecked Sendable {
     let memberA = Cluster.Member(node: UniqueNode(node: Node(systemName: "System", host: "1.1.1.1", port: 7337), nid: .random()), status: .up)
     let memberB = Cluster.Member(node: UniqueNode(node: Node(systemName: "System", host: "2.2.2.2", port: 8228), nid: .random()), status: .up)
 
diff --git a/Tests/DistributedActorsTests/Cluster/DowningStrategy/DowningClusteredTests.swift b/Tests/DistributedActorsTests/Cluster/DowningStrategy/DowningClusteredTests.swift
@@ -105,16 +105,16 @@ final class DowningClusteredTests: ClusteredActorSystemsXCTestCase {
             return { event in
                 switch event {
                 case .membershipChange(let change) where change.node == expectedDownNode && change.isRemoval:
-                    pinfo("\(on.cluster.uniqueNode.node): \(change)", file: file, line: line)
+                    pinfo("\(on.cluster.uniqueNode.node): \(change)", file: (file), line: line)
                     return .catchComplete(change)
                 case .membershipChange(let change) where change.node == expectedDownNode:
-                    pinfo("\(on.cluster.uniqueNode.node): \(change)", file: file, line: line)
+                    pinfo("\(on.cluster.uniqueNode.node): \(change)", file: (file), line: line)
                     return .catchContinue(change)
                 case .reachabilityChange(let change) where change.member.uniqueNode == expectedDownNode:
-                    pnote("\(on.cluster.uniqueNode.node): \(change)", file: file, line: line)
+                    pnote("\(on.cluster.uniqueNode.node): \(change)", file: (file), line: line)
                     return .ignore
                 default:
-                    pnote("\(on.cluster.uniqueNode.node): \(event)", file: file, line: line)
+                    pnote("\(on.cluster.uniqueNode.node): \(event)", file: (file), line: line)
                     return .ignore
                 }
             }
diff --git a/Tests/DistributedActorsTests/Cluster/Protobuf/ClusterEvents+SerializationTests.swift b/Tests/DistributedActorsTests/Cluster/Protobuf/ClusterEvents+SerializationTests.swift
@@ -18,7 +18,7 @@ import Logging
 import NIO
 import XCTest
 
-final class ClusterEventsSerializationTests: ClusterSystemXCTestCase {
+final class ClusterEventsSerializationTests: SingleClusterSystemXCTestCase {
     lazy var context: Serialization.Context! = Serialization.Context(
         log: system.log,
         system: system,
diff --git a/Tests/DistributedActorsTests/Cluster/Protobuf/Membership+SerializationTests.swift b/Tests/DistributedActorsTests/Cluster/Protobuf/Membership+SerializationTests.swift
@@ -19,7 +19,7 @@ import Logging
 import NIO
 import XCTest
 
-final class MembershipSerializationTests: ClusterSystemXCTestCase {
+final class MembershipSerializationTests: SingleClusterSystemXCTestCase {
     lazy var context: Serialization.Context! = Serialization.Context(
         log: system.log,
         system: system,
diff --git a/Tests/DistributedActorsTests/Cluster/ProtobufRoundTripTests.swift b/Tests/DistributedActorsTests/Cluster/ProtobufRoundTripTests.swift
@@ -19,7 +19,7 @@ import NIO
 import SwiftProtobuf
 import XCTest
 
-final class ProtobufRoundTripTests: ClusterSystemXCTestCase {
+final class ProtobufRoundTripTests: SingleClusterSystemXCTestCase {
     func check<Value: _ProtobufRepresentable & Equatable>(_ value: Value) throws {
         let context = Serialization.Context(log: self.system.log, system: self.system, allocator: self.system.serialization.allocator)
         let proto = try value.toProto(context: context)
diff --git a/Tests/DistributedActorsTests/Cluster/RemoteActorRefProviderTests.swift b/Tests/DistributedActorsTests/Cluster/RemoteActorRefProviderTests.swift
@@ -17,7 +17,7 @@ import DistributedActorsTestKit
 import Foundation
 import XCTest
 
-final class RemoteActorRefProviderTests: ClusterSystemXCTestCase {
+final class RemoteActorRefProviderTests: SingleClusterSystemXCTestCase {
     override func setUp() async throws {
         _ = await self.setUpNode(String(reflecting: Self.self)) { settings in
             settings.enabled = true
diff --git a/Tests/DistributedActorsTests/Cluster/SWIM/Protobuf/SWIM+SerializationTests.swift b/Tests/DistributedActorsTests/Cluster/SWIM/Protobuf/SWIM+SerializationTests.swift
@@ -17,7 +17,7 @@ import DistributedActorsTestKit
 import SWIM
 import XCTest
 
-final class SWIMSerializationTests: ClusterSystemXCTestCase {
+final class SWIMSerializationTests: SingleClusterSystemXCTestCase {
     func test_serializationOf_ack() async throws {
         let targetNode = await setUpNode("target") { settings in
             settings.enabled = true
diff --git a/Tests/DistributedActorsTests/Cluster/SystemMessagesRedeliveryTests.swift b/Tests/DistributedActorsTests/Cluster/SystemMessagesRedeliveryTests.swift
@@ -17,7 +17,7 @@ import DistributedActorsTestKit
 import Foundation
 import XCTest
 
-final class SystemMessagesRedeliveryTests: ClusterSystemXCTestCase {
+final class SystemMessagesRedeliveryTests: SingleClusterSystemXCTestCase {
     // ==== ------------------------------------------------------------------------------------------------------------
     // MARK: OutboundSystemMessageRedelivery
 
diff --git a/Tests/DistributedActorsTests/ClusterSystem+ActorTransportTests.swift b/Tests/DistributedActorsTests/ClusterSystem+ActorTransportTests.swift
@@ -17,7 +17,7 @@ import DistributedActorsTestKit
 import XCTest
 
 // FIXME: rename
-final class ActorSystemTransportTests: ClusterSystemXCTestCase, @unchecked Sendable {
+final class ActorSystemTransportTests: SingleClusterSystemXCTestCase, @unchecked Sendable {
     func test_system_shouldAssignIdentityAndReadyActor() async throws {
         try runAsyncAndBlock {
             let first = await setUpNode("first")
diff --git a/Tests/DistributedActorsTests/ClusterSystemTests.swift b/Tests/DistributedActorsTests/ClusterSystemTests.swift
@@ -17,7 +17,7 @@ import DistributedActorsTestKit
 import Foundation
 import XCTest
 
-final class ClusterSystemTests: ClusterSystemXCTestCase {
+final class ClusterSystemTests: SingleClusterSystemXCTestCase {
     let MaxSpecialTreatedValueTypeSizeInBytes = 24
 
     func test_system_spawn_shouldThrowOnDuplicateName() throws {
diff --git a/Tests/DistributedActorsTests/DeadLetterTests.swift b/Tests/DistributedActorsTests/DeadLetterTests.swift
@@ -18,7 +18,7 @@ import DistributedActorsTestKit
 @testable import Logging
 import XCTest
 
-final class DeadLetterTests: ClusterSystemXCTestCase {
+final class DeadLetterTests: SingleClusterSystemXCTestCase {
     // ==== ------------------------------------------------------------------------------------------------------------
     // MARK: DeadLetterOffice tests
 
diff --git a/Tests/DistributedActorsTests/DispatcherTests.swift b/Tests/DistributedActorsTests/DispatcherTests.swift
@@ -19,7 +19,7 @@ import Foundation
 import NIO
 import XCTest
 
-final class DispatcherTests: ClusterSystemXCTestCase {
+final class DispatcherTests: SingleClusterSystemXCTestCase {
     // ==== ------------------------------------------------------------------------------------------------------------
     // MARK: Running "on NIO" for fun and profit
 
diff --git a/Tests/DistributedActorsTests/DistributedReceptionistTests.swift b/Tests/DistributedActorsTests/DistributedReceptionistTests.swift
@@ -18,7 +18,7 @@ import DistributedActorsTestKit
 import Foundation
 import XCTest
 
-final class DistributedReceptionistTests: ClusterSystemXCTestCase {
+final class DistributedReceptionistTests: SingleClusterSystemXCTestCase {
     let receptionistBehavior = _OperationLogClusterReceptionist(settings: .default).behavior
 
     func test_receptionist_mustHaveWellKnownID() throws {
diff --git a/Tests/DistributedActorsTests/Gossip/GossiperShellTests.swift b/Tests/DistributedActorsTests/Gossip/GossiperShellTests.swift
@@ -18,7 +18,7 @@ import Foundation
 import NIOSSL
 import XCTest
 
-final class GossiperShellTests: ClusterSystemXCTestCase {
+final class GossiperShellTests: SingleClusterSystemXCTestCase {
     func peerBehavior<T: Codable>() -> _Behavior<GossipShell<T, String>.Message> {
         .receiveMessage { msg in
             if "\(msg)".contains("stop") { return .stop } else { return .same }
diff --git a/Tests/DistributedActorsTests/InterceptorTests.swift b/Tests/DistributedActorsTests/InterceptorTests.swift
@@ -56,7 +56,7 @@ final class TerminatedInterceptor<Message: Codable>: _Interceptor<Message> {
     }
 }
 
-final class InterceptorTests: ClusterSystemXCTestCase {
+final class InterceptorTests: SingleClusterSystemXCTestCase {
     func test_remoteCall_interceptor() async throws {
         let local = await setUpNode("local") { settings in
             settings.enabled = true
diff --git a/Tests/DistributedActorsTests/LifecycleWatchTests.swift b/Tests/DistributedActorsTests/LifecycleWatchTests.swift
@@ -83,7 +83,7 @@ distributed actor Juliet: LifecycleWatch, CustomStringConvertible {
 // ==== ----------------------------------------------------------------------------------------------------------------
 // MARK: Tests
 
-final class LifecycleWatchTests: ClusterSystemXCTestCase, @unchecked Sendable {
+final class LifecycleWatchTests: SingleClusterSystemXCTestCase, @unchecked Sendable {
     override func configureLogCapture(settings: inout LogCapture.Settings) {
         settings.excludeActorPaths = [
             "/system/cluster",
diff --git a/Tests/DistributedActorsTests/MailboxTests.swift b/Tests/DistributedActorsTests/MailboxTests.swift
@@ -17,7 +17,7 @@ import DistributedActorsTestKit
 import Foundation
 import XCTest
 
-final class MailboxTests: ClusterSystemXCTestCase {
+final class MailboxTests: SingleClusterSystemXCTestCase {
     func test_sendMessage_shouldDropMessagesWhenFull() {
         let mailbox: _Mailbox<Int> = _Mailbox(system: self.system, capacity: 2)
 
diff --git a/Tests/DistributedActorsTests/ParentChildActorTests.swift b/Tests/DistributedActorsTests/ParentChildActorTests.swift
@@ -17,7 +17,7 @@ import DistributedActorsTestKit
 import Foundation
 import XCTest
 
-final class ParentChildActorTests: ClusterSystemXCTestCase {
+final class ParentChildActorTests: SingleClusterSystemXCTestCase {
     typealias ParentRef = _ActorRef<ParentProtocol>
     enum ParentProtocol: _NotActuallyCodableMessage {
         case spawnChild(name: String, behavior: _Behavior<ChildProtocol>)
diff --git a/Tests/DistributedActorsTests/Pattern/WorkerPoolTests.swift b/Tests/DistributedActorsTests/Pattern/WorkerPoolTests.swift
@@ -19,7 +19,7 @@ import Foundation
 import XCTest
 
 // TODO: "ActorGroup" perhaps could be better name?
-final class WorkerPoolTests: ClusterSystemXCTestCase {
+final class WorkerPoolTests: SingleClusterSystemXCTestCase {
     func test_workerPool_registerNewlyStartedActors() async throws {
         let workerKey = DistributedReception.Key(Greeter.self, id: "request-workers")
 
diff --git a/Tests/DistributedActorsTests/Plugins/ClusterSingleton/ClusterSingletonPluginTests.swift b/Tests/DistributedActorsTests/Plugins/ClusterSingleton/ClusterSingletonPluginTests.swift
@@ -16,7 +16,7 @@
 import DistributedActorsTestKit
 import XCTest
 
-final class ClusterSingletonPluginTests: ClusterSystemXCTestCase {
+final class ClusterSingletonPluginTests: SingleClusterSystemXCTestCase {
     func test_singletonPlugin_clusterDisabled() async throws {
         // Singleton should work just fine without clustering
         let test = await setUpNode("test") { settings in
diff --git a/Tests/DistributedActorsTests/SerializationTests.swift b/Tests/DistributedActorsTests/SerializationTests.swift
@@ -20,7 +20,7 @@ import NIO
 import NIOFoundationCompat
 import XCTest
 
-class SerializationTests: ClusterSystemXCTestCase {
+class SerializationTests: SingleClusterSystemXCTestCase {
     override func setUp() async throws {
         _ = await self.setUpNode(String(describing: type(of: self))) { settings in
             settings.serialization.register(HasReceivesSystemMsgs.self)
diff --git a/Tests/DistributedActorsTests/StashBufferTests.swift b/Tests/DistributedActorsTests/StashBufferTests.swift
@@ -18,7 +18,7 @@ import XCTest
 
 @testable import DistributedActors
 
-final class _StashBufferTests: ClusterSystemXCTestCase {
+final class _StashBufferTests: SingleClusterSystemXCTestCase {
     func test_stash_shouldStashMessages() throws {
         let probe: ActorTestProbe<Int> = self.testKit.makeTestProbe()
 
diff --git a/Tests/DistributedActorsTests/SupervisionTests.swift b/Tests/DistributedActorsTests/SupervisionTests.swift
@@ -24,7 +24,7 @@ import Darwin
 import Glibc
 #endif
 
-final class SupervisionTests: ClusterSystemXCTestCase {
+final class SupervisionTests: SingleClusterSystemXCTestCase {
     enum FaultyError: Error, _NotActuallyCodableMessage {
         case boom(message: String)
     }
diff --git a/Tests/DistributedActorsTests/TimersTests.swift b/Tests/DistributedActorsTests/TimersTests.swift
@@ -18,7 +18,7 @@ import XCTest
 
 @testable import DistributedActors
 
-final class TimersTests: ClusterSystemXCTestCase {
+final class TimersTests: SingleClusterSystemXCTestCase {
     func testTimerKey_shouldPrintNicely() {
         _TimerKey("Hello").description.shouldEqual("_TimerKey(Hello)")
         _TimerKey("Hello", isSystemTimer: true).description.shouldEqual("_TimerKey(Hello, isSystemTimer: true)")
diff --git a/Tests/DistributedActorsTests/TraversalTests.swift b/Tests/DistributedActorsTests/TraversalTests.swift
@@ -20,7 +20,7 @@ import NIO
 import NIOFoundationCompat
 import XCTest
 
-final class TraversalTests: ClusterSystemXCTestCase {
+final class TraversalTests: SingleClusterSystemXCTestCase {
     struct ActorReady: Codable {
         let name: String
     }
diff --git a/Tests/DistributedActorsTests/_ActorRefReceptionistTests.swift b/Tests/DistributedActorsTests/_ActorRefReceptionistTests.swift
@@ -18,7 +18,7 @@ import DistributedActorsTestKit
 import Foundation
 import XCTest
 
-final class _ActorRefReceptionistTests: ClusterSystemXCTestCase {
+final class _ActorRefReceptionistTests: SingleClusterSystemXCTestCase {
     let receptionistBehavior = _OperationLogClusterReceptionist(settings: .default).behavior
 
     func test_receptionist_shouldRespondWithRegisteredRefsForKey() throws {
diff --git a/Tests/DistributedActorsTests/_DeathWatchTests.swift b/Tests/DistributedActorsTests/_DeathWatchTests.swift
@@ -17,7 +17,7 @@ import DistributedActorsTestKit
 import Foundation
 import XCTest
 
-final class DeathWatchTests: ClusterSystemXCTestCase {
+final class DeathWatchTests: SingleClusterSystemXCTestCase {
     // MARK: Termination watcher
 
     enum TerminationWatcherMessages {
diff --git a/docker/docker-compose.2004.57.yaml b/docker/docker-compose.2004.57.yaml
diff --git a/docker/docker-compose.custom.yaml b/docker/docker-compose.custom.yaml

Original file line number	Diff line number	Diff line change
`@@ -17,7 +17,7 @@ import DistributedActorsTestKit`
`17`	`17`	`import Foundation`
`18`	`18`	`import XCTest`
`19`	`19`
`20`		`-final class ActorAskTests: ClusterSystemXCTestCase {`
	`20`	`+final class ActorAskTests: SingleClusterSystemXCTestCase {`
`21`	`21`	`struct TestMessage: Codable {`
`22`	`22`	`let replyTo: _ActorRef<String>`
`23`	`23`	`}`