diff --git a/Tests/PostgresNIOTests/New/Connection State Machine/AuthenticationStateMachineTests.swift b/Tests/PostgresNIOTests/New/Connection State Machine/AuthenticationStateMachineTests.swift
index df881f90..99f7f5e9 100644
--- a/Tests/PostgresNIOTests/New/Connection State Machine/AuthenticationStateMachineTests.swift	
+++ b/Tests/PostgresNIOTests/New/Connection State Machine/AuthenticationStateMachineTests.swift	
@@ -1,82 +1,84 @@
-import XCTest
+import Testing
 import NIOCore
 @testable import PostgresNIO
 
-class AuthenticationStateMachineTests: XCTestCase {
-    
-    func testAuthenticatePlaintext() {
+@Suite struct AuthenticationStateMachineTests {
+
+    @Test func testAuthenticatePlaintext() {
         let authContext = AuthContext(username: "test", password: "abc123", database: "test")
 
         var state = ConnectionStateMachine(requireBackendKeyData: true)
-        XCTAssertEqual(state.connected(tls: .disable), .provideAuthenticationContext)
-        
-        XCTAssertEqual(state.provideAuthenticationContext(authContext), .sendStartupMessage(authContext))
-        XCTAssertEqual(state.authenticationMessageReceived(.plaintext), .sendPasswordMessage(.cleartext, authContext))
-        XCTAssertEqual(state.authenticationMessageReceived(.ok), .wait)
+        #expect(state.connected(tls: .disable) == .provideAuthenticationContext)
+
+        #expect(state.provideAuthenticationContext(authContext) == .sendStartupMessage(authContext))
+        #expect(state.authenticationMessageReceived(.plaintext) == .sendPasswordMessage(.cleartext, authContext))
+        #expect(state.authenticationMessageReceived(.ok) == .wait)
     }
     
-    func testAuthenticateMD5() {
+    @Test func testAuthenticateMD5() {
         let authContext = AuthContext(username: "test", password: "abc123", database: "test")
         var state = ConnectionStateMachine(requireBackendKeyData: true)
-        XCTAssertEqual(state.connected(tls: .disable), .provideAuthenticationContext)
+        #expect(state.connected(tls: .disable) == .provideAuthenticationContext)
         let salt: UInt32 = 0x00_01_02_03
 
-        XCTAssertEqual(state.provideAuthenticationContext(authContext), .sendStartupMessage(authContext))
-        XCTAssertEqual(state.authenticationMessageReceived(.md5(salt: salt)), .sendPasswordMessage(.md5(salt: salt), authContext))
-        XCTAssertEqual(state.authenticationMessageReceived(.ok), .wait)
+        #expect(state.provideAuthenticationContext(authContext) == .sendStartupMessage(authContext))
+        #expect(state.authenticationMessageReceived(.md5(salt: salt)) == .sendPasswordMessage(.md5(salt: salt), authContext))
+        #expect(state.authenticationMessageReceived(.ok) == .wait)
     }
     
-    func testAuthenticateMD5WithoutPassword() {
+    @Test func testAuthenticateMD5WithoutPassword() {
         let authContext = AuthContext(username: "test", password: nil, database: "test")
         var state = ConnectionStateMachine(requireBackendKeyData: true)
-        XCTAssertEqual(state.connected(tls: .disable), .provideAuthenticationContext)
+        #expect(state.connected(tls: .disable) == .provideAuthenticationContext)
         let salt: UInt32 = 0x00_01_02_03
 
-        XCTAssertEqual(state.provideAuthenticationContext(authContext), .sendStartupMessage(authContext))
-        XCTAssertEqual(state.authenticationMessageReceived(.md5(salt: salt)),
+        #expect(state.provideAuthenticationContext(authContext) == .sendStartupMessage(authContext))
+        #expect(state.authenticationMessageReceived(.md5(salt: salt)) ==
                        .closeConnectionAndCleanup(.init(action: .close, tasks: [], error: .authMechanismRequiresPassword, closePromise: nil)))
     }
     
-    func testAuthenticateOkAfterStartUpWithoutAuthChallenge() {
+    @Test func testAuthenticateOkAfterStartUpWithoutAuthChallenge() {
         let authContext = AuthContext(username: "test", password: "abc123", database: "test")
         var state = ConnectionStateMachine(requireBackendKeyData: true)
-        XCTAssertEqual(state.connected(tls: .disable), .provideAuthenticationContext)
-        XCTAssertEqual(state.provideAuthenticationContext(authContext), .sendStartupMessage(authContext))
-        XCTAssertEqual(state.authenticationMessageReceived(.ok), .wait)
+        #expect(state.connected(tls: .disable) == .provideAuthenticationContext)
+        #expect(state.provideAuthenticationContext(authContext) == .sendStartupMessage(authContext))
+        #expect(state.authenticationMessageReceived(.ok) == .wait)
     }
     
-    func testAuthenticateSCRAMSHA256WithAtypicalEncoding() {
+    @Test func testAuthenticateSCRAMSHA256WithAtypicalEncoding() {
         let authContext = AuthContext(username: "test", password: "abc123", database: "test")
         var state = ConnectionStateMachine(requireBackendKeyData: true)
-        XCTAssertEqual(state.connected(tls: .disable), .provideAuthenticationContext)
-        XCTAssertEqual(state.provideAuthenticationContext(authContext), .sendStartupMessage(authContext))
-        
+        #expect(state.connected(tls: .disable) == .provideAuthenticationContext)
+        #expect(state.provideAuthenticationContext(authContext) == .sendStartupMessage(authContext))
+
         let saslResponse = state.authenticationMessageReceived(.sasl(names: ["SCRAM-SHA-256"]))
         guard case .sendSaslInitialResponse(name: let name, initialResponse: let responseData) = saslResponse else {
-            return XCTFail("\(saslResponse) is not .sendSaslInitialResponse")
+            Issue.record("\(saslResponse) is not .sendSaslInitialResponse")
+            return
         }
         let responseString = String(decoding: responseData, as: UTF8.self)
-        XCTAssertEqual(name, "SCRAM-SHA-256")
-        XCTAssert(responseString.starts(with: "n,,n=test,r="))
-        
+        #expect(name == "SCRAM-SHA-256")
+        #expect(responseString.starts(with: "n,,n=test,r="))
+
         let saslContinueResponse = state.authenticationMessageReceived(.saslContinue(data: .init(bytes:
             "r=\(responseString.dropFirst(12))RUJSZHhkeUVFNzRLNERKMkxmU05ITU1NZWcxaQ==,s=ijgUVaWgCDLRJyF963BKNA==,i=4096".utf8
         )))
         guard case .sendSaslResponse(let responseData2) = saslContinueResponse else {
-            return XCTFail("\(saslContinueResponse) is not .sendSaslResponse")
+            Issue.record("\(saslContinueResponse) is not .sendSaslResponse")
+            return
         }
         let response2String = String(decoding: responseData2, as: UTF8.self)
-        XCTAssertEqual(response2String.prefix(76), "c=biws,r=\(responseString.dropFirst(12))RUJSZHhkeUVFNzRLNERKMkxmU05ITU1NZWcxaQ==,p=")
+        #expect(response2String.prefix(76) == "c=biws,r=\(responseString.dropFirst(12))RUJSZHhkeUVFNzRLNERKMkxmU05ITU1NZWcxaQ==,p=")
     }
     
-    func testAuthenticationFailure() {
+    @Test func testAuthenticationFailure() {
         let authContext = AuthContext(username: "test", password: "abc123", database: "test")
         var state = ConnectionStateMachine(requireBackendKeyData: true)
-        XCTAssertEqual(state.connected(tls: .disable), .provideAuthenticationContext)
+        #expect(state.connected(tls: .disable) == .provideAuthenticationContext)
         let salt: UInt32 = 0x00_01_02_03
 
-        XCTAssertEqual(state.provideAuthenticationContext(authContext), .sendStartupMessage(authContext))
-        XCTAssertEqual(state.authenticationMessageReceived(.md5(salt: salt)), .sendPasswordMessage(.md5(salt: salt), authContext))
+        #expect(state.provideAuthenticationContext(authContext) == .sendStartupMessage(authContext))
+        #expect(state.authenticationMessageReceived(.md5(salt: salt)) == .sendPasswordMessage(.md5(salt: salt), authContext))
         let fields: [PostgresBackendMessage.Field: String] = [
             .message: "password authentication failed for user \"postgres\"",
             .severity: "FATAL",
@@ -86,13 +88,13 @@ class AuthenticationStateMachineTests: XCTestCase {
             .line: "334",
             .file: "auth.c"
         ]
-        XCTAssertEqual(state.errorReceived(.init(fields: fields)),
+        #expect(state.errorReceived(.init(fields: fields)) ==
                        .closeConnectionAndCleanup(.init(action: .close, tasks: [], error: .server(.init(fields: fields)), closePromise: nil)))
     }
 
     // MARK: Test unsupported messages
     
-    func testUnsupportedAuthMechanism() {
+    @Test func testUnsupportedAuthMechanism() {
         let unsupported: [(PostgresBackendMessage.Authentication, PSQLError.UnsupportedAuthScheme)] = [
             (.kerberosV5, .kerberosV5),
             (.scmCredential, .scmCredential),
@@ -104,14 +106,14 @@ class AuthenticationStateMachineTests: XCTestCase {
         for (message, mechanism) in unsupported {
             let authContext = AuthContext(username: "test", password: "abc123", database: "test")
             var state = ConnectionStateMachine(requireBackendKeyData: true)
-            XCTAssertEqual(state.connected(tls: .disable), .provideAuthenticationContext)
-            XCTAssertEqual(state.provideAuthenticationContext(authContext), .sendStartupMessage(authContext))
-            XCTAssertEqual(state.authenticationMessageReceived(message),
+            #expect(state.connected(tls: .disable) == .provideAuthenticationContext)
+            #expect(state.provideAuthenticationContext(authContext) == .sendStartupMessage(authContext))
+            #expect(state.authenticationMessageReceived(message) ==
                            .closeConnectionAndCleanup(.init(action: .close, tasks: [], error: .unsupportedAuthMechanism(mechanism), closePromise: nil)))
         }
     }
     
-    func testUnexpectedMessagesAfterStartUp() {
+    @Test func testUnexpectedMessagesAfterStartUp() {
         var buffer = ByteBuffer()
         buffer.writeBytes([0, 1, 2, 3, 4, 5, 6, 7, 8])
         let unexpected: [PostgresBackendMessage.Authentication] = [
@@ -123,14 +125,14 @@ class AuthenticationStateMachineTests: XCTestCase {
         for message in unexpected {
             let authContext = AuthContext(username: "test", password: "abc123", database: "test")
             var state = ConnectionStateMachine(requireBackendKeyData: true)
-            XCTAssertEqual(state.connected(tls: .disable), .provideAuthenticationContext)
-            XCTAssertEqual(state.provideAuthenticationContext(authContext), .sendStartupMessage(authContext))
-            XCTAssertEqual(state.authenticationMessageReceived(message),
+            #expect(state.connected(tls: .disable) == .provideAuthenticationContext)
+            #expect(state.provideAuthenticationContext(authContext) == .sendStartupMessage(authContext))
+            #expect(state.authenticationMessageReceived(message) ==
                            .closeConnectionAndCleanup(.init(action: .close, tasks: [], error: .unexpectedBackendMessage(.authentication(message)), closePromise: nil)))
         }
     }
     
-    func testUnexpectedMessagesAfterPasswordSent() {
+    @Test func testUnexpectedMessagesAfterPasswordSent() {
         let salt: UInt32 = 0x00_01_02_03
         var buffer = ByteBuffer()
         buffer.writeBytes([0, 1, 2, 3, 4, 5, 6, 7, 8])
@@ -150,10 +152,10 @@ class AuthenticationStateMachineTests: XCTestCase {
         for message in unexpected {
             let authContext = AuthContext(username: "test", password: "abc123", database: "test")
             var state = ConnectionStateMachine(requireBackendKeyData: true)
-            XCTAssertEqual(state.connected(tls: .disable), .provideAuthenticationContext)
-            XCTAssertEqual(state.provideAuthenticationContext(authContext), .sendStartupMessage(authContext))
-            XCTAssertEqual(state.authenticationMessageReceived(.md5(salt: salt)), .sendPasswordMessage(.md5(salt: salt), authContext))
-            XCTAssertEqual(state.authenticationMessageReceived(message),
+            #expect(state.connected(tls: .disable) == .provideAuthenticationContext)
+            #expect(state.provideAuthenticationContext(authContext) == .sendStartupMessage(authContext))
+            #expect(state.authenticationMessageReceived(.md5(salt: salt)) == .sendPasswordMessage(.md5(salt: salt), authContext))
+            #expect(state.authenticationMessageReceived(message) ==
                            .closeConnectionAndCleanup(.init(action: .close, tasks: [], error: .unexpectedBackendMessage(.authentication(message)), closePromise: nil)))
         }
     }
diff --git a/Tests/PostgresNIOTests/New/Connection State Machine/ConnectionStateMachineTests.swift b/Tests/PostgresNIOTests/New/Connection State Machine/ConnectionStateMachineTests.swift
index f3d72a5e..445feb25 100644
--- a/Tests/PostgresNIOTests/New/Connection State Machine/ConnectionStateMachineTests.swift	
+++ b/Tests/PostgresNIOTests/New/Connection State Machine/ConnectionStateMachineTests.swift	
@@ -1,162 +1,159 @@
-import XCTest
+import Testing
 @testable import PostgresNIO
 @testable import NIOCore
 import NIOPosix
 import NIOSSL
 
-class ConnectionStateMachineTests: XCTestCase {
-    
-    func testStartup() {
+@Suite struct ConnectionStateMachineTests {
+
+    @Test func testStartup() {
         let authContext = AuthContext(username: "test", password: "abc123", database: "test")
         var state = ConnectionStateMachine(requireBackendKeyData: true)
-        XCTAssertEqual(state.connected(tls: .disable), .provideAuthenticationContext)
-        XCTAssertEqual(state.provideAuthenticationContext(authContext), .sendStartupMessage(authContext))
-        XCTAssertEqual(state.authenticationMessageReceived(.plaintext), .sendPasswordMessage(.cleartext, authContext))
-        XCTAssertEqual(state.authenticationMessageReceived(.ok), .wait)
+        #expect(state.connected(tls: .disable) == .provideAuthenticationContext)
+        #expect(state.provideAuthenticationContext(authContext) == .sendStartupMessage(authContext))
+        #expect(state.authenticationMessageReceived(.plaintext) == .sendPasswordMessage(.cleartext, authContext))
+        #expect(state.authenticationMessageReceived(.ok) == .wait)
     }
     
-    func testSSLStartupSuccess() {
+    @Test func testSSLStartupSuccess() {
         let authContext = AuthContext(username: "test", password: "abc123", database: "test")
         var state = ConnectionStateMachine(requireBackendKeyData: true)
-        XCTAssertEqual(state.connected(tls: .require), .sendSSLRequest)
-        XCTAssertEqual(state.sslSupportedReceived(unprocessedBytes: 0), .establishSSLConnection)
-        XCTAssertEqual(state.sslHandlerAdded(), .wait)
-        XCTAssertEqual(state.sslEstablished(), .provideAuthenticationContext)
-        XCTAssertEqual(state.provideAuthenticationContext(authContext), .sendStartupMessage(authContext))
+        #expect(state.connected(tls: .require) == .sendSSLRequest)
+        #expect(state.sslSupportedReceived(unprocessedBytes: 0) == .establishSSLConnection)
+        #expect(state.sslHandlerAdded() == .wait)
+        #expect(state.sslEstablished() == .provideAuthenticationContext)
+        #expect(state.provideAuthenticationContext(authContext) == .sendStartupMessage(authContext))
         let salt: UInt32 = 0x00_01_02_03
-        XCTAssertEqual(state.authenticationMessageReceived(.md5(salt: salt)), .sendPasswordMessage(.md5(salt: salt), authContext))
+        #expect(state.authenticationMessageReceived(.md5(salt: salt)) == .sendPasswordMessage(.md5(salt: salt), authContext))
     }
 
-    func testSSLStartupFailureTooManyBytesRemaining() {
+    @Test func testSSLStartupFailureTooManyBytesRemaining() {
         var state = ConnectionStateMachine(requireBackendKeyData: true)
-        XCTAssertEqual(state.connected(tls: .require), .sendSSLRequest)
+        #expect(state.connected(tls: .require) == .sendSSLRequest)
         let failError = PSQLError.receivedUnencryptedDataAfterSSLRequest
-        XCTAssertEqual(state.sslSupportedReceived(unprocessedBytes: 1), .closeConnectionAndCleanup(.init(action: .close, tasks: [], error: failError, closePromise: nil)))
+        #expect(state.sslSupportedReceived(unprocessedBytes: 1) == .closeConnectionAndCleanup(.init(action: .close, tasks: [], error: failError, closePromise: nil)))
     }
 
-    func testSSLStartupFailHandler() {
+    @Test func testSSLStartupFailHandler() {
         struct SSLHandlerAddError: Error, Equatable {}
         
         var state = ConnectionStateMachine(requireBackendKeyData: true)
-        XCTAssertEqual(state.connected(tls: .require), .sendSSLRequest)
-        XCTAssertEqual(state.sslSupportedReceived(unprocessedBytes: 0), .establishSSLConnection)
+        #expect(state.connected(tls: .require) == .sendSSLRequest)
+        #expect(state.sslSupportedReceived(unprocessedBytes: 0) == .establishSSLConnection)
         let failError = PSQLError.failedToAddSSLHandler(underlying: SSLHandlerAddError())
-        XCTAssertEqual(state.errorHappened(failError), .closeConnectionAndCleanup(.init(action: .close, tasks: [], error: failError, closePromise: nil)))
+        #expect(state.errorHappened(failError) == .closeConnectionAndCleanup(.init(action: .close, tasks: [], error: failError, closePromise: nil)))
     }
     
-    func testTLSRequiredStartupSSLUnsupported() {
+    @Test func testTLSRequiredStartupSSLUnsupported() {
         var state = ConnectionStateMachine(requireBackendKeyData: true)
         
-        XCTAssertEqual(state.connected(tls: .require), .sendSSLRequest)
-        XCTAssertEqual(state.sslUnsupportedReceived(),
+        #expect(state.connected(tls: .require) == .sendSSLRequest)
+        #expect(state.sslUnsupportedReceived() ==
                        .closeConnectionAndCleanup(.init(action: .close, tasks: [], error: PSQLError.sslUnsupported, closePromise: nil)))
     }
 
-    func testTLSPreferredStartupSSLUnsupported() {
+    @Test func testTLSPreferredStartupSSLUnsupported() {
         var state = ConnectionStateMachine(requireBackendKeyData: true)
 
-        XCTAssertEqual(state.connected(tls: .prefer), .sendSSLRequest)
-        XCTAssertEqual(state.sslUnsupportedReceived(), .provideAuthenticationContext)
+        #expect(state.connected(tls: .prefer) == .sendSSLRequest)
+        #expect(state.sslUnsupportedReceived() == .provideAuthenticationContext)
     }
         
-    func testParameterStatusReceivedAndBackendKeyAfterAuthenticated() {
+    @Test func testParameterStatusReceivedAndBackendKeyAfterAuthenticated() {
         var state = ConnectionStateMachine(.authenticated(nil, [:]))
         
-        XCTAssertEqual(state.parameterStatusReceived(.init(parameter: "DateStyle", value: "ISO, MDY")), .wait)
-        XCTAssertEqual(state.parameterStatusReceived(.init(parameter: "application_name", value: "")), .wait)
-        XCTAssertEqual(state.parameterStatusReceived(.init(parameter: "server_encoding", value: "UTF8")), .wait)
-        XCTAssertEqual(state.parameterStatusReceived(.init(parameter: "integer_datetimes", value: "on")), .wait)
-        XCTAssertEqual(state.parameterStatusReceived(.init(parameter: "client_encoding", value: "UTF8")), .wait)
-        XCTAssertEqual(state.parameterStatusReceived(.init(parameter: "TimeZone", value: "Etc/UTC")), .wait)
-        XCTAssertEqual(state.parameterStatusReceived(.init(parameter: "is_superuser", value: "on")), .wait)
-        XCTAssertEqual(state.parameterStatusReceived(.init(parameter: "server_version", value: "13.1 (Debian 13.1-1.pgdg100+1)")), .wait)
-        XCTAssertEqual(state.parameterStatusReceived(.init(parameter: "session_authorization", value: "postgres")), .wait)
-        XCTAssertEqual(state.parameterStatusReceived(.init(parameter: "IntervalStyle", value: "postgres")), .wait)
-        XCTAssertEqual(state.parameterStatusReceived(.init(parameter: "standard_conforming_strings", value: "on")), .wait)
-        
-        XCTAssertEqual(state.backendKeyDataReceived(.init(processID: 2730, secretKey: 882037977)), .wait)
-        XCTAssertEqual(state.readyForQueryReceived(.idle), .fireEventReadyForQuery)
+        #expect(state.parameterStatusReceived(.init(parameter: "DateStyle", value: "ISO, MDY")) == .wait)
+        #expect(state.parameterStatusReceived(.init(parameter: "application_name", value: "")) == .wait)
+        #expect(state.parameterStatusReceived(.init(parameter: "server_encoding", value: "UTF8")) == .wait)
+        #expect(state.parameterStatusReceived(.init(parameter: "integer_datetimes", value: "on")) == .wait)
+        #expect(state.parameterStatusReceived(.init(parameter: "client_encoding", value: "UTF8")) == .wait)
+        #expect(state.parameterStatusReceived(.init(parameter: "TimeZone", value: "Etc/UTC")) == .wait)
+        #expect(state.parameterStatusReceived(.init(parameter: "is_superuser", value: "on")) == .wait)
+        #expect(state.parameterStatusReceived(.init(parameter: "server_version", value: "13.1 (Debian 13.1-1.pgdg100+1)")) == .wait)
+        #expect(state.parameterStatusReceived(.init(parameter: "session_authorization", value: "postgres")) == .wait)
+        #expect(state.parameterStatusReceived(.init(parameter: "IntervalStyle", value: "postgres")) == .wait)
+        #expect(state.parameterStatusReceived(.init(parameter: "standard_conforming_strings", value: "on")) == .wait)
+
+        #expect(state.backendKeyDataReceived(.init(processID: 2730, secretKey: 882037977)) == .wait)
+        #expect(state.readyForQueryReceived(.idle) == .fireEventReadyForQuery)
     }
     
-    func testBackendKeyAndParameterStatusReceivedAfterAuthenticated() {
+    @Test func testBackendKeyAndParameterStatusReceivedAfterAuthenticated() {
         var state = ConnectionStateMachine(.authenticated(nil, [:]))
         
-        XCTAssertEqual(state.backendKeyDataReceived(.init(processID: 2730, secretKey: 882037977)), .wait)
-        
-        XCTAssertEqual(state.parameterStatusReceived(.init(parameter: "DateStyle", value: "ISO, MDY")), .wait)
-        XCTAssertEqual(state.parameterStatusReceived(.init(parameter: "application_name", value: "")), .wait)
-        XCTAssertEqual(state.parameterStatusReceived(.init(parameter: "server_encoding", value: "UTF8")), .wait)
-        XCTAssertEqual(state.parameterStatusReceived(.init(parameter: "integer_datetimes", value: "on")), .wait)
-        XCTAssertEqual(state.parameterStatusReceived(.init(parameter: "client_encoding", value: "UTF8")), .wait)
-        XCTAssertEqual(state.parameterStatusReceived(.init(parameter: "TimeZone", value: "Etc/UTC")), .wait)
-        XCTAssertEqual(state.parameterStatusReceived(.init(parameter: "is_superuser", value: "on")), .wait)
-        XCTAssertEqual(state.parameterStatusReceived(.init(parameter: "server_version", value: "13.1 (Debian 13.1-1.pgdg100+1)")), .wait)
-        XCTAssertEqual(state.parameterStatusReceived(.init(parameter: "session_authorization", value: "postgres")), .wait)
-        XCTAssertEqual(state.parameterStatusReceived(.init(parameter: "IntervalStyle", value: "postgres")), .wait)
-        XCTAssertEqual(state.parameterStatusReceived(.init(parameter: "standard_conforming_strings", value: "on")), .wait)
-        
-        XCTAssertEqual(state.readyForQueryReceived(.idle), .fireEventReadyForQuery)
+        #expect(state.backendKeyDataReceived(.init(processID: 2730, secretKey: 882037977)) == .wait)
+
+        #expect(state.parameterStatusReceived(.init(parameter: "DateStyle", value: "ISO, MDY")) == .wait)
+        #expect(state.parameterStatusReceived(.init(parameter: "application_name", value: "")) == .wait)
+        #expect(state.parameterStatusReceived(.init(parameter: "server_encoding", value: "UTF8")) == .wait)
+        #expect(state.parameterStatusReceived(.init(parameter: "integer_datetimes", value: "on")) == .wait)
+        #expect(state.parameterStatusReceived(.init(parameter: "client_encoding", value: "UTF8")) == .wait)
+        #expect(state.parameterStatusReceived(.init(parameter: "TimeZone", value: "Etc/UTC")) == .wait)
+        #expect(state.parameterStatusReceived(.init(parameter: "is_superuser", value: "on")) == .wait)
+        #expect(state.parameterStatusReceived(.init(parameter: "server_version", value: "13.1 (Debian 13.1-1.pgdg100+1)")) == .wait)
+        #expect(state.parameterStatusReceived(.init(parameter: "session_authorization", value: "postgres")) == .wait)
+        #expect(state.parameterStatusReceived(.init(parameter: "IntervalStyle", value: "postgres")) == .wait)
+        #expect(state.parameterStatusReceived(.init(parameter: "standard_conforming_strings", value: "on")) == .wait)
+
+        #expect(state.readyForQueryReceived(.idle) == .fireEventReadyForQuery)
     }
     
-    func testReadyForQueryReceivedWithoutBackendKeyAfterAuthenticated() {
+    @Test func testReadyForQueryReceivedWithoutBackendKeyAfterAuthenticated() {
         var state = ConnectionStateMachine(.authenticated(nil, [:]), requireBackendKeyData: true)
         
-        XCTAssertEqual(state.parameterStatusReceived(.init(parameter: "DateStyle", value: "ISO, MDY")), .wait)
-        XCTAssertEqual(state.parameterStatusReceived(.init(parameter: "application_name", value: "")), .wait)
-        XCTAssertEqual(state.parameterStatusReceived(.init(parameter: "server_encoding", value: "UTF8")), .wait)
-        XCTAssertEqual(state.parameterStatusReceived(.init(parameter: "integer_datetimes", value: "on")), .wait)
-        XCTAssertEqual(state.parameterStatusReceived(.init(parameter: "client_encoding", value: "UTF8")), .wait)
-        XCTAssertEqual(state.parameterStatusReceived(.init(parameter: "TimeZone", value: "Etc/UTC")), .wait)
-        XCTAssertEqual(state.parameterStatusReceived(.init(parameter: "is_superuser", value: "on")), .wait)
-        XCTAssertEqual(state.parameterStatusReceived(.init(parameter: "server_version", value: "13.1 (Debian 13.1-1.pgdg100+1)")), .wait)
-        XCTAssertEqual(state.parameterStatusReceived(.init(parameter: "session_authorization", value: "postgres")), .wait)
-        XCTAssertEqual(state.parameterStatusReceived(.init(parameter: "IntervalStyle", value: "postgres")), .wait)
-        XCTAssertEqual(state.parameterStatusReceived(.init(parameter: "standard_conforming_strings", value: "on")), .wait)
-        
-        XCTAssertEqual(state.readyForQueryReceived(.idle),
+        #expect(state.parameterStatusReceived(.init(parameter: "DateStyle", value: "ISO, MDY")) == .wait)
+        #expect(state.parameterStatusReceived(.init(parameter: "application_name", value: "")) == .wait)
+        #expect(state.parameterStatusReceived(.init(parameter: "server_encoding", value: "UTF8")) == .wait)
+        #expect(state.parameterStatusReceived(.init(parameter: "integer_datetimes", value: "on")) == .wait)
+        #expect(state.parameterStatusReceived(.init(parameter: "client_encoding", value: "UTF8")) == .wait)
+        #expect(state.parameterStatusReceived(.init(parameter: "TimeZone", value: "Etc/UTC")) == .wait)
+        #expect(state.parameterStatusReceived(.init(parameter: "is_superuser", value: "on")) == .wait)
+        #expect(state.parameterStatusReceived(.init(parameter: "server_version", value: "13.1 (Debian 13.1-1.pgdg100+1)")) == .wait)
+        #expect(state.parameterStatusReceived(.init(parameter: "session_authorization", value: "postgres")) == .wait)
+        #expect(state.parameterStatusReceived(.init(parameter: "IntervalStyle", value: "postgres")) == .wait)
+        #expect(state.parameterStatusReceived(.init(parameter: "standard_conforming_strings", value: "on")) == .wait)
+
+        #expect(state.readyForQueryReceived(.idle) ==
                        .closeConnectionAndCleanup(.init(action: .close, tasks: [], error: PSQLError.unexpectedBackendMessage(.readyForQuery(.idle)), closePromise: nil)))
     }
     
-    func testReadyForQueryReceivedWithoutUnneededBackendKeyAfterAuthenticated() {
+    @Test func testReadyForQueryReceivedWithoutUnneededBackendKeyAfterAuthenticated() {
         var state = ConnectionStateMachine(.authenticated(nil, [:]), requireBackendKeyData: false)
         
-        XCTAssertEqual(state.parameterStatusReceived(.init(parameter: "DateStyle", value: "ISO, MDY")), .wait)
-        XCTAssertEqual(state.parameterStatusReceived(.init(parameter: "application_name", value: "")), .wait)
-        XCTAssertEqual(state.parameterStatusReceived(.init(parameter: "server_encoding", value: "UTF8")), .wait)
-        XCTAssertEqual(state.parameterStatusReceived(.init(parameter: "integer_datetimes", value: "on")), .wait)
-        XCTAssertEqual(state.parameterStatusReceived(.init(parameter: "client_encoding", value: "UTF8")), .wait)
-        XCTAssertEqual(state.parameterStatusReceived(.init(parameter: "TimeZone", value: "Etc/UTC")), .wait)
-        XCTAssertEqual(state.parameterStatusReceived(.init(parameter: "is_superuser", value: "on")), .wait)
-        XCTAssertEqual(state.parameterStatusReceived(.init(parameter: "server_version", value: "13.1 (Debian 13.1-1.pgdg100+1)")), .wait)
-        XCTAssertEqual(state.parameterStatusReceived(.init(parameter: "session_authorization", value: "postgres")), .wait)
-        XCTAssertEqual(state.parameterStatusReceived(.init(parameter: "IntervalStyle", value: "postgres")), .wait)
-        XCTAssertEqual(state.parameterStatusReceived(.init(parameter: "standard_conforming_strings", value: "on")), .wait)
-        
-        XCTAssertEqual(state.readyForQueryReceived(.idle), .fireEventReadyForQuery)
+        #expect(state.parameterStatusReceived(.init(parameter: "DateStyle", value: "ISO, MDY")) == .wait)
+        #expect(state.parameterStatusReceived(.init(parameter: "application_name", value: "")) == .wait)
+        #expect(state.parameterStatusReceived(.init(parameter: "server_encoding", value: "UTF8")) == .wait)
+        #expect(state.parameterStatusReceived(.init(parameter: "integer_datetimes", value: "on")) == .wait)
+        #expect(state.parameterStatusReceived(.init(parameter: "client_encoding", value: "UTF8")) == .wait)
+        #expect(state.parameterStatusReceived(.init(parameter: "TimeZone", value: "Etc/UTC")) == .wait)
+        #expect(state.parameterStatusReceived(.init(parameter: "is_superuser", value: "on")) == .wait)
+        #expect(state.parameterStatusReceived(.init(parameter: "server_version", value: "13.1 (Debian 13.1-1.pgdg100+1)")) == .wait)
+        #expect(state.parameterStatusReceived(.init(parameter: "session_authorization", value: "postgres")) == .wait)
+        #expect(state.parameterStatusReceived(.init(parameter: "IntervalStyle", value: "postgres")) == .wait)
+        #expect(state.parameterStatusReceived(.init(parameter: "standard_conforming_strings", value: "on")) == .wait)
+
+        #expect(state.readyForQueryReceived(.idle) == .fireEventReadyForQuery)
     }
     
-    func testErrorIsIgnoredWhenClosingConnection() {
+    @Test func testErrorIsIgnoredWhenClosingConnection() {
         // test ignore unclean shutdown when closing connection
         var stateIgnoreChannelError = ConnectionStateMachine(.closing(nil))
 
-        XCTAssertEqual(stateIgnoreChannelError.errorHappened(.connectionError(underlying: NIOSSLError.uncleanShutdown)), .wait)
-        XCTAssertEqual(stateIgnoreChannelError.closed(), .fireChannelInactive)
-        
+        #expect(stateIgnoreChannelError.errorHappened(.connectionError(underlying: NIOSSLError.uncleanShutdown)) == .wait)
+        #expect(stateIgnoreChannelError.closed() == .fireChannelInactive)
+
         // test ignore any other error when closing connection
         
         var stateIgnoreErrorMessage = ConnectionStateMachine(.closing(nil))
-        XCTAssertEqual(stateIgnoreErrorMessage.errorReceived(.init(fields: [:])), .wait)
-        XCTAssertEqual(stateIgnoreErrorMessage.closed(), .fireChannelInactive)
+        #expect(stateIgnoreErrorMessage.errorReceived(.init(fields: [:])) == .wait)
+        #expect(stateIgnoreErrorMessage.closed() == .fireChannelInactive)
     }
     
-    func testFailQueuedQueriesOnAuthenticationFailure() throws {
-        let eventLoopGroup = MultiThreadedEventLoopGroup(numberOfThreads: 1)
-        defer { XCTAssertNoThrow(try eventLoopGroup.syncShutdownGracefully()) }
-
+    @Test func testFailQueuedQueriesOnAuthenticationFailure() throws {
         let authContext = AuthContext(username: "test", password: "abc123", database: "test")
         let salt: UInt32 = 0x00_01_02_03
 
-        let queryPromise = eventLoopGroup.next().makePromise(of: PSQLRowStream.self)
+        let queryPromise = NIOSingletons.posixEventLoopGroup.next().makePromise(of: PSQLRowStream.self)
 
         var state = ConnectionStateMachine(requireBackendKeyData: true)
         let extendedQueryContext = ExtendedQueryContext(
@@ -164,10 +161,10 @@ class ConnectionStateMachineTests: XCTestCase {
             logger: .psqlTest,
             promise: queryPromise)
 
-        XCTAssertEqual(state.enqueue(task: .extendedQuery(extendedQueryContext)), .wait)
-        XCTAssertEqual(state.connected(tls: .disable), .provideAuthenticationContext)
-        XCTAssertEqual(state.provideAuthenticationContext(authContext), .sendStartupMessage(authContext))
-        XCTAssertEqual(state.authenticationMessageReceived(.md5(salt: salt)), .sendPasswordMessage(.md5(salt: salt), authContext))
+        #expect(state.enqueue(task: .extendedQuery(extendedQueryContext)) == .wait)
+        #expect(state.connected(tls: .disable) == .provideAuthenticationContext)
+        #expect(state.provideAuthenticationContext(authContext) == .sendStartupMessage(authContext))
+        #expect(state.authenticationMessageReceived(.md5(salt: salt)) == .sendPasswordMessage(.md5(salt: salt), authContext))
         let fields: [PostgresBackendMessage.Field: String] = [
             .message: "password authentication failed for user \"postgres\"",
             .severity: "FATAL",
@@ -177,10 +174,10 @@ class ConnectionStateMachineTests: XCTestCase {
             .line: "334",
             .file: "auth.c"
         ]
-        XCTAssertEqual(state.errorReceived(.init(fields: fields)),
+        #expect(state.errorReceived(.init(fields: fields)) ==
                        .closeConnectionAndCleanup(.init(action: .close, tasks: [.extendedQuery(extendedQueryContext)], error: .server(.init(fields: fields)), closePromise: nil)))
         
-        XCTAssertNil(queryPromise.futureResult._value)
+        #expect(queryPromise.futureResult._value == nil)
 
         // make sure we don't crash
         queryPromise.fail(PSQLError.server(.init(fields: fields)))
diff --git a/Tests/PostgresNIOTests/New/Data/Array+PSQLCodableTests.swift b/Tests/PostgresNIOTests/New/Data/Array+PSQLCodableTests.swift
index bfffef52..1602cee0 100644
--- a/Tests/PostgresNIOTests/New/Data/Array+PSQLCodableTests.swift
+++ b/Tests/PostgresNIOTests/New/Data/Array+PSQLCodableTests.swift
@@ -1,137 +1,141 @@
-import XCTest
+import Foundation
+import Testing
 import NIOCore
 @testable import PostgresNIO
 
-class Array_PSQLCodableTests: XCTestCase {
+@Suite struct Array_PSQLCodableTests {
 
-    func testArrayTypes() {
+    @Test func testArrayTypes() {
+        #expect(Bool.psqlArrayType == .boolArray)
+        #expect(Bool.psqlType == .bool)
+        #expect([Bool].psqlType == .boolArray)
 
-        XCTAssertEqual(Bool.psqlArrayType, .boolArray)
-        XCTAssertEqual(Bool.psqlType, .bool)
-        XCTAssertEqual([Bool].psqlType, .boolArray)
+        #expect(ByteBuffer.psqlArrayType == .byteaArray)
+        #expect(ByteBuffer.psqlType == .bytea)
+        #expect([ByteBuffer].psqlType == .byteaArray)
 
-        XCTAssertEqual(ByteBuffer.psqlArrayType, .byteaArray)
-        XCTAssertEqual(ByteBuffer.psqlType, .bytea)
-        XCTAssertEqual([ByteBuffer].psqlType, .byteaArray)
+        #expect(UInt8.psqlArrayType == .charArray)
+        #expect(UInt8.psqlType == .char)
+        #expect([UInt8].psqlType == .charArray)
 
-        XCTAssertEqual(UInt8.psqlArrayType, .charArray)
-        XCTAssertEqual(UInt8.psqlType, .char)
-        XCTAssertEqual([UInt8].psqlType, .charArray)
+        #expect(Int16.psqlArrayType == .int2Array)
+        #expect(Int16.psqlType == .int2)
+        #expect([Int16].psqlType == .int2Array)
 
-        XCTAssertEqual(Int16.psqlArrayType, .int2Array)
-        XCTAssertEqual(Int16.psqlType, .int2)
-        XCTAssertEqual([Int16].psqlType, .int2Array)
+        #expect(Int32.psqlArrayType == .int4Array)
+        #expect(Int32.psqlType == .int4)
+        #expect([Int32].psqlType == .int4Array)
 
-        XCTAssertEqual(Int32.psqlArrayType, .int4Array)
-        XCTAssertEqual(Int32.psqlType, .int4)
-        XCTAssertEqual([Int32].psqlType, .int4Array)
-
-        XCTAssertEqual(Int64.psqlArrayType, .int8Array)
-        XCTAssertEqual(Int64.psqlType, .int8)
-        XCTAssertEqual([Int64].psqlType, .int8Array)
+        #expect(Int64.psqlArrayType == .int8Array)
+        #expect(Int64.psqlType == .int8)
+        #expect([Int64].psqlType == .int8Array)
 
         #if (arch(i386) || arch(arm))
-        XCTAssertEqual(Int.psqlArrayType, .int4Array)
-        XCTAssertEqual(Int.psqlType, .int4)
-        XCTAssertEqual([Int].psqlType, .int4Array)
+        #expect(Int.psqlArrayType == .int4Array)
+        #expect(Int.psqlType == .int4)
+        #expect([Int].psqlType == .int4Array)
         #else
-        XCTAssertEqual(Int.psqlArrayType, .int8Array)
-        XCTAssertEqual(Int.psqlType, .int8)
-        XCTAssertEqual([Int].psqlType, .int8Array)
+        #expect(Int.psqlArrayType == .int8Array)
+        #expect(Int.psqlType == .int8)
+        #expect([Int].psqlType == .int8Array)
         #endif
 
-        XCTAssertEqual(Float.psqlArrayType, .float4Array)
-        XCTAssertEqual(Float.psqlType, .float4)
-        XCTAssertEqual([Float].psqlType, .float4Array)
+        #expect(Float.psqlArrayType == .float4Array)
+        #expect(Float.psqlType == .float4)
+        #expect([Float].psqlType == .float4Array)
 
-        XCTAssertEqual(Double.psqlArrayType, .float8Array)
-        XCTAssertEqual(Double.psqlType, .float8)
-        XCTAssertEqual([Double].psqlType, .float8Array)
+        #expect(Double.psqlArrayType == .float8Array)
+        #expect(Double.psqlType == .float8)
+        #expect([Double].psqlType == .float8Array)
 
-        XCTAssertEqual(String.psqlArrayType, .textArray)
-        XCTAssertEqual(String.psqlType, .text)
-        XCTAssertEqual([String].psqlType, .textArray)
+        #expect(String.psqlArrayType == .textArray)
+        #expect(String.psqlType == .text)
+        #expect([String].psqlType == .textArray)
 
-        XCTAssertEqual(UUID.psqlArrayType, .uuidArray)
-        XCTAssertEqual(UUID.psqlType, .uuid)
-        XCTAssertEqual([UUID].psqlType, .uuidArray)
+        #expect(UUID.psqlArrayType == .uuidArray)
+        #expect(UUID.psqlType == .uuid)
+        #expect([UUID].psqlType == .uuidArray)
 
-        XCTAssertEqual(Date.psqlArrayType, .timestamptzArray)
-        XCTAssertEqual(Date.psqlType, .timestamptz)
-        XCTAssertEqual([Date].psqlType, .timestamptzArray)
+        #expect(Date.psqlArrayType == .timestamptzArray)
+        #expect(Date.psqlType == .timestamptz)
+        #expect([Date].psqlType == .timestamptzArray)
 
-        XCTAssertEqual(Range<Int32>.psqlArrayType, .int4RangeArray)
-        XCTAssertEqual(Range<Int32>.psqlType, .int4Range)
-        XCTAssertEqual([Range<Int32>].psqlType, .int4RangeArray)
+        #expect(Range<Int32>.psqlArrayType == .int4RangeArray)
+        #expect(Range<Int32>.psqlType == .int4Range)
+        #expect([Range<Int32>].psqlType == .int4RangeArray)
 
-        XCTAssertEqual(ClosedRange<Int32>.psqlArrayType, .int4RangeArray)
-        XCTAssertEqual(ClosedRange<Int32>.psqlType, .int4Range)
-        XCTAssertEqual([ClosedRange<Int32>].psqlType, .int4RangeArray)
+        #expect(ClosedRange<Int32>.psqlArrayType == .int4RangeArray)
+        #expect(ClosedRange<Int32>.psqlType == .int4Range)
+        #expect([ClosedRange<Int32>].psqlType == .int4RangeArray)
 
-        XCTAssertEqual(Range<Int64>.psqlArrayType, .int8RangeArray)
-        XCTAssertEqual(Range<Int64>.psqlType, .int8Range)
-        XCTAssertEqual([Range<Int64>].psqlType, .int8RangeArray)
+        #expect(Range<Int64>.psqlArrayType == .int8RangeArray)
+        #expect(Range<Int64>.psqlType == .int8Range)
+        #expect([Range<Int64>].psqlType == .int8RangeArray)
 
-        XCTAssertEqual(ClosedRange<Int64>.psqlArrayType, .int8RangeArray)
-        XCTAssertEqual(ClosedRange<Int64>.psqlType, .int8Range)
-        XCTAssertEqual([ClosedRange<Int64>].psqlType, .int8RangeArray)
+        #expect(ClosedRange<Int64>.psqlArrayType == .int8RangeArray)
+        #expect(ClosedRange<Int64>.psqlType == .int8Range)
+        #expect([ClosedRange<Int64>].psqlType == .int8RangeArray)
     }
 
-    func testStringArrayRoundTrip() {
+    @Test func testStringArrayRoundTrip() {
         let values = ["foo", "bar", "hello", "world"]
 
         var buffer = ByteBuffer()
         values.encode(into: &buffer, context: .default)
 
         var result: [String]?
-        XCTAssertNoThrow(result = try [String](from: &buffer, type: .textArray, format: .binary, context: .default))
-        XCTAssertEqual(values, result)
+        #expect(throws: Never.self) {
+            result = try [String](from: &buffer, type: .textArray, format: .binary, context: .default)
+        }
+        #expect(values == result)
     }
 
-    func testEmptyStringArrayRoundTrip() {
+    @Test func testEmptyStringArrayRoundTrip() {
         let values: [String] = []
 
         var buffer = ByteBuffer()
         values.encode(into: &buffer, context: .default)
 
         var result: [String]?
-        XCTAssertNoThrow(result = try [String](from: &buffer, type: .textArray, format: .binary, context: .default))
-        XCTAssertEqual(values, result)
+        #expect(throws: Never.self) {
+            result = try [String](from: &buffer, type: .textArray, format: .binary, context: .default)
+        }
+        #expect(values == result)
     }
 
-    func testDecodeFailureIsNotEmptyOutOfScope() {
+    @Test func testDecodeFailureIsNotEmptyOutOfScope() {
         var buffer = ByteBuffer()
         buffer.writeInteger(Int32(2)) // invalid value
         buffer.writeInteger(Int32(0))
         buffer.writeInteger(String.psqlType.rawValue)
 
-        XCTAssertThrowsError(try [String](from: &buffer, type: .textArray, format: .binary, context: .default)) {
-            XCTAssertEqual($0 as? PostgresDecodingError.Code, .failure)
+        #expect(throws: PostgresDecodingError.Code.failure) {
+            try [String](from: &buffer, type: .textArray, format: .binary, context: .default)
         }
     }
 
-    func testDecodeFailureSecondValueIsUnexpected() {
+    @Test func testDecodeFailureSecondValueIsUnexpected() {
         var buffer = ByteBuffer()
         buffer.writeInteger(Int32(0)) // is empty
         buffer.writeInteger(Int32(1)) // invalid value, must always be 0
         buffer.writeInteger(String.psqlType.rawValue)
 
-        XCTAssertThrowsError(try [String](from: &buffer, type: .textArray, format: .binary, context: .default)) {
-            XCTAssertEqual($0 as? PostgresDecodingError.Code, .failure)
+        #expect(throws: PostgresDecodingError.Code.failure) {
+            try [String](from: &buffer, type: .textArray, format: .binary, context: .default)
         }
     }
 
-    func testDecodeFailureTriesDecodeInt8() {
+    @Test func testDecodeFailureTriesDecodeInt8() {
         let value: Int64 = 1 << 32
         var buffer = ByteBuffer()
         value.encode(into: &buffer, context: .default)
 
-        XCTAssertThrowsError(try [String](from: &buffer, type: .textArray, format: .binary, context: .default)) {
-            XCTAssertEqual($0 as? PostgresDecodingError.Code, .failure)
+        #expect(throws: PostgresDecodingError.Code.failure) {
+            try [String](from: &buffer, type: .textArray, format: .binary, context: .default)
         }
     }
 
-    func testDecodeFailureInvalidNumberOfArrayElements() {
+    @Test func testDecodeFailureInvalidNumberOfArrayElements() {
         var buffer = ByteBuffer()
         buffer.writeInteger(Int32(1)) // invalid value
         buffer.writeInteger(Int32(0))
@@ -139,12 +143,12 @@ class Array_PSQLCodableTests: XCTestCase {
         buffer.writeInteger(Int32(-123)) // expected element count
         buffer.writeInteger(Int32(1)) // dimensions... must be one
 
-        XCTAssertThrowsError(try [String](from: &buffer, type: .textArray, format: .binary, context: .default)) {
-            XCTAssertEqual($0 as? PostgresDecodingError.Code, .failure)
+        #expect(throws: PostgresDecodingError.Code.failure) {
+            try [String](from: &buffer, type: .textArray, format: .binary, context: .default)
         }
     }
 
-    func testDecodeFailureInvalidNumberOfDimensions() {
+    @Test func testDecodeFailureInvalidNumberOfDimensions() {
         var buffer = ByteBuffer()
         buffer.writeInteger(Int32(1)) // invalid value
         buffer.writeInteger(Int32(0))
@@ -152,12 +156,12 @@ class Array_PSQLCodableTests: XCTestCase {
         buffer.writeInteger(Int32(1)) // expected element count
         buffer.writeInteger(Int32(2)) // dimensions... must be one
 
-        XCTAssertThrowsError(try [String](from: &buffer, type: .textArray, format: .binary, context: .default)) {
-            XCTAssertEqual($0 as? PostgresDecodingError.Code, .failure)
+        #expect(throws: PostgresDecodingError.Code.failure) {
+            try [String](from: &buffer, type: .textArray, format: .binary, context: .default)
         }
     }
 
-    func testDecodeUnexpectedEnd() {
+    @Test func testDecodeUnexpectedEnd() {
         var unexpectedEndInElementLengthBuffer = ByteBuffer()
         unexpectedEndInElementLengthBuffer.writeInteger(Int32(1)) // invalid value
         unexpectedEndInElementLengthBuffer.writeInteger(Int32(0))
@@ -166,8 +170,8 @@ class Array_PSQLCodableTests: XCTestCase {
         unexpectedEndInElementLengthBuffer.writeInteger(Int32(1)) // dimensions
         unexpectedEndInElementLengthBuffer.writeInteger(Int16(1)) // length of element, must be Int32
 
-        XCTAssertThrowsError(try [String](from: &unexpectedEndInElementLengthBuffer, type: .textArray, format: .binary, context: .default)) {
-            XCTAssertEqual($0 as? PostgresDecodingError.Code, .failure)
+        #expect(throws: PostgresDecodingError.Code.failure) {
+            try [String](from: &unexpectedEndInElementLengthBuffer, type: .textArray, format: .binary, context: .default)
         }
 
         var unexpectedEndInElementBuffer = ByteBuffer()
@@ -179,8 +183,8 @@ class Array_PSQLCodableTests: XCTestCase {
         unexpectedEndInElementBuffer.writeInteger(Int32(12)) // length of element, must be Int32
         unexpectedEndInElementBuffer.writeString("Hello World") // only 11 bytes, 12 needed!
 
-        XCTAssertThrowsError(try [String](from: &unexpectedEndInElementBuffer, type: .textArray, format: .binary, context: .default)) {
-            XCTAssertEqual($0 as? PostgresDecodingError.Code, .failure)
+        #expect(throws: PostgresDecodingError.Code.failure) {
+            try [String](from: &unexpectedEndInElementBuffer, type: .textArray, format: .binary, context: .default)
         }
     }
 }
diff --git a/Tests/PostgresNIOTests/New/Data/Bool+PSQLCodableTests.swift b/Tests/PostgresNIOTests/New/Data/Bool+PSQLCodableTests.swift
index e6e43f0b..d23eff08 100644
--- a/Tests/PostgresNIOTests/New/Data/Bool+PSQLCodableTests.swift
+++ b/Tests/PostgresNIOTests/New/Data/Bool+PSQLCodableTests.swift
@@ -1,89 +1,97 @@
-import XCTest
+import Testing
 import NIOCore
 @testable import PostgresNIO
 
-class Bool_PSQLCodableTests: XCTestCase {
+@Suite struct Bool_PSQLCodableTests {
 
     // MARK: - Binary
 
-    func testBinaryTrueRoundTrip() {
+    @Test func testBinaryTrueRoundTrip() {
         let value = true
 
         var buffer = ByteBuffer()
         value.encode(into: &buffer, context: .default)
-        XCTAssertEqual(Bool.psqlType, .bool)
-        XCTAssertEqual(Bool.psqlFormat, .binary)
-        XCTAssertEqual(buffer.readableBytes, 1)
-        XCTAssertEqual(buffer.getInteger(at: buffer.readerIndex, as: UInt8.self), 1)
+        #expect(Bool.psqlType == .bool)
+        #expect(Bool.psqlFormat == .binary)
+        #expect(buffer.readableBytes == 1)
+        #expect(buffer.getInteger(at: buffer.readerIndex, as: UInt8.self) == 1)
 
         var result: Bool?
-        XCTAssertNoThrow(result = try Bool(from: &buffer, type: .bool, format: .binary, context: .default))
-        XCTAssertEqual(value, result)
+        #expect(throws: Never.self) {
+            result = try Bool(from: &buffer, type: .bool, format: .binary, context: .default)
+        }
+        #expect(value == result)
     }
 
-    func testBinaryFalseRoundTrip() {
+    @Test func testBinaryFalseRoundTrip() {
         let value = false
 
         var buffer = ByteBuffer()
         value.encode(into: &buffer, context: .default)
-        XCTAssertEqual(Bool.psqlType, .bool)
-        XCTAssertEqual(Bool.psqlFormat, .binary)
-        XCTAssertEqual(buffer.readableBytes, 1)
-        XCTAssertEqual(buffer.getInteger(at: buffer.readerIndex, as: UInt8.self), 0)
+        #expect(Bool.psqlType == .bool)
+        #expect(Bool.psqlFormat == .binary)
+        #expect(buffer.readableBytes == 1)
+        #expect(buffer.getInteger(at: buffer.readerIndex, as: UInt8.self) == 0)
 
         var result: Bool?
-        XCTAssertNoThrow(result = try Bool(from: &buffer, type: .bool, format: .binary, context: .default))
-        XCTAssertEqual(value, result)
+        #expect(throws: Never.self) {
+            result = try Bool(from: &buffer, type: .bool, format: .binary, context: .default)
+        }
+        #expect(value == result)
     }
 
-    func testBinaryDecodeBoolInvalidLength() {
+    @Test func testBinaryDecodeBoolInvalidLength() {
         var buffer = ByteBuffer()
         buffer.writeInteger(Int64(1))
 
-        XCTAssertThrowsError(try Bool(from: &buffer, type: .bool, format: .binary, context: .default)) {
-            XCTAssertEqual($0 as? PostgresDecodingError.Code, .failure)
+        #expect(throws: PostgresDecodingError.Code.failure) {
+            try Bool(from: &buffer, type: .bool, format: .binary, context: .default)
         }
     }
 
-    func testBinaryDecodeBoolInvalidValue() {
+    @Test func testBinaryDecodeBoolInvalidValue() {
         var buffer = ByteBuffer()
         buffer.writeInteger(UInt8(13))
 
-        XCTAssertThrowsError(try Bool(from: &buffer, type: .bool, format: .binary, context: .default)) {
-            XCTAssertEqual($0 as? PostgresDecodingError.Code, .failure)
+        #expect(throws: PostgresDecodingError.Code.failure) {
+            try Bool(from: &buffer, type: .bool, format: .binary, context: .default)
         }
     }
 
     // MARK: - Text
 
-    func testTextTrueDecode() {
+    @Test func testTextTrueDecode() {
         let value = true
 
         var buffer = ByteBuffer()
         buffer.writeInteger(UInt8(ascii: "t"))
 
         var result: Bool?
-        XCTAssertNoThrow(result = try Bool(from: &buffer, type: .bool, format: .text, context: .default))
-        XCTAssertEqual(value, result)
+        #expect(throws: Never.self) {
+            result = try Bool(from: &buffer, type: .bool, format: .text, context: .default)
+        }
+        #expect(value == result)
     }
 
-    func testTextFalseDecode() {
+    @Test func testTextFalseDecode() {
         let value = false
 
         var buffer = ByteBuffer()
         buffer.writeInteger(UInt8(ascii: "f"))
 
         var result: Bool?
-        XCTAssertNoThrow(result = try Bool(from: &buffer, type: .bool, format: .text, context: .default))
-        XCTAssertEqual(value, result)
+        #expect(throws: Never.self) {
+            result = try Bool(from: &buffer, type: .bool, format: .text, context: .default)
+        }
+        #expect(value == result)
     }
 
-    func testTextDecodeBoolInvalidValue() {
+    @Test func testTextDecodeBoolInvalidValue() {
         var buffer = ByteBuffer()
         buffer.writeInteger(UInt8(13))
 
-        XCTAssertThrowsError(try Bool(from: &buffer, type: .bool, format: .text, context: .default)) {
-            XCTAssertEqual($0 as? PostgresDecodingError.Code, .failure)
+        #expect(throws: PostgresDecodingError.Code.failure) {
+            try Bool(from: &buffer, type: .bool, format: .text, context: .default)
         }
     }
 }
diff --git a/Tests/PostgresNIOTests/New/Data/Bytes+PSQLCodableTests.swift b/Tests/PostgresNIOTests/New/Data/Bytes+PSQLCodableTests.swift
index 9230aee7..77051775 100644
--- a/Tests/PostgresNIOTests/New/Data/Bytes+PSQLCodableTests.swift
+++ b/Tests/PostgresNIOTests/New/Data/Bytes+PSQLCodableTests.swift
@@ -1,34 +1,35 @@
-import XCTest
+import struct Foundation.Data
+import Testing
 import NIOCore
 @testable import PostgresNIO
 
-class Bytes_PSQLCodableTests: XCTestCase {
-    
-    func testDataRoundTrip() {
+@Suite struct Bytes_PSQLCodableTests {
+
+    @Test func testDataRoundTrip() {
         let data = Data((0...UInt8.max))
         
         var buffer = ByteBuffer()
         data.encode(into: &buffer, context: .default)
-        XCTAssertEqual(ByteBuffer.psqlType, .bytea)
-        
+        #expect(ByteBuffer.psqlType == .bytea)
+
         var result: Data?
         result = Data(from: &buffer, type: .bytea, format: .binary, context: .default)
-        XCTAssertEqual(data, result)
+        #expect(data == result)
     }
     
-    func testByteBufferRoundTrip() {
+    @Test func testByteBufferRoundTrip() {
         let bytes = ByteBuffer(bytes: (0...UInt8.max))
         
         var buffer = ByteBuffer()
         bytes.encode(into: &buffer, context: .default)
-        XCTAssertEqual(ByteBuffer.psqlType, .bytea)
-        
+        #expect(ByteBuffer.psqlType == .bytea)
+
         var result: ByteBuffer?
         result = ByteBuffer(from: &buffer, type: .bytea, format: .binary, context: .default)
-        XCTAssertEqual(bytes, result)
+        #expect(bytes == result)
     }
     
-    func testEncodeSequenceWhereElementUInt8() {
+    @Test func testEncodeSequenceWhereElementUInt8() {
         struct ByteSequence: Sequence, PostgresEncodable {
             typealias Element = UInt8
             typealias Iterator = Array<UInt8>.Iterator
@@ -47,7 +48,7 @@ class Bytes_PSQLCodableTests: XCTestCase {
         let sequence = ByteSequence()
         var buffer = ByteBuffer()
         sequence.encode(into: &buffer, context: .default)
-        XCTAssertEqual(ByteSequence.psqlType, .bytea)
-        XCTAssertEqual(buffer.readableBytes, 256)
+        #expect(ByteSequence.psqlType == .bytea)
+        #expect(buffer.readableBytes == 256)
     }
 }
diff --git a/Tests/PostgresNIOTests/New/Messages/AuthenticationTests.swift b/Tests/PostgresNIOTests/New/Messages/AuthenticationTests.swift
index 06e39aae..3b857157 100644
--- a/Tests/PostgresNIOTests/New/Messages/AuthenticationTests.swift
+++ b/Tests/PostgresNIOTests/New/Messages/AuthenticationTests.swift
@@ -1,10 +1,10 @@
-import XCTest
+import Testing
 import NIOCore
 import NIOTestUtils
 @testable import PostgresNIO
 
-class AuthenticationTests: XCTestCase {
-    
+@Suite struct AuthenticationTests {
+
     func testDecodeAuthentication() {
         var expected = [PostgresBackendMessage]()
         var buffer = ByteBuffer()
@@ -39,9 +39,11 @@ class AuthenticationTests: XCTestCase {
         encoder.encode(data: .authentication(.sspi), out: &buffer)
         expected.append(.authentication(.sspi))
         
-        XCTAssertNoThrow(try ByteToMessageDecoderVerifier.verifyDecoder(
-            inputOutputPairs: [(buffer, expected)],
-            decoderFactory: { PostgresBackendMessageDecoder(hasAlreadyReceivedBytes: false) }
-        ))
+        #expect(throws: Never.self) {
+            try ByteToMessageDecoderVerifier.verifyDecoder(
+                inputOutputPairs: [(buffer, expected)],
+                decoderFactory: { PostgresBackendMessageDecoder(hasAlreadyReceivedBytes: false) }
+            )
+        }
     }
 }
diff --git a/Tests/PostgresNIOTests/New/Messages/BackendKeyDataTests.swift b/Tests/PostgresNIOTests/New/Messages/BackendKeyDataTests.swift
index d41607e3..204b544d 100644
--- a/Tests/PostgresNIOTests/New/Messages/BackendKeyDataTests.swift
+++ b/Tests/PostgresNIOTests/New/Messages/BackendKeyDataTests.swift
@@ -1,10 +1,10 @@
-import XCTest
+import Testing
 import NIOCore
 import NIOTestUtils
 @testable import PostgresNIO
 
-class BackendKeyDataTests: XCTestCase {
-    func testDecode() {
+@Suite struct BackendKeyDataTests {
+    @Test func testDecode() {
         let buffer = ByteBuffer.backendMessage(id: .backendKeyData) { buffer in
             buffer.writeInteger(Int32(1234))
             buffer.writeInteger(Int32(4567))
@@ -14,12 +14,15 @@ class BackendKeyDataTests: XCTestCase {
             (buffer, [PostgresBackendMessage.backendKeyData(.init(processID: 1234, secretKey: 4567))]),
         ]
         
-        XCTAssertNoThrow(try ByteToMessageDecoderVerifier.verifyDecoder(
-            inputOutputPairs: expectedInOuts,
-            decoderFactory: { PostgresBackendMessageDecoder(hasAlreadyReceivedBytes: false) }))
+        #expect(throws: Never.self) {
+            try ByteToMessageDecoderVerifier.verifyDecoder(
+                inputOutputPairs: expectedInOuts,
+                decoderFactory: { PostgresBackendMessageDecoder(hasAlreadyReceivedBytes: false) }
+            )
+        }
     }
     
-    func testDecodeInvalidLength() {
+    @Test func testDecodeInvalidLength() {
         var buffer = ByteBuffer()
         buffer.psqlWriteBackendMessageID(.backendKeyData)
         buffer.writeInteger(Int32(11))
@@ -30,10 +33,11 @@ class BackendKeyDataTests: XCTestCase {
             (buffer, [PostgresBackendMessage.backendKeyData(.init(processID: 1234, secretKey: 4567))]),
         ]
         
-        XCTAssertThrowsError(try ByteToMessageDecoderVerifier.verifyDecoder(
-            inputOutputPairs: expected,
-            decoderFactory: { PostgresBackendMessageDecoder(hasAlreadyReceivedBytes: false) })) {
-            XCTAssert($0 is PostgresMessageDecodingError)
+        #expect(throws: PostgresMessageDecodingError.self) {
+            try ByteToMessageDecoderVerifier.verifyDecoder(
+                inputOutputPairs: expected,
+                decoderFactory: { PostgresBackendMessageDecoder(hasAlreadyReceivedBytes: false) }
+            )
         }
     }
 }
diff --git a/Tests/PostgresNIOTests/New/Messages/BindTests.swift b/Tests/PostgresNIOTests/New/Messages/BindTests.swift
index d5ec5b30..24925fdf 100644
--- a/Tests/PostgresNIOTests/New/Messages/BindTests.swift
+++ b/Tests/PostgresNIOTests/New/Messages/BindTests.swift
@@ -1,10 +1,10 @@
-import XCTest
+import Testing
 import NIOCore
 @testable import PostgresNIO
 
-class BindTests: XCTestCase {
-    
-    func testEncodeBind() {
+@Suite struct BindTests {
+
+    @Test func testEncodeBind() {
         var bindings = PostgresBindings()
         bindings.append("Hello", context: .default)
         bindings.append("World", context: .default)
@@ -14,34 +14,34 @@ class BindTests: XCTestCase {
         encoder.bind(portalName: "", preparedStatementName: "", bind: bindings)
         var byteBuffer = encoder.flushBuffer()
 
-        XCTAssertEqual(byteBuffer.readableBytes, 37)
-        XCTAssertEqual(PostgresFrontendMessage.ID.bind.rawValue, byteBuffer.readInteger(as: UInt8.self))
-        XCTAssertEqual(byteBuffer.readInteger(as: Int32.self), 36)
-        XCTAssertEqual("", byteBuffer.readNullTerminatedString())
-        XCTAssertEqual("", byteBuffer.readNullTerminatedString())
+        #expect(byteBuffer.readableBytes == 37)
+        #expect(PostgresFrontendMessage.ID.bind.rawValue == byteBuffer.readInteger(as: UInt8.self))
+        #expect(byteBuffer.readInteger(as: Int32.self) == 36)
+        #expect("" == byteBuffer.readNullTerminatedString())
+        #expect("" == byteBuffer.readNullTerminatedString())
         // the number of parameters
-        XCTAssertEqual(2, byteBuffer.readInteger(as: Int16.self))
+        #expect(2 == byteBuffer.readInteger(as: Int16.self))
         // all (two) parameters have the same format (binary)
-        XCTAssertEqual(1, byteBuffer.readInteger(as: Int16.self))
-        XCTAssertEqual(1, byteBuffer.readInteger(as: Int16.self))
-        
+        #expect(1 == byteBuffer.readInteger(as: Int16.self))
+        #expect(1 == byteBuffer.readInteger(as: Int16.self))
+
         // read number of parameters
-        XCTAssertEqual(2, byteBuffer.readInteger(as: Int16.self))
-        
+        #expect(2 == byteBuffer.readInteger(as: Int16.self))
+
         // hello length
-        XCTAssertEqual(5, byteBuffer.readInteger(as: Int32.self))
-        XCTAssertEqual("Hello", byteBuffer.readString(length: 5))
-        
+        #expect(5 == byteBuffer.readInteger(as: Int32.self))
+        #expect("Hello" == byteBuffer.readString(length: 5))
+
         // world length
-        XCTAssertEqual(5, byteBuffer.readInteger(as: Int32.self))
-        XCTAssertEqual("World", byteBuffer.readString(length: 5))
-        
+        #expect(5 == byteBuffer.readInteger(as: Int32.self))
+        #expect("World" == byteBuffer.readString(length: 5))
+
         // all response values have the same format: therefore one format byte is next
-        XCTAssertEqual(1, byteBuffer.readInteger(as: Int16.self))
+        #expect(1 == byteBuffer.readInteger(as: Int16.self))
         // all response values have the same format (binary)
-        XCTAssertEqual(1, byteBuffer.readInteger(as: Int16.self))
-        
+        #expect(1 == byteBuffer.readInteger(as: Int16.self))
+
         // nothing left to read
-        XCTAssertEqual(byteBuffer.readableBytes, 0)
+        #expect(byteBuffer.readableBytes == 0)
     }
 }
diff --git a/Tests/PostgresNIOTests/New/Messages/CancelTests.swift b/Tests/PostgresNIOTests/New/Messages/CancelTests.swift
index 5548aae3..c2da01d3 100644
--- a/Tests/PostgresNIOTests/New/Messages/CancelTests.swift
+++ b/Tests/PostgresNIOTests/New/Messages/CancelTests.swift
@@ -1,21 +1,20 @@
-import XCTest
+import Testing
 import NIOCore
 @testable import PostgresNIO
 
-class CancelTests: XCTestCase {
-    
-    func testEncodeCancel() {
+@Suite struct CancelTests {
+    @Test func testEncodeCancel() {
         let processID: Int32 = 1234
         let secretKey: Int32 = 4567
         var encoder = PostgresFrontendMessageEncoder(buffer: .init())
         encoder.cancel(processID: processID, secretKey: secretKey)
         var byteBuffer = encoder.flushBuffer()
         
-        XCTAssertEqual(byteBuffer.readableBytes, 16)
-        XCTAssertEqual(16, byteBuffer.readInteger(as: Int32.self)) // payload length
-        XCTAssertEqual(80877102, byteBuffer.readInteger(as: Int32.self)) // cancel request code
-        XCTAssertEqual(processID, byteBuffer.readInteger(as: Int32.self))
-        XCTAssertEqual(secretKey, byteBuffer.readInteger(as: Int32.self))
-        XCTAssertEqual(byteBuffer.readableBytes, 0)
+        #expect(byteBuffer.readableBytes == 16)
+        #expect(16 == byteBuffer.readInteger(as: Int32.self)) // payload length
+        #expect(80877102 == byteBuffer.readInteger(as: Int32.self)) // cancel request code
+        #expect(processID == byteBuffer.readInteger(as: Int32.self))
+        #expect(secretKey == byteBuffer.readInteger(as: Int32.self))
+        #expect(byteBuffer.readableBytes == 0)
     }
 }
diff --git a/Tests/PostgresNIOTests/New/Messages/CloseTests.swift b/Tests/PostgresNIOTests/New/Messages/CloseTests.swift
index a8e1cfeb..9d6f1b37 100644
--- a/Tests/PostgresNIOTests/New/Messages/CloseTests.swift
+++ b/Tests/PostgresNIOTests/New/Messages/CloseTests.swift
@@ -1,31 +1,31 @@
-import XCTest
+import Testing
 import NIOCore
 @testable import PostgresNIO
 
-class CloseTests: XCTestCase {
-    func testEncodeClosePortal() {
+@Suite struct CloseTests {
+    @Test func testEncodeClosePortal() {
         var encoder = PostgresFrontendMessageEncoder(buffer: .init())
         encoder.closePortal("Hello")
         var byteBuffer = encoder.flushBuffer()
 
-        XCTAssertEqual(byteBuffer.readableBytes, 12)
-        XCTAssertEqual(PostgresFrontendMessage.ID.close.rawValue, byteBuffer.readInteger(as: UInt8.self))
-        XCTAssertEqual(11, byteBuffer.readInteger(as: Int32.self))
-        XCTAssertEqual(UInt8(ascii: "P"), byteBuffer.readInteger(as: UInt8.self))
-        XCTAssertEqual("Hello", byteBuffer.readNullTerminatedString())
-        XCTAssertEqual(byteBuffer.readableBytes, 0)
+        #expect(byteBuffer.readableBytes == 12)
+        #expect(PostgresFrontendMessage.ID.close.rawValue == byteBuffer.readInteger(as: UInt8.self))
+        #expect(11 == byteBuffer.readInteger(as: Int32.self))
+        #expect(UInt8(ascii: "P") == byteBuffer.readInteger(as: UInt8.self))
+        #expect("Hello" == byteBuffer.readNullTerminatedString())
+        #expect(byteBuffer.readableBytes == 0)
     }
     
-    func testEncodeCloseUnnamedStatement() {
+    @Test func testEncodeCloseUnnamedStatement() {
         var encoder = PostgresFrontendMessageEncoder(buffer: .init())
         encoder.closePreparedStatement("")
         var byteBuffer = encoder.flushBuffer()
 
-        XCTAssertEqual(byteBuffer.readableBytes, 7)
-        XCTAssertEqual(PostgresFrontendMessage.ID.close.rawValue, byteBuffer.readInteger(as: UInt8.self))
-        XCTAssertEqual(6, byteBuffer.readInteger(as: Int32.self))
-        XCTAssertEqual(UInt8(ascii: "S"), byteBuffer.readInteger(as: UInt8.self))
-        XCTAssertEqual("", byteBuffer.readNullTerminatedString())
-        XCTAssertEqual(byteBuffer.readableBytes, 0)
+        #expect(byteBuffer.readableBytes == 7)
+        #expect(PostgresFrontendMessage.ID.close.rawValue == byteBuffer.readInteger(as: UInt8.self))
+        #expect(6 == byteBuffer.readInteger(as: Int32.self))
+        #expect(UInt8(ascii: "S") == byteBuffer.readInteger(as: UInt8.self))
+        #expect("" == byteBuffer.readNullTerminatedString())
+        #expect(byteBuffer.readableBytes == 0)
     }
 }
diff --git a/Tests/PostgresNIOTests/New/Messages/CopyTests.swift b/Tests/PostgresNIOTests/New/Messages/CopyTests.swift
index de686ae5..01136d05 100644
--- a/Tests/PostgresNIOTests/New/Messages/CopyTests.swift
+++ b/Tests/PostgresNIOTests/New/Messages/CopyTests.swift
@@ -1,10 +1,10 @@
-import XCTest
+import Testing
 import NIOCore
 import NIOTestUtils
 @testable import PostgresNIO
 
-class CopyTests: XCTestCase {
-    func testDecodeCopyInResponseMessage() throws {
+@Suite struct CopyTests {
+    @Test func testDecodeCopyInResponseMessage() throws {
         let expected: [PostgresBackendMessage] = [
             .copyInResponse(.init(format: .textual, columnFormats: [.textual, .textual])),
             .copyInResponse(.init(format: .binary, columnFormats: [.binary, .binary])),
@@ -15,7 +15,8 @@ class CopyTests: XCTestCase {
 
         for message in expected {
             guard case .copyInResponse(let message) = message else {
-                return XCTFail("Expected only to get copyInResponse here!")
+                Issue.record("Expected only to get copyInResponse here!")
+                return
             }
             buffer.writeBackendMessage(id: .copyInResponse ) { buffer in
                 buffer.writeInteger(Int8(message.format.rawValue))
@@ -31,72 +32,63 @@ class CopyTests: XCTestCase {
         )
     }
 
-    func testDecodeFailureBecauseOfEmptyMessage() {
+    @Test func testDecodeFailureBecauseOfEmptyMessage() {
         var buffer = ByteBuffer()
         buffer.writeBackendMessage(id: .copyInResponse) { _ in}
         
-        XCTAssertThrowsError(
+        #expect(throws: PostgresMessageDecodingError.self) {
             try ByteToMessageDecoderVerifier.verifyDecoder(
                 inputOutputPairs: [(buffer, [])],
                 decoderFactory: { PostgresBackendMessageDecoder(hasAlreadyReceivedBytes: true) }
             )
-        ) {
-            XCTAssert($0 is PostgresMessageDecodingError)
         }
     }
 
 
-    func testDecodeFailureBecauseOfInvalidFormat() {
+    @Test func testDecodeFailureBecauseOfInvalidFormat() {
         var buffer = ByteBuffer()
         buffer.writeBackendMessage(id: .copyInResponse) { buffer in
             buffer.writeInteger(Int8(20))  // Only 0 and 1 are valid formats
         }
-        
-        XCTAssertThrowsError(
+
+        #expect(throws: PostgresMessageDecodingError.self) {
             try ByteToMessageDecoderVerifier.verifyDecoder(
                 inputOutputPairs: [(buffer, [])],
                 decoderFactory: { PostgresBackendMessageDecoder(hasAlreadyReceivedBytes: true) }
             )
-        ) {
-            XCTAssert($0 is PostgresMessageDecodingError)
         }
     }
 
-    func testDecodeFailureBecauseOfMissingColumnNumber() {
+    @Test func testDecodeFailureBecauseOfMissingColumnNumber() {
         var buffer = ByteBuffer()
         buffer.writeBackendMessage(id: .copyInResponse) { buffer in
             buffer.writeInteger(Int8(0))
         }
-        
-        XCTAssertThrowsError(
+
+        #expect(throws: PostgresMessageDecodingError.self) {
             try ByteToMessageDecoderVerifier.verifyDecoder(
                 inputOutputPairs: [(buffer, [])],
                 decoderFactory: { PostgresBackendMessageDecoder(hasAlreadyReceivedBytes: true) }
             )
-        ) {
-            XCTAssert($0 is PostgresMessageDecodingError)
         }
     }
 
-
-    func testDecodeFailureBecauseOfMissingColumns() {
+    @Test func testDecodeFailureBecauseOfMissingColumns() {
         var buffer = ByteBuffer()
         buffer.writeBackendMessage(id: .copyInResponse) { buffer in
             buffer.writeInteger(Int8(0))
             buffer.writeInteger(Int16(20))  // 20 columns promised, none given
         }
         
-        XCTAssertThrowsError(
+        #expect(throws: PostgresMessageDecodingError.self) {
             try ByteToMessageDecoderVerifier.verifyDecoder(
                 inputOutputPairs: [(buffer, [])],
                 decoderFactory: { PostgresBackendMessageDecoder(hasAlreadyReceivedBytes: true) }
             )
-        ) {
-            XCTAssert($0 is PostgresMessageDecodingError)
         }
     }
 
-    func testDecodeFailureBecauseOfInvalidColumnFormat() {
+    @Test func testDecodeFailureBecauseOfInvalidColumnFormat() {
         var buffer = ByteBuffer()
         buffer.writeBackendMessage(id: .copyInResponse) { buffer in
             buffer.writeInteger(Int8(0))
@@ -104,44 +96,42 @@ class CopyTests: XCTestCase {
             buffer.writeInteger(Int8(20))  // Only 0 and 1 are valid formats
         }
         
-        XCTAssertThrowsError(
+        #expect(throws: PostgresMessageDecodingError.self) {
             try ByteToMessageDecoderVerifier.verifyDecoder(
                 inputOutputPairs: [(buffer, [])],
                 decoderFactory: { PostgresBackendMessageDecoder(hasAlreadyReceivedBytes: true) }
             )
-        ) {
-            XCTAssert($0 is PostgresMessageDecodingError)
         }
     }
 
-    func testEncodeCopyDataHeader() {
+    @Test func testEncodeCopyDataHeader() {
         var encoder = PostgresFrontendMessageEncoder(buffer: .init())
         encoder.copyDataHeader(dataLength: 3)
         var byteBuffer = encoder.flushBuffer()
 
-        XCTAssertEqual(byteBuffer.readableBytes, 5)
-        XCTAssertEqual(PostgresFrontendMessage.ID.copyData.rawValue, byteBuffer.readInteger(as: UInt8.self))
-        XCTAssertEqual(byteBuffer.readInteger(as: Int32.self), 7)
+        #expect(byteBuffer.readableBytes == 5)
+        #expect(PostgresFrontendMessage.ID.copyData.rawValue == byteBuffer.readInteger(as: UInt8.self))
+        #expect(byteBuffer.readInteger(as: Int32.self) == 7)
     }
 
-    func testEncodeCopyDone() {
+    @Test func testEncodeCopyDone() {
         var encoder = PostgresFrontendMessageEncoder(buffer: .init())
         encoder.copyDone()
         var byteBuffer = encoder.flushBuffer()
 
-        XCTAssertEqual(byteBuffer.readableBytes, 5)
-        XCTAssertEqual(PostgresFrontendMessage.ID.copyDone.rawValue, byteBuffer.readInteger(as: UInt8.self))
-        XCTAssertEqual(byteBuffer.readInteger(as: Int32.self), 4)
+        #expect(byteBuffer.readableBytes == 5)
+        #expect(PostgresFrontendMessage.ID.copyDone.rawValue == byteBuffer.readInteger(as: UInt8.self))
+        #expect(byteBuffer.readInteger(as: Int32.self) == 4)
     }
 
-    func testEncodeCopyFail() {
+    @Test func testEncodeCopyFail() {
         var encoder = PostgresFrontendMessageEncoder(buffer: .init())
         encoder.copyFail(message: "Oh, no :(")
         var byteBuffer = encoder.flushBuffer()
 
-        XCTAssertEqual(byteBuffer.readableBytes, 15)
-        XCTAssertEqual(PostgresFrontendMessage.ID.copyFail.rawValue, byteBuffer.readInteger(as: UInt8.self))
-        XCTAssertEqual(byteBuffer.readInteger(as: Int32.self), 14)
-        XCTAssertEqual(byteBuffer.readNullTerminatedString(), "Oh, no :(")
+        #expect(byteBuffer.readableBytes == 15)
+        #expect(PostgresFrontendMessage.ID.copyFail.rawValue == byteBuffer.readInteger(as: UInt8.self))
+        #expect(byteBuffer.readInteger(as: Int32.self) == 14)
+        #expect(byteBuffer.readNullTerminatedString() == "Oh, no :(")
     }
 }
diff --git a/Tests/PostgresNIOTests/New/Messages/DataRowTests.swift b/Tests/PostgresNIOTests/New/Messages/DataRowTests.swift
index a90d1e93..f185877a 100644
--- a/Tests/PostgresNIOTests/New/Messages/DataRowTests.swift
+++ b/Tests/PostgresNIOTests/New/Messages/DataRowTests.swift
@@ -1,10 +1,11 @@
-import XCTest
+import Foundation
+import Testing
 import NIOCore
 import NIOTestUtils
 @testable import PostgresNIO
 
-class DataRowTests: XCTestCase {
-    func testDecode() {
+@Suite struct DataRowTests {
+    @Test func testDecode() {
         let buffer = ByteBuffer.backendMessage(id: .dataRow) { buffer in
             // the data row has 3 columns
             buffer.writeInteger(3, as: Int16.self)
@@ -26,23 +27,26 @@ class DataRowTests: XCTestCase {
             (buffer, [PostgresBackendMessage.dataRow(.init(columnCount: 3, bytes: rowSlice))]),
         ]
 
-        XCTAssertNoThrow(try ByteToMessageDecoderVerifier.verifyDecoder(
-            inputOutputPairs: expectedInOuts,
-            decoderFactory: { PostgresBackendMessageDecoder(hasAlreadyReceivedBytes: false) }))
+        #expect(throws: Never.self) {
+            try ByteToMessageDecoderVerifier.verifyDecoder(
+                inputOutputPairs: expectedInOuts,
+                decoderFactory: { PostgresBackendMessageDecoder(hasAlreadyReceivedBytes: false) }
+            )
+        }
     }
     
-    func testIteratingElements() {
+    @Test func testIteratingElements() {
         let dataRow = DataRow.makeTestDataRow(nil, ByteBuffer(), ByteBuffer(repeating: 5, count: 10))
         var iterator = dataRow.makeIterator()
         
-        XCTAssertEqual(dataRow.count, 3)
-        XCTAssertEqual(iterator.next(), .some(.none))
-        XCTAssertEqual(iterator.next(), ByteBuffer())
-        XCTAssertEqual(iterator.next(), ByteBuffer(repeating: 5, count: 10))
-        XCTAssertEqual(iterator.next(), .none)
+        #expect(dataRow.count == 3)
+        #expect(iterator.next() == .some(.none))
+        #expect(iterator.next() == ByteBuffer())
+        #expect(iterator.next() == ByteBuffer(repeating: 5, count: 10))
+        #expect(iterator.next() == .none)
     }
     
-    func testIndexAfterAndSubscript() {
+    @Test func testIndexAfterAndSubscript() {
         let dataRow = DataRow.makeTestDataRow(
             nil,
             ByteBuffer(),
@@ -51,18 +55,18 @@ class DataRowTests: XCTestCase {
         )
         
         var index = dataRow.startIndex
-        XCTAssertEqual(dataRow[index], .none)
+        #expect(dataRow[index] == .none)
         index = dataRow.index(after: index)
-        XCTAssertEqual(dataRow[index], ByteBuffer())
+        #expect(dataRow[index] == ByteBuffer())
         index = dataRow.index(after: index)
-        XCTAssertEqual(dataRow[index], ByteBuffer(repeating: 5, count: 10))
+        #expect(dataRow[index] == ByteBuffer(repeating: 5, count: 10))
         index = dataRow.index(after: index)
-        XCTAssertEqual(dataRow[index], .none)
+        #expect(dataRow[index] == .none)
         index = dataRow.index(after: index)
-        XCTAssertEqual(index, dataRow.endIndex)
+        #expect(index == dataRow.endIndex)
     }
     
-    func testIndexComparison() {
+    @Test func testIndexComparison() {
         let dataRow = DataRow.makeTestDataRow(
             nil,
             ByteBuffer(),
@@ -73,18 +77,18 @@ class DataRowTests: XCTestCase {
         let startIndex = dataRow.startIndex
         let secondIndex = dataRow.index(after: startIndex)
         
-        XCTAssertLessThanOrEqual(startIndex, secondIndex)
-        XCTAssertLessThan(startIndex, secondIndex)
-        
-        XCTAssertGreaterThanOrEqual(secondIndex, startIndex)
-        XCTAssertGreaterThan(secondIndex, startIndex)
-        
-        XCTAssertFalse(secondIndex == startIndex)
-        XCTAssertEqual(secondIndex, secondIndex)
-        XCTAssertEqual(startIndex, startIndex)
+        #expect(startIndex <= secondIndex)
+        #expect(startIndex < secondIndex)
+
+        #expect(secondIndex >= startIndex)
+        #expect(secondIndex > startIndex)
+
+        #expect(secondIndex != startIndex)
+        #expect(secondIndex == secondIndex)
+        #expect(startIndex == startIndex)
     }
     
-    func testColumnSubscript() {
+    @Test func testColumnSubscript() {
         let dataRow = DataRow.makeTestDataRow(
             nil,
             ByteBuffer(),
@@ -92,14 +96,14 @@ class DataRowTests: XCTestCase {
             nil
         )
     
-        XCTAssertEqual(dataRow.count, 4)
-        XCTAssertEqual(dataRow[column: 0], .none)
-        XCTAssertEqual(dataRow[column: 1], ByteBuffer())
-        XCTAssertEqual(dataRow[column: 2], ByteBuffer(repeating: 5, count: 10))
-        XCTAssertEqual(dataRow[column: 3], .none)
+        #expect(dataRow.count == 4)
+        #expect(dataRow[column: 0] == .none)
+        #expect(dataRow[column: 1] == ByteBuffer())
+        #expect(dataRow[column: 2] == ByteBuffer(repeating: 5, count: 10))
+        #expect(dataRow[column: 3] == .none)
     }
     
-    func testWithContiguousStorageIfAvailable() {
+    @Test func testWithContiguousStorageIfAvailable() {
         let dataRow = DataRow.makeTestDataRow(
             nil,
             ByteBuffer(),
@@ -107,9 +111,9 @@ class DataRowTests: XCTestCase {
             nil
         )
         
-        XCTAssertNil(dataRow.withContiguousStorageIfAvailable { _ in
-            return XCTFail("DataRow does not have a contiguous storage")
-        })
+        #expect(dataRow.withContiguousStorageIfAvailable { _ in
+            Issue.record("DataRow does not have a contiguous storage")
+        } == nil)
     }
 }
 
diff --git a/Tests/PostgresNIOTests/New/Messages/DescribeTests.swift b/Tests/PostgresNIOTests/New/Messages/DescribeTests.swift
index cb3c745b..42a521aa 100644
--- a/Tests/PostgresNIOTests/New/Messages/DescribeTests.swift
+++ b/Tests/PostgresNIOTests/New/Messages/DescribeTests.swift
@@ -1,33 +1,32 @@
-import XCTest
+import Testing
 import NIOCore
 @testable import PostgresNIO
 
-class DescribeTests: XCTestCase {
-    
-    func testEncodeDescribePortal() {
+@Suite struct DescribeTests {
+    @Test func testEncodeDescribePortal() {
         var encoder = PostgresFrontendMessageEncoder(buffer: .init())
         encoder.describePortal("Hello")
         var byteBuffer = encoder.flushBuffer()
 
-        XCTAssertEqual(byteBuffer.readableBytes, 12)
-        XCTAssertEqual(PostgresFrontendMessage.ID.describe.rawValue, byteBuffer.readInteger(as: UInt8.self))
-        XCTAssertEqual(11, byteBuffer.readInteger(as: Int32.self))
-        XCTAssertEqual(UInt8(ascii: "P"), byteBuffer.readInteger(as: UInt8.self))
-        XCTAssertEqual("Hello", byteBuffer.readNullTerminatedString())
-        XCTAssertEqual(byteBuffer.readableBytes, 0)
+        #expect(byteBuffer.readableBytes == 12)
+        #expect(PostgresFrontendMessage.ID.describe.rawValue == byteBuffer.readInteger(as: UInt8.self))
+        #expect(11 == byteBuffer.readInteger(as: Int32.self))
+        #expect(UInt8(ascii: "P") == byteBuffer.readInteger(as: UInt8.self))
+        #expect("Hello" == byteBuffer.readNullTerminatedString())
+        #expect(byteBuffer.readableBytes == 0)
     }
-    
-    func testEncodeDescribeUnnamedStatement() {
+
+    @Test func testEncodeDescribeUnnamedStatement() {
         var encoder = PostgresFrontendMessageEncoder(buffer: .init())
         encoder.describePreparedStatement("")
         var byteBuffer = encoder.flushBuffer()
 
-        XCTAssertEqual(byteBuffer.readableBytes, 7)
-        XCTAssertEqual(PostgresFrontendMessage.ID.describe.rawValue, byteBuffer.readInteger(as: UInt8.self))
-        XCTAssertEqual(6, byteBuffer.readInteger(as: Int32.self))
-        XCTAssertEqual(UInt8(ascii: "S"), byteBuffer.readInteger(as: UInt8.self))
-        XCTAssertEqual("", byteBuffer.readNullTerminatedString())
-        XCTAssertEqual(byteBuffer.readableBytes, 0)
+        #expect(byteBuffer.readableBytes == 7)
+        #expect(PostgresFrontendMessage.ID.describe.rawValue == byteBuffer.readInteger(as: UInt8.self))
+        #expect(6 == byteBuffer.readInteger(as: Int32.self))
+        #expect(UInt8(ascii: "S") == byteBuffer.readInteger(as: UInt8.self))
+        #expect("" == byteBuffer.readNullTerminatedString())
+        #expect(byteBuffer.readableBytes == 0)
     }
 
 }
diff --git a/Tests/PostgresNIOTests/New/Messages/ExecuteTests.swift b/Tests/PostgresNIOTests/New/Messages/ExecuteTests.swift
index 834ad0dd..985ab10e 100644
--- a/Tests/PostgresNIOTests/New/Messages/ExecuteTests.swift
+++ b/Tests/PostgresNIOTests/New/Messages/ExecuteTests.swift
@@ -1,18 +1,17 @@
-import XCTest
+import Testing
 import NIOCore
 @testable import PostgresNIO
 
-class ExecuteTests: XCTestCase {
-    
-    func testEncodeExecute() {
+@Suite struct ExecuteTests {
+    @Test func testEncodeExecute() {
         var encoder = PostgresFrontendMessageEncoder(buffer: .init())
         encoder.execute(portalName: "", maxNumberOfRows: 0)
         var byteBuffer = encoder.flushBuffer()
 
-        XCTAssertEqual(byteBuffer.readableBytes, 10) // 1 (id) + 4 (length) + 1 (empty null terminated string) + 4 (count)
-        XCTAssertEqual(PostgresFrontendMessage.ID.execute.rawValue, byteBuffer.readInteger(as: UInt8.self))
-        XCTAssertEqual(9, byteBuffer.readInteger(as: Int32.self)) // length
-        XCTAssertEqual("", byteBuffer.readNullTerminatedString())
-        XCTAssertEqual(0, byteBuffer.readInteger(as: Int32.self))
+        #expect(byteBuffer.readableBytes == 10) // 1 (id) + 4 (length) + 1 (empty null terminated string) + 4 (count)
+        #expect(PostgresFrontendMessage.ID.execute.rawValue == byteBuffer.readInteger(as: UInt8.self))
+        #expect(9 == byteBuffer.readInteger(as: Int32.self)) // length
+        #expect("" == byteBuffer.readNullTerminatedString())
+        #expect(0 == byteBuffer.readInteger(as: Int32.self))
     }
 }
diff --git a/Tests/PostgresNIOTests/New/Messages/ParseTests.swift b/Tests/PostgresNIOTests/New/Messages/ParseTests.swift
index 9f81e4e4..e40dbbfe 100644
--- a/Tests/PostgresNIOTests/New/Messages/ParseTests.swift
+++ b/Tests/PostgresNIOTests/New/Messages/ParseTests.swift
@@ -1,9 +1,9 @@
-import XCTest
+import Testing
 import NIOCore
 @testable import PostgresNIO
 
-class ParseTests: XCTestCase {
-    func testEncode() {
+@Suite struct ParseTests {
+    @Test func testEncode() {
         let preparedStatementName = "test"
         let query = "SELECT version()"
         let parameters: [PostgresDataType] = [.bool, .int8, .bytea, .varchar, .text, .uuid, .json, .jsonbArray]
@@ -22,14 +22,14 @@ class ParseTests: XCTestCase {
         // + 4 preparedStatement (3 + 1 null terminator)
         // + 1 query ()
         
-        XCTAssertEqual(byteBuffer.readableBytes, length)
-        XCTAssertEqual(byteBuffer.readInteger(as: UInt8.self), PostgresFrontendMessage.ID.parse.rawValue)
-        XCTAssertEqual(byteBuffer.readInteger(as: Int32.self), Int32(length - 1))
-        XCTAssertEqual(byteBuffer.readNullTerminatedString(), preparedStatementName)
-        XCTAssertEqual(byteBuffer.readNullTerminatedString(), query)
-        XCTAssertEqual(byteBuffer.readInteger(as: UInt16.self), UInt16(parameters.count))
+        #expect(byteBuffer.readableBytes == length)
+        #expect(byteBuffer.readInteger(as: UInt8.self) == PostgresFrontendMessage.ID.parse.rawValue)
+        #expect(byteBuffer.readInteger(as: Int32.self) == Int32(length - 1))
+        #expect(byteBuffer.readNullTerminatedString() == preparedStatementName)
+        #expect(byteBuffer.readNullTerminatedString() == query)
+        #expect(byteBuffer.readInteger(as: UInt16.self) == UInt16(parameters.count))
         for dataType in parameters {
-            XCTAssertEqual(byteBuffer.readInteger(as: UInt32.self), dataType.rawValue)
+            #expect(byteBuffer.readInteger(as: UInt32.self) == dataType.rawValue)
         }
     }
 }
diff --git a/Tests/PostgresNIOTests/New/Messages/PasswordTests.swift b/Tests/PostgresNIOTests/New/Messages/PasswordTests.swift
index 4a4833d2..cf4ad83f 100644
--- a/Tests/PostgresNIOTests/New/Messages/PasswordTests.swift
+++ b/Tests/PostgresNIOTests/New/Messages/PasswordTests.swift
@@ -1,10 +1,9 @@
-import XCTest
+import Testing
 import NIOCore
 @testable import PostgresNIO
 
-class PasswordTests: XCTestCase {
-    
-    func testEncodePassword() {
+@Suite struct PasswordTests {
+    @Test func testEncodePassword() {
         var encoder = PostgresFrontendMessageEncoder(buffer: .init())
         // md522d085ed8dc3377968dc1c1a40519a2a = "abc123" with salt 1, 2, 3, 4
         let password = "md522d085ed8dc3377968dc1c1a40519a2a"
@@ -13,9 +12,9 @@ class PasswordTests: XCTestCase {
         
         let expectedLength = 41 // 1 (id) + 4 (length) + 35 (string) + 1 (null termination)
         
-        XCTAssertEqual(byteBuffer.readableBytes, expectedLength)
-        XCTAssertEqual(byteBuffer.readInteger(as: UInt8.self), PostgresFrontendMessage.ID.password.rawValue)
-        XCTAssertEqual(byteBuffer.readInteger(as: Int32.self), Int32(expectedLength - 1)) // length
-        XCTAssertEqual(byteBuffer.readNullTerminatedString(), "md522d085ed8dc3377968dc1c1a40519a2a")
+        #expect(byteBuffer.readableBytes == expectedLength)
+        #expect(byteBuffer.readInteger(as: UInt8.self) == PostgresFrontendMessage.ID.password.rawValue)
+        #expect(byteBuffer.readInteger(as: Int32.self) == Int32(expectedLength - 1)) // length
+        #expect(byteBuffer.readNullTerminatedString() == "md522d085ed8dc3377968dc1c1a40519a2a")
     }
 }
diff --git a/Tests/PostgresNIOTests/New/Messages/SASLInitialResponseTests.swift b/Tests/PostgresNIOTests/New/Messages/SASLInitialResponseTests.swift
index 90aa6b34..7ba31057 100644
--- a/Tests/PostgresNIOTests/New/Messages/SASLInitialResponseTests.swift
+++ b/Tests/PostgresNIOTests/New/Messages/SASLInitialResponseTests.swift
@@ -1,10 +1,10 @@
-import XCTest
+import Testing
 import NIOCore
 @testable import PostgresNIO
 
-class SASLInitialResponseTests: XCTestCase {
+@Suite struct SASLInitialResponseTests {
 
-    func testEncode() {
+    @Test func testEncode() {
         var encoder = PostgresFrontendMessageEncoder(buffer: .init())
         let saslMechanism = "hello"
         let initialData: [UInt8] = [0, 1, 2, 3, 4, 5, 6, 7]
@@ -19,16 +19,16 @@ class SASLInitialResponseTests: XCTestCase {
         // + 4 initialData length
         // + 8 initialData
         
-        XCTAssertEqual(byteBuffer.readableBytes, length)
-        XCTAssertEqual(byteBuffer.readInteger(as: UInt8.self), PostgresFrontendMessage.ID.saslInitialResponse.rawValue)
-        XCTAssertEqual(byteBuffer.readInteger(as: Int32.self), Int32(length - 1))
-        XCTAssertEqual(byteBuffer.readNullTerminatedString(), saslMechanism)
-        XCTAssertEqual(byteBuffer.readInteger(as: Int32.self), Int32(initialData.count))
-        XCTAssertEqual(byteBuffer.readBytes(length: initialData.count), initialData)
-        XCTAssertEqual(byteBuffer.readableBytes, 0)
+        #expect(byteBuffer.readableBytes == length)
+        #expect(byteBuffer.readInteger(as: UInt8.self) == PostgresFrontendMessage.ID.saslInitialResponse.rawValue)
+        #expect(byteBuffer.readInteger(as: Int32.self) == Int32(length - 1))
+        #expect(byteBuffer.readNullTerminatedString() == saslMechanism)
+        #expect(byteBuffer.readInteger(as: Int32.self) == Int32(initialData.count))
+        #expect(byteBuffer.readBytes(length: initialData.count) == initialData)
+        #expect(byteBuffer.readableBytes == 0)
     }
     
-    func testEncodeWithoutData() {
+    @Test func testEncodeWithoutData() {
         var encoder = PostgresFrontendMessageEncoder(buffer: .init())
         let saslMechanism = "hello"
         let initialData: [UInt8] = []
@@ -43,12 +43,12 @@ class SASLInitialResponseTests: XCTestCase {
         // + 4 initialData length
         // + 0 initialData
         
-        XCTAssertEqual(byteBuffer.readableBytes, length)
-        XCTAssertEqual(byteBuffer.readInteger(as: UInt8.self), PostgresFrontendMessage.ID.saslInitialResponse.rawValue)
-        XCTAssertEqual(byteBuffer.readInteger(as: Int32.self), Int32(length - 1))
-        XCTAssertEqual(byteBuffer.readNullTerminatedString(), saslMechanism)
-        XCTAssertEqual(byteBuffer.readInteger(as: Int32.self), Int32(-1))
-        XCTAssertEqual(byteBuffer.readBytes(length: initialData.count), initialData)
-        XCTAssertEqual(byteBuffer.readableBytes, 0)
+        #expect(byteBuffer.readableBytes == length)
+        #expect(byteBuffer.readInteger(as: UInt8.self) == PostgresFrontendMessage.ID.saslInitialResponse.rawValue)
+        #expect(byteBuffer.readInteger(as: Int32.self) == Int32(length - 1))
+        #expect(byteBuffer.readNullTerminatedString() == saslMechanism)
+        #expect(byteBuffer.readInteger(as: Int32.self) == Int32(-1))
+        #expect(byteBuffer.readBytes(length: initialData.count) == initialData)
+        #expect(byteBuffer.readableBytes == 0)
     }
 }
diff --git a/Tests/PostgresNIOTests/New/Messages/SASLResponseTests.swift b/Tests/PostgresNIOTests/New/Messages/SASLResponseTests.swift
index cdb0f10b..a2a06418 100644
--- a/Tests/PostgresNIOTests/New/Messages/SASLResponseTests.swift
+++ b/Tests/PostgresNIOTests/New/Messages/SASLResponseTests.swift
@@ -1,10 +1,10 @@
-import XCTest
+import Testing
 import NIOCore
 @testable import PostgresNIO
 
-class SASLResponseTests: XCTestCase {
+@Suite struct SASLResponseTests {
 
-    func testEncodeWithData() {
+    @Test func testEncodeWithData() {
         var encoder = PostgresFrontendMessageEncoder(buffer: .init())
         let data: [UInt8] = [0, 1, 2, 3, 4, 5, 6, 7]
         encoder.saslResponse(data)
@@ -12,14 +12,14 @@ class SASLResponseTests: XCTestCase {
 
         let length: Int = 1 + 4 + (data.count)
         
-        XCTAssertEqual(byteBuffer.readableBytes, length)
-        XCTAssertEqual(byteBuffer.readInteger(as: UInt8.self), PostgresFrontendMessage.ID.saslResponse.rawValue)
-        XCTAssertEqual(byteBuffer.readInteger(as: Int32.self), Int32(length - 1))
-        XCTAssertEqual(byteBuffer.readBytes(length: data.count), data)
-        XCTAssertEqual(byteBuffer.readableBytes, 0)
+        #expect(byteBuffer.readableBytes == length)
+        #expect(byteBuffer.readInteger(as: UInt8.self) == PostgresFrontendMessage.ID.saslResponse.rawValue)
+        #expect(byteBuffer.readInteger(as: Int32.self) == Int32(length - 1))
+        #expect(byteBuffer.readBytes(length: data.count) == data)
+        #expect(byteBuffer.readableBytes == 0)
     }
     
-    func testEncodeWithoutData() {
+    @Test func testEncodeWithoutData() {
         var encoder = PostgresFrontendMessageEncoder(buffer: .init())
         let data: [UInt8] = []
         encoder.saslResponse(data)
@@ -27,9 +27,9 @@ class SASLResponseTests: XCTestCase {
 
         let length: Int = 1 + 4
         
-        XCTAssertEqual(byteBuffer.readableBytes, length)
-        XCTAssertEqual(byteBuffer.readInteger(as: UInt8.self), PostgresFrontendMessage.ID.saslResponse.rawValue)
-        XCTAssertEqual(byteBuffer.readInteger(as: Int32.self), Int32(length - 1))
-        XCTAssertEqual(byteBuffer.readableBytes, 0)
+        #expect(byteBuffer.readableBytes == length)
+        #expect(byteBuffer.readInteger(as: UInt8.self) == PostgresFrontendMessage.ID.saslResponse.rawValue)
+        #expect(byteBuffer.readInteger(as: Int32.self) == Int32(length - 1))
+        #expect(byteBuffer.readableBytes == 0)
     }
 }
diff --git a/Tests/PostgresNIOTests/New/Messages/StartupTests.swift b/Tests/PostgresNIOTests/New/Messages/StartupTests.swift
index 5af3bf34..23d022d9 100644
--- a/Tests/PostgresNIOTests/New/Messages/StartupTests.swift
+++ b/Tests/PostgresNIOTests/New/Messages/StartupTests.swift
@@ -1,10 +1,9 @@
-import XCTest
+import Testing
 import NIOCore
 @testable import PostgresNIO
 
-class StartupTests: XCTestCase {
-    
-    func testStartupMessageWithDatabase() {
+@Suite struct StartupTests {
+    @Test func testStartupMessageWithDatabase() {
         var encoder = PostgresFrontendMessageEncoder(buffer: .init())
         var byteBuffer = ByteBuffer()
 
@@ -15,18 +14,18 @@ class StartupTests: XCTestCase {
         byteBuffer = encoder.flushBuffer()
 
         let byteBufferLength = Int32(byteBuffer.readableBytes)
-        XCTAssertEqual(byteBufferLength, byteBuffer.readInteger())
-        XCTAssertEqual(PostgresFrontendMessage.Startup.versionThree, byteBuffer.readInteger())
-        XCTAssertEqual(byteBuffer.readNullTerminatedString(), "user")
-        XCTAssertEqual(byteBuffer.readNullTerminatedString(), "test")
-        XCTAssertEqual(byteBuffer.readNullTerminatedString(), "database")
-        XCTAssertEqual(byteBuffer.readNullTerminatedString(), "abc123")
-        XCTAssertEqual(byteBuffer.readInteger(), UInt8(0))
+        #expect(byteBufferLength == byteBuffer.readInteger())
+        #expect(PostgresFrontendMessage.Startup.versionThree == byteBuffer.readInteger())
+        #expect(byteBuffer.readNullTerminatedString() == "user")
+        #expect(byteBuffer.readNullTerminatedString() == "test")
+        #expect(byteBuffer.readNullTerminatedString() == "database")
+        #expect(byteBuffer.readNullTerminatedString() == "abc123")
+        #expect(byteBuffer.readInteger() == UInt8(0))
 
-        XCTAssertEqual(byteBuffer.readableBytes, 0)
+        #expect(byteBuffer.readableBytes == 0)
     }
 
-    func testStartupMessageWithoutDatabase() {
+    @Test func testStartupMessageWithoutDatabase() {
         var encoder = PostgresFrontendMessageEncoder(buffer: .init())
         var byteBuffer = ByteBuffer()
 
@@ -36,16 +35,16 @@ class StartupTests: XCTestCase {
         byteBuffer = encoder.flushBuffer()
 
         let byteBufferLength = Int32(byteBuffer.readableBytes)
-        XCTAssertEqual(byteBufferLength, byteBuffer.readInteger())
-        XCTAssertEqual(PostgresFrontendMessage.Startup.versionThree, byteBuffer.readInteger())
-        XCTAssertEqual(byteBuffer.readNullTerminatedString(), "user")
-        XCTAssertEqual(byteBuffer.readNullTerminatedString(), "test")
-        XCTAssertEqual(byteBuffer.readInteger(), UInt8(0))
+        #expect(byteBufferLength == byteBuffer.readInteger())
+        #expect(PostgresFrontendMessage.Startup.versionThree == byteBuffer.readInteger())
+        #expect(byteBuffer.readNullTerminatedString() == "user")
+        #expect(byteBuffer.readNullTerminatedString() == "test")
+        #expect(byteBuffer.readInteger() == UInt8(0))
 
-        XCTAssertEqual(byteBuffer.readableBytes, 0)
+        #expect(byteBuffer.readableBytes == 0)
     }
 
-    func testStartupMessageWithAdditionalOptions() {
+    @Test func testStartupMessageWithAdditionalOptions() {
         var encoder = PostgresFrontendMessageEncoder(buffer: .init())
         var byteBuffer = ByteBuffer()
         
@@ -56,17 +55,17 @@ class StartupTests: XCTestCase {
         byteBuffer = encoder.flushBuffer()
         
         let byteBufferLength = Int32(byteBuffer.readableBytes)
-        XCTAssertEqual(byteBufferLength, byteBuffer.readInteger())
-        XCTAssertEqual(PostgresFrontendMessage.Startup.versionThree, byteBuffer.readInteger())
-        XCTAssertEqual(byteBuffer.readNullTerminatedString(), "user")
-        XCTAssertEqual(byteBuffer.readNullTerminatedString(), "test")
-        XCTAssertEqual(byteBuffer.readNullTerminatedString(), "database")
-        XCTAssertEqual(byteBuffer.readNullTerminatedString(), "abc123")
-        XCTAssertEqual(byteBuffer.readNullTerminatedString(), "some")
-        XCTAssertEqual(byteBuffer.readNullTerminatedString(), "options")
-        XCTAssertEqual(byteBuffer.readInteger(), UInt8(0))
-        
-        XCTAssertEqual(byteBuffer.readableBytes, 0)
+        #expect(byteBufferLength == byteBuffer.readInteger())
+        #expect(PostgresFrontendMessage.Startup.versionThree == byteBuffer.readInteger())
+        #expect(byteBuffer.readNullTerminatedString() == "user")
+        #expect(byteBuffer.readNullTerminatedString() == "test")
+        #expect(byteBuffer.readNullTerminatedString() == "database")
+        #expect(byteBuffer.readNullTerminatedString() == "abc123")
+        #expect(byteBuffer.readNullTerminatedString() == "some")
+        #expect(byteBuffer.readNullTerminatedString() == "options")
+        #expect(byteBuffer.readInteger() == UInt8(0))
+
+        #expect(byteBuffer.readableBytes == 0)
     }
 }
 
diff --git a/Tests/PostgresNIOTests/New/PostgresCellTests.swift b/Tests/PostgresNIOTests/New/PostgresCellTests.swift
index 6458d063..4ed64b3f 100644
--- a/Tests/PostgresNIOTests/New/PostgresCellTests.swift
+++ b/Tests/PostgresNIOTests/New/PostgresCellTests.swift
@@ -1,9 +1,9 @@
 @testable import PostgresNIO
-import XCTest
+import Testing
 import NIOCore
 
-final class PostgresCellTests: XCTestCase {
-    func testDecodingANonOptionalString() {
+@Suite struct PostgresCellTests {
+    @Test func testDecodingANonOptionalString() {
         let cell = PostgresCell(
             bytes: ByteBuffer(string: "Hello world"),
             dataType: .text,
@@ -13,11 +13,13 @@ final class PostgresCellTests: XCTestCase {
         )
 
         var result: String?
-        XCTAssertNoThrow(result = try cell.decode(String.self, context: .default))
-        XCTAssertEqual(result, "Hello world")
+        #expect(throws: Never.self) {
+            result = try cell.decode(String.self, context: .default)
+        }
+        #expect(result == "Hello world")
     }
 
-    func testDecodingAnOptionalString() {
+    @Test func testDecodingAnOptionalString() {
         let cell = PostgresCell(
             bytes: nil,
             dataType: .text,
@@ -27,11 +29,13 @@ final class PostgresCellTests: XCTestCase {
         )
 
         var result: String? = "test"
-        XCTAssertNoThrow(result = try cell.decode(String?.self, context: .default))
-        XCTAssertNil(result)
+        #expect(throws: Never.self) {
+            result = try cell.decode(String?.self, context: .default)
+        }
+        #expect(result == nil)
     }
 
-    func testDecodingFailure() {
+    @Test func testDecodingFailure() {
         let cell = PostgresCell(
             bytes: ByteBuffer(string: "Hello world"),
             dataType: .text,
@@ -40,19 +44,44 @@ final class PostgresCellTests: XCTestCase {
             columnIndex: 1
         )
 
-        XCTAssertThrowsError(try cell.decode(Int?.self, context: .default)) {
-            guard let error = $0 as? PostgresDecodingError else {
-                return XCTFail("Unexpected error")
+        #if compiler(>=6.1)
+        let error = #expect(throws: PostgresDecodingError.self) {
+            try cell.decode(Int?.self, context: .default)
+        }
+        guard let error else {
+            Issue.record("Expected error at this point")
+            return
+        }
+
+        #expect(error.file == #fileID)
+        #expect(error.line == #line - 9)
+        #expect(error.code == .typeMismatch)
+        #expect(error.columnName == "hello")
+        #expect(error.columnIndex == 1)
+        let correctType = error.targetType == Int?.self
+        #expect(correctType)
+        #expect(error.postgresType == .text)
+        #expect(error.postgresFormat == .binary)
+        #else
+        do {
+            _ = try cell.decode(Int?.self, context: .default)
+            Issue.record("Expected to throw")
+        } catch {
+            guard let error = error as? PostgresDecodingError else {
+                Issue.record("Expected error at this point")
+                return
             }
 
-            XCTAssertEqual(error.file, #fileID)
-            XCTAssertEqual(error.line, #line - 6)
-            XCTAssertEqual(error.code, .typeMismatch)
-            XCTAssertEqual(error.columnName, "hello")
-            XCTAssertEqual(error.columnIndex, 1)
-            XCTAssert(error.targetType == Int?.self)
-            XCTAssertEqual(error.postgresType, .text)
-            XCTAssertEqual(error.postgresFormat, .binary)
+            #expect(error.file == #fileID)
+            #expect(error.line == #line - 9)
+            #expect(error.code == .typeMismatch)
+            #expect(error.columnName == "hello")
+            #expect(error.columnIndex == 1)
+            let correctType = error.targetType == Int?.self
+            #expect(correctType)
+            #expect(error.postgresType == .text)
+            #expect(error.postgresFormat == .binary)
         }
+        #endif
     }
 }
diff --git a/Tests/PostgresNIOTests/New/PostgresRowSequenceTests.swift b/Tests/PostgresNIOTests/New/PostgresRowSequenceTests.swift
index 9d662252..54f13e96 100644
--- a/Tests/PostgresNIOTests/New/PostgresRowSequenceTests.swift
+++ b/Tests/PostgresNIOTests/New/PostgresRowSequenceTests.swift
@@ -1,15 +1,15 @@
 import Atomics
 import NIOEmbedded
 import NIOPosix
-import XCTest
+import Testing
 @testable import PostgresNIO
 import NIOCore
 import Logging
 
-final class PostgresRowSequenceTests: XCTestCase {
+@Suite struct PostgresRowSequenceTests {
     let logger = Logger(label: "PSQLRowStreamTests")
 
-    func testBackpressureWorks() async throws {
+    @Test func testBackpressureWorks() async throws {
         let dataSource = MockRowDataSource()
         let embeddedEventLoop = EmbeddedEventLoop()
         let stream = PSQLRowStream(
@@ -24,22 +24,22 @@ final class PostgresRowSequenceTests: XCTestCase {
         )
 
         let rowSequence = stream.asyncSequence()
-        XCTAssertEqual(dataSource.requestCount, 0)
+        #expect(dataSource.requestCount == 0)
         let dataRow: DataRow = [ByteBuffer(integer: Int64(1))]
         stream.receive([dataRow])
 
         var iterator = rowSequence.makeAsyncIterator()
         let row = try await iterator.next()
-        XCTAssertEqual(dataSource.requestCount, 1)
-        XCTAssertEqual(row?.data, dataRow)
+        #expect(dataSource.requestCount == 1)
+        #expect(row?.data == dataRow)
 
         stream.receive(completion: .success("SELECT 1"))
         let empty = try await iterator.next()
-        XCTAssertNil(empty)
+        #expect(empty == nil)
     }
 
 
-    func testCancellationWorksWhileIterating() async throws {
+    @Test func testCancellationWorksWhileIterating() async throws {
         let dataSource = MockRowDataSource()
         let embeddedEventLoop = EmbeddedEventLoop()
         let stream = PSQLRowStream(
@@ -54,13 +54,13 @@ final class PostgresRowSequenceTests: XCTestCase {
         )
 
         let rowSequence = stream.asyncSequence()
-        XCTAssertEqual(dataSource.requestCount, 0)
+        #expect(dataSource.requestCount == 0)
         let dataRows: [DataRow] = (0..<128).map { [ByteBuffer(integer: Int64($0))] }
         stream.receive(dataRows)
 
         var counter = 0
         for try await row in rowSequence {
-            XCTAssertEqual(try row.decode(Int.self), counter)
+            #expect(try row.decode(Int.self) == counter)
             counter += 1
 
             if counter == 64 {
@@ -68,10 +68,10 @@ final class PostgresRowSequenceTests: XCTestCase {
             }
         }
 
-        XCTAssertEqual(dataSource.cancelCount, 1)
+        #expect(dataSource.cancelCount == 1)
     }
 
-    func testCancellationWorksBeforeIterating() async throws {
+    @Test func testCancellationWorksBeforeIterating() async throws {
         let dataSource = MockRowDataSource()
         let embeddedEventLoop = EmbeddedEventLoop()
         let stream = PSQLRowStream(
@@ -86,18 +86,18 @@ final class PostgresRowSequenceTests: XCTestCase {
         )
 
         let rowSequence = stream.asyncSequence()
-        XCTAssertEqual(dataSource.requestCount, 0)
+        #expect(dataSource.requestCount == 0)
         let dataRows: [DataRow] = (0..<128).map { [ByteBuffer(integer: Int64($0))] }
         stream.receive(dataRows)
 
         var iterator: PostgresRowSequence.AsyncIterator? = rowSequence.makeAsyncIterator()
         iterator = nil
 
-        XCTAssertEqual(dataSource.cancelCount, 1)
-        XCTAssertNil(iterator, "Surpress warning")
+        #expect(dataSource.cancelCount == 1)
+        #expect(iterator == nil, "Surpress warning")
     }
 
-    func testDroppingTheSequenceCancelsTheSource() async throws {
+    @Test func testDroppingTheSequenceCancelsTheSource() throws {
         let dataSource = MockRowDataSource()
         let embeddedEventLoop = EmbeddedEventLoop()
         let stream = PSQLRowStream(
@@ -114,11 +114,11 @@ final class PostgresRowSequenceTests: XCTestCase {
         var rowSequence: PostgresRowSequence? = stream.asyncSequence()
         rowSequence = nil
 
-        XCTAssertEqual(dataSource.cancelCount, 1)
-        XCTAssertNil(rowSequence, "Surpress warning")
+        #expect(dataSource.cancelCount == 1)
+        #expect(rowSequence == nil, "Surpress warning")
     }
 
-    func testStreamBasedOnCompletedQuery() async throws {
+    @Test func testStreamBasedOnCompletedQuery() async throws {
         let dataSource = MockRowDataSource()
         let embeddedEventLoop = EmbeddedEventLoop()
         let stream = PSQLRowStream(
@@ -139,14 +139,14 @@ final class PostgresRowSequenceTests: XCTestCase {
 
         var counter = 0
         for try await row in rowSequence {
-            XCTAssertEqual(try row.decode(Int.self), counter)
+            #expect(try row.decode(Int.self) == counter)
             counter += 1
         }
 
-        XCTAssertEqual(dataSource.cancelCount, 0)
+        #expect(dataSource.cancelCount == 0)
     }
 
-    func testStreamIfInitializedWithAllData() async throws {
+    @Test func testStreamIfInitializedWithAllData() async throws {
         let dataSource = MockRowDataSource()
         let embeddedEventLoop = EmbeddedEventLoop()
         let stream = PSQLRowStream(
@@ -168,14 +168,14 @@ final class PostgresRowSequenceTests: XCTestCase {
 
         var counter = 0
         for try await row in rowSequence {
-            XCTAssertEqual(try row.decode(Int.self), counter)
+            #expect(try row.decode(Int.self) == counter)
             counter += 1
         }
 
-        XCTAssertEqual(dataSource.cancelCount, 0)
+        #expect(dataSource.cancelCount == 0)
     }
 
-    func testStreamIfInitializedWithError() async throws {
+    @Test func testStreamIfInitializedWithError() async throws {
         let dataSource = MockRowDataSource()
         let embeddedEventLoop = EmbeddedEventLoop()
         let stream = PSQLRowStream(
@@ -198,13 +198,13 @@ final class PostgresRowSequenceTests: XCTestCase {
             for try await _ in rowSequence {
                 counter += 1
             }
-            XCTFail("Expected that an error was thrown before.")
+            Issue.record("Expected that an error was thrown before.")
         } catch {
-            XCTAssertEqual(error as? PSQLError, .serverClosedConnection(underlying: nil))
+            #expect(error as? PSQLError == .serverClosedConnection(underlying: nil))
         }
     }
 
-    func testSucceedingRowContinuationsWorks() async throws {
+    @Test func testSucceedingRowContinuationsWorks() async throws {
         let dataSource = MockRowDataSource()
         let eventLoop = NIOSingletons.posixEventLoopGroup.next()
         let stream = PSQLRowStream(
@@ -227,17 +227,17 @@ final class PostgresRowSequenceTests: XCTestCase {
         }
 
         let row1 = try await rowIterator.next()
-        XCTAssertEqual(try row1?.decode(Int.self), 0)
+        #expect(try row1?.decode(Int.self) == 0)
 
         eventLoop.scheduleTask(in: .seconds(1)) {
             stream.receive(completion: .success("SELECT 1"))
         }
 
         let row2 = try await rowIterator.next()
-        XCTAssertNil(row2)
+        #expect(row2 == nil)
     }
 
-    func testFailingRowContinuationsWorks() async throws {
+    @Test func testFailingRowContinuationsWorks() async throws {
         let dataSource = MockRowDataSource()
         let eventLoop = NIOSingletons.posixEventLoopGroup.next()
         let stream = PSQLRowStream(
@@ -260,7 +260,7 @@ final class PostgresRowSequenceTests: XCTestCase {
         }
 
         let row1 = try await rowIterator.next()
-        XCTAssertEqual(try row1?.decode(Int.self), 0)
+        #expect(try row1?.decode(Int.self) == 0)
 
         eventLoop.scheduleTask(in: .seconds(1)) {
             stream.receive(completion: .failure(PSQLError.serverClosedConnection(underlying: nil)))
@@ -268,13 +268,13 @@ final class PostgresRowSequenceTests: XCTestCase {
 
         do {
             _ = try await rowIterator.next()
-            XCTFail("Expected that an error was thrown before.")
+            Issue.record("Expected that an error was thrown before.")
         } catch {
-            XCTAssertEqual(error as? PSQLError, .serverClosedConnection(underlying: nil))
+            #expect(error as? PSQLError == .serverClosedConnection(underlying: nil))
         }
     }
 
-    func testAdaptiveRowBufferShrinksAndGrows() async throws {
+    @Test func testAdaptiveRowBufferShrinksAndGrows() async throws {
         let dataSource = MockRowDataSource()
         let embeddedEventLoop = EmbeddedEventLoop()
         let stream = PSQLRowStream(
@@ -294,20 +294,20 @@ final class PostgresRowSequenceTests: XCTestCase {
         let rowSequence = stream.asyncSequence()
         var rowIterator = rowSequence.makeAsyncIterator()
 
-        XCTAssertEqual(dataSource.requestCount, 0)
+        #expect(dataSource.requestCount == 0)
         _ = try await rowIterator.next() // new buffer size will be target -> don't ask for more
-        XCTAssertEqual(dataSource.requestCount, 0)
+        #expect(dataSource.requestCount == 0)
         _ = try await rowIterator.next() // new buffer will be (target - 1) -> ask for more
-        XCTAssertEqual(dataSource.requestCount, 1)
+        #expect(dataSource.requestCount == 1)
 
         // if the buffer gets new rows so that it has equal or more than target (the target size
         // should be halved), however shrinking is only allowed AFTER the first extra rows were
         // received.
         let addDataRows1: [DataRow] = [[ByteBuffer(integer: Int64(0))]]
         stream.receive(addDataRows1)
-        XCTAssertEqual(dataSource.requestCount, 1)
+        #expect(dataSource.requestCount == 1)
         _ = try await rowIterator.next() // new buffer will be (target - 1) -> ask for more
-        XCTAssertEqual(dataSource.requestCount, 2)
+        #expect(dataSource.requestCount == 2)
 
         // if the buffer gets new rows so that it has equal or more than target (the target size
         // should be halved)
@@ -316,30 +316,30 @@ final class PostgresRowSequenceTests: XCTestCase {
         _ = try await rowIterator.next() // new buffer will be (target - 1) -> ask for more
         for _ in 0..<(AdaptiveRowBuffer.defaultBufferTarget / 2) {
             _ = try await rowIterator.next() // Remove all rows until we are back at target
-            XCTAssertEqual(dataSource.requestCount, 2)
+            #expect(dataSource.requestCount == 2)
         }
 
         // if we remove another row we should trigger getting new rows.
         _ = try await rowIterator.next() // new buffer will be (target - 1) -> ask for more
-        XCTAssertEqual(dataSource.requestCount, 3)
+        #expect(dataSource.requestCount == 3)
 
         // remove all remaining rows... this will trigger a target size double
         for _ in 0..<(AdaptiveRowBuffer.defaultBufferTarget/2 - 1) {
             _ = try await rowIterator.next() // Remove all rows until we are back at target
-            XCTAssertEqual(dataSource.requestCount, 3)
+            #expect(dataSource.requestCount == 3)
         }
 
         let fillBufferDataRows: [DataRow] = (0..<AdaptiveRowBuffer.defaultBufferTarget + 1).map { [ByteBuffer(integer: Int64($0))] }
         stream.receive(fillBufferDataRows)
 
-        XCTAssertEqual(dataSource.requestCount, 3)
+        #expect(dataSource.requestCount == 3)
         _ = try await rowIterator.next() // new buffer size will be target -> don't ask for more
-        XCTAssertEqual(dataSource.requestCount, 3)
+        #expect(dataSource.requestCount == 3)
         _ = try await rowIterator.next() // new buffer will be (target - 1) -> ask for more
-        XCTAssertEqual(dataSource.requestCount, 4)
+        #expect(dataSource.requestCount == 4)
     }
 
-    func testAdaptiveRowShrinksToMin() async throws {
+    @Test func testAdaptiveRowShrinksToMin() async throws {
         let dataSource = MockRowDataSource()
         let embeddedEventLoop = EmbeddedEventLoop()
         let stream = PSQLRowStream(
@@ -362,9 +362,9 @@ final class PostgresRowSequenceTests: XCTestCase {
         var rowIterator = rowSequence.makeAsyncIterator()
 
         // shrinking the buffer is only allowed after the first extra rows were received
-        XCTAssertEqual(dataSource.requestCount, 0)
+        #expect(dataSource.requestCount == 0)
         _ = try await rowIterator.next()
-        XCTAssertEqual(dataSource.requestCount, 1)
+        #expect(dataSource.requestCount == 1)
 
         stream.receive([[ByteBuffer(integer: Int64(1))]])
 
@@ -373,10 +373,10 @@ final class PostgresRowSequenceTests: XCTestCase {
         while currentTarget > AdaptiveRowBuffer.defaultBufferMinimum {
             // the buffer is filled up to currentTarget at that point, if we remove one row and add
             // one row it should shrink
-            XCTAssertEqual(dataSource.requestCount, expectedRequestCount)
+            #expect(dataSource.requestCount == expectedRequestCount)
             _ = try await rowIterator.next()
             expectedRequestCount += 1
-            XCTAssertEqual(dataSource.requestCount, expectedRequestCount)
+            #expect(dataSource.requestCount == expectedRequestCount)
 
             stream.receive([[ByteBuffer(integer: Int64(1))], [ByteBuffer(integer: Int64(1))]])
             let newTarget = currentTarget / 2
@@ -385,16 +385,16 @@ final class PostgresRowSequenceTests: XCTestCase {
             // consume all messages that are to much.
             for _ in 0..<toDrop {
                 _ = try await rowIterator.next()
-                XCTAssertEqual(dataSource.requestCount, expectedRequestCount)
+                #expect(dataSource.requestCount == expectedRequestCount)
             }
 
             currentTarget = newTarget
         }
 
-        XCTAssertEqual(currentTarget, AdaptiveRowBuffer.defaultBufferMinimum)
+        #expect(currentTarget == AdaptiveRowBuffer.defaultBufferMinimum)
     }
 
-    func testStreamBufferAcceptsNewRowsEventhoughItDidntAskForIt() async throws {
+    @Test func testStreamBufferAcceptsNewRowsEventhoughItDidntAskForIt() async throws {
         let dataSource = MockRowDataSource()
         let embeddedEventLoop = EmbeddedEventLoop()
         let stream = PSQLRowStream(
@@ -415,9 +415,9 @@ final class PostgresRowSequenceTests: XCTestCase {
         let rowSequence = stream.asyncSequence()
         var rowIterator = rowSequence.makeAsyncIterator()
 
-        XCTAssertEqual(dataSource.requestCount, 0)
+        #expect(dataSource.requestCount == 0)
         _ = try await rowIterator.next()
-        XCTAssertEqual(dataSource.requestCount, 0)
+        #expect(dataSource.requestCount == 0)
 
         let finalDataRows: [DataRow] = (0..<messagePerChunk).map { [ByteBuffer(integer: Int64(messagePerChunk + $0))] }
         stream.receive(finalDataRows)
@@ -426,12 +426,12 @@ final class PostgresRowSequenceTests: XCTestCase {
         var counter = 1
         for _ in 0..<(2 * messagePerChunk - 1) {
             let row = try await rowIterator.next()
-            XCTAssertEqual(try row?.decode(Int.self), counter)
+            #expect(try row?.decode(Int.self) == counter)
             counter += 1
         }
 
         let emptyRow = try await rowIterator.next()
-        XCTAssertNil(emptyRow)
+        #expect(emptyRow == nil)
     }
 }