diff --git a/Package.swift b/Package.swift
index 63d8d2b..136d5cc 100644
--- a/Package.swift
+++ b/Package.swift
@@ -1,4 +1,4 @@
-// swift-tools-version: 5.9
+// swift-tools-version: 6.0
 // The swift-tools-version declares the minimum version of Swift required to build this package.
 
 import PackageDescription
@@ -11,9 +11,10 @@ let package = Package(
     products: [.library(name: "OpenAPILambda", targets: ["OpenAPILambda"])],
     dependencies: [
         .package(url: "https://github.com/apple/swift-openapi-runtime.git", from: "1.0.0"),
-        .package(url: "https://github.com/swift-server/swift-aws-lambda-runtime.git", from: "1.0.0-alpha.1"),
+        .package(url: "https://github.com/swift-server/swift-aws-lambda-runtime.git", from: "1.0.0-alpha.3"),
         .package(url: "https://github.com/swift-server/swift-aws-lambda-events.git", from: "0.3.0"),
         .package(url: "https://github.com/apple/swift-docc-plugin", from: "1.3.0"),
+        .package(url: "https://github.com/apple/swift-testing.git", branch: "main"),
     ],
     targets: [
         .target(
@@ -27,6 +28,12 @@ let package = Package(
             swiftSettings: [.enableExperimentalFeature("StrictConcurrency=complete")]
         ),
         // test targets
-        .testTarget(name: "OpenAPILambdaTests", dependencies: [.byName(name: "OpenAPILambda")]),
+        .testTarget(
+            name: "OpenAPILambdaTests",
+            dependencies: [
+                .byName(name: "OpenAPILambda"),
+                .product(name: "Testing", package: "swift-testing"),
+            ]
+        ),
     ]
 )
diff --git a/Package@swift-5.10.swift b/Package@swift-5.10.swift
new file mode 100644
index 0000000..c9d55cc
--- /dev/null
+++ b/Package@swift-5.10.swift
@@ -0,0 +1,37 @@
+// swift-tools-version: 5.10
+// The swift-tools-version declares the minimum version of Swift required to build this package.
+
+import PackageDescription
+
+let package = Package(
+    name: "swift-openapi-lambda",
+    platforms: [
+        .macOS(.v12), .iOS(.v15), .tvOS(.v15), .watchOS(.v8),
+    ],
+    products: [.library(name: "OpenAPILambda", targets: ["OpenAPILambda"])],
+    dependencies: [
+        .package(url: "https://github.com/apple/swift-openapi-runtime.git", from: "1.0.0"),
+        .package(url: "https://github.com/swift-server/swift-aws-lambda-runtime.git", from: "1.0.0-alpha.3"),
+        .package(url: "https://github.com/swift-server/swift-aws-lambda-events.git", from: "0.3.0"),
+        .package(url: "https://github.com/apple/swift-docc-plugin", from: "1.3.0"),
+    ],
+    targets: [
+        .target(
+            name: "OpenAPILambda",
+            dependencies: [
+                .product(name: "AWSLambdaRuntime", package: "swift-aws-lambda-runtime"),
+                .product(name: "AWSLambdaEvents", package: "swift-aws-lambda-events"),
+                .product(name: "OpenAPIRuntime", package: "swift-openapi-runtime"),
+            ],
+            path: "Sources",
+            swiftSettings: [.enableExperimentalFeature("StrictConcurrency=complete")]
+        ),
+        // test targets
+        .testTarget(
+            name: "OpenAPILambdaTests",
+            dependencies: [
+                .byName(name: "OpenAPILambda")
+            ]
+        ),
+    ]
+)
diff --git a/Package@swift-5.9.swift b/Package@swift-5.9.swift
new file mode 100644
index 0000000..265ea88
--- /dev/null
+++ b/Package@swift-5.9.swift
@@ -0,0 +1,37 @@
+// swift-tools-version: 5.9
+// The swift-tools-version declares the minimum version of Swift required to build this package.
+
+import PackageDescription
+
+let package = Package(
+    name: "swift-openapi-lambda",
+    platforms: [
+        .macOS(.v12), .iOS(.v15), .tvOS(.v15), .watchOS(.v8),
+    ],
+    products: [.library(name: "OpenAPILambda", targets: ["OpenAPILambda"])],
+    dependencies: [
+        .package(url: "https://github.com/apple/swift-openapi-runtime.git", from: "1.0.0"),
+        .package(url: "https://github.com/swift-server/swift-aws-lambda-runtime.git", from: "1.0.0-alpha.3"),
+        .package(url: "https://github.com/swift-server/swift-aws-lambda-events.git", from: "0.3.0"),
+        .package(url: "https://github.com/apple/swift-docc-plugin", from: "1.3.0"),
+    ],
+    targets: [
+        .target(
+            name: "OpenAPILambda",
+            dependencies: [
+                .product(name: "AWSLambdaRuntime", package: "swift-aws-lambda-runtime"),
+                .product(name: "AWSLambdaEvents", package: "swift-aws-lambda-events"),
+                .product(name: "OpenAPIRuntime", package: "swift-openapi-runtime"),
+            ],
+            path: "Sources",
+            swiftSettings: [.enableExperimentalFeature("StrictConcurrency=complete")]
+        ),
+        // test targets
+        .testTarget(
+            name: "OpenAPILambdaTests",
+            dependencies: [
+                .byName(name: "OpenAPILambda")
+            ]
+        ),
+    ]
+)
diff --git a/Tests/OpenAPILambdaTests/Router/RouterGraphTest.swift b/Tests/OpenAPILambdaTests/Router/RouterGraphTest.swift
index 4405261..beecae5 100644
--- a/Tests/OpenAPILambdaTests/Router/RouterGraphTest.swift
+++ b/Tests/OpenAPILambdaTests/Router/RouterGraphTest.swift
@@ -15,10 +15,14 @@
 import HTTPTypes
 import OpenAPIRuntime
 
-import XCTest
 @testable import OpenAPILambda
 
-final class RouterGraphTest: XCTestCase {
+// only run unit tests on Swift 6.x
+#if swift(>=6.0)
+import Testing
+
+struct RouterGraphTests {
+    @Test("Path with no parameters")
     func testPathNoParams() async throws {
         // given
         let strMethod = "GET"
@@ -29,41 +33,43 @@ final class RouterGraphTest: XCTestCase {
         let handler: OpenAPIHandler = { a, b, c in (HTTPResponse(status: .ok), HTTPBody(bodyString)) }
 
         // when
-        XCTAssertNoThrow(try graph.add(method: method, path: path, handler: handler))
+        #expect(throws: Never.self) { try graph.add(method: method, path: path, handler: handler) }
+
         // then
         var node: Node? = graph.root()
 
         // first node is GET
         node = node?.children[strMethod]
         if case .httpMethod(let retrievedMethod) = node?.value {
-            XCTAssert(retrievedMethod == method)
+            #expect(retrievedMethod == method)
         }
         else {
-            XCTFail("Not an HTTP method")
+            Issue.record("Not an HTTP method")
         }
         // all other nodes but last are path elements
         node = node?.children["element1"]
-        XCTAssertNotNil(node)
-        XCTAssert(node?.children.count == 1)
-        if case .pathElement(let element) = node?.value { XCTAssert(element == "element1") }
+        #expect(node != nil)
+        #expect(node?.children.count == 1)
+        if case .pathElement(let element) = node?.value { #expect(element == "element1") }
         node = node?.children["element2"]
-        XCTAssertNotNil(node)
-        XCTAssert(node?.children.count == 1)
-        if case .pathElement(let element) = node?.value { XCTAssert(element == "element2") }
+        #expect(node != nil)
+        #expect(node?.children.count == 1)
+        if case .pathElement(let element) = node?.value { #expect(element == "element2") }
 
         // last node is a handler
         node = node?.children["handler"]
         if case .handler(let retrievedHandler) = node?.value {
             let request = HTTPRequest(method: .init("GET")!, scheme: "https", authority: nil, path: "")
             let (response, body) = try await retrievedHandler(request, nil, ServerRequestMetadata())
-            XCTAssert(response.status == .ok)
+            #expect(response.status == .ok)
             let retrievedBody = try? await String(collecting: body ?? "", upTo: 10 * 1024 * 1024)
-            XCTAssert(retrievedBody == bodyString)
+            #expect(retrievedBody == bodyString)
         }
         else {
-            XCTFail("Not a handler")
+            Issue.record("Not a handler")
         }
     }
+    @Test("Path with one parameter")
     func testPathOneParams() async throws {
         // given
         let strMethod = "GET"
@@ -74,41 +80,42 @@ final class RouterGraphTest: XCTestCase {
         let handler: OpenAPIHandler = { a, b, c in (HTTPResponse(status: .ok), HTTPBody(bodyString)) }
 
         // when
-        XCTAssertNoThrow(try graph.add(method: method, path: path, handler: handler))
+        #expect(throws: Never.self) { try graph.add(method: method, path: path, handler: handler) }
         // then
         var node: Node? = graph.root()
 
         // first node is GET
         node = node?.children[strMethod]
         if case .httpMethod(let retrievedMethod) = node?.value {
-            XCTAssert(retrievedMethod == method)
+            #expect(retrievedMethod == method)
         }
         else {
-            XCTFail("Not an HTTP method")
+            Issue.record("Not an HTTP method")
         }
         // next node  is a  path elements
         node = node?.children["element1"]
-        XCTAssertNotNil(node)
-        XCTAssert(node?.children.count == 1)
-        if case .pathElement(let element) = node?.value { XCTAssert(element == "element1") }
+        #expect(node != nil)
+        #expect(node?.children.count == 1)
+        if case .pathElement(let element) = node?.value { #expect(element == "element1") }
         node = node?.children["param1"]
-        XCTAssertNotNil(node)
-        XCTAssert(node?.children.count == 1)
-        if case .pathParameter(let param) = node?.value { XCTAssert(param == "param1") }
+        #expect(node != nil)
+        #expect(node?.children.count == 1)
+        if case .pathParameter(let param) = node?.value { #expect(param == "param1") }
 
         // last node is a handler
         node = node?.children["handler"]
         if case .handler(let retrievedHandler) = node?.value {
             let request = HTTPRequest(method: .init("GET")!, scheme: "https", authority: nil, path: "")
             let (response, body) = try await retrievedHandler(request, nil, ServerRequestMetadata())
-            XCTAssert(response.status == .ok)
+            #expect(response.status == .ok)
             let retrievedBody = try? await String(collecting: body ?? "", upTo: 10 * 1024 * 1024)
-            XCTAssert(retrievedBody == bodyString)
+            #expect(retrievedBody == bodyString)
         }
         else {
-            XCTFail("Not a handler")
+            Issue.record("Not a handler")
         }
     }
+    @Test("Two GET paths")
     func testTwoGETPaths() async throws {
         // given
         let strMethod = "GET"
@@ -120,8 +127,8 @@ final class RouterGraphTest: XCTestCase {
         let handler: OpenAPIHandler = { a, b, c in (HTTPResponse(status: .ok), HTTPBody(bodyString)) }
 
         // when
-        XCTAssertNoThrow(try graph.add(method: method, path: path1, handler: handler))
-        XCTAssertNoThrow(try graph.add(method: method, path: path2, handler: handler))
+        #expect(throws: Never.self) { try graph.add(method: method, path: path1, handler: handler) }
+        #expect(throws: Never.self) { try graph.add(method: method, path: path2, handler: handler) }
 
         // then
         var node: Node? = graph.root()
@@ -129,49 +136,50 @@ final class RouterGraphTest: XCTestCase {
         // first node is GET
         node = node?.children[strMethod]
         if case .httpMethod(let retrievedMethod) = node?.value {
-            XCTAssert(retrievedMethod == method)
+            #expect(retrievedMethod == method)
         }
         else {
-            XCTFail("Not an HTTP method")
+            Issue.record("Not an HTTP method")
         }
         // next nodes are a path elements
         let node1 = node?.children["element1"]
-        XCTAssertNotNil(node1)
-        XCTAssert(node1?.children.count == 1)
-        if case .pathElement(let element) = node1?.value { XCTAssert(element == "element1") }
+        #expect(node1 != nil)
+        #expect(node1?.children.count == 1)
+        if case .pathElement(let element) = node1?.value { #expect(element == "element1") }
 
         let node2 = node?.children["element2"]
-        XCTAssertNotNil(node2)
-        XCTAssert(node2?.children.count == 1)
-        if case .pathElement(let element) = node2?.value { XCTAssert(element == "element2") }
+        #expect(node2 != nil)
+        #expect(node2?.children.count == 1)
+        if case .pathElement(let element) = node2?.value { #expect(element == "element2") }
 
         // last node is a handler
         let node3 = node1?.children["handler"]
-        XCTAssertNotNil(node3)
+        #expect(node3 != nil)
         if case .handler(let retrievedHandler) = node3?.value {
             let request = HTTPRequest(method: .init("GET")!, scheme: "https", authority: nil, path: "")
             let (response, body) = try await retrievedHandler(request, nil, ServerRequestMetadata())
-            XCTAssert(response.status == .ok)
+            #expect(response.status == .ok)
             let retrievedBody = try? await String(collecting: body ?? "", upTo: 10 * 1024 * 1024)
-            XCTAssert(retrievedBody == bodyString)
+            #expect(retrievedBody == bodyString)
         }
         else {
-            XCTFail("Not a handler")
+            Issue.record("Not a handler")
         }
 
         let node4 = node2?.children["handler"]
-        XCTAssertNotNil(node3)
+        try #require(node4 != nil)
         if case .handler(let retrievedHandler) = node4?.value {
             let request = HTTPRequest(method: .init("GET")!, scheme: "https", authority: nil, path: "")
             let (response, body) = try await retrievedHandler(request, nil, ServerRequestMetadata())
-            XCTAssert(response.status == .ok)
+            #expect(response.status == .ok)
             let retrievedBody = try? await String(collecting: body ?? "", upTo: 10 * 1024 * 1024)
-            XCTAssert(retrievedBody == bodyString)
+            #expect(retrievedBody == bodyString)
         }
         else {
-            XCTFail("Not a handler")
+            Issue.record("Not a handler")
         }
     }
+    @Test("Multiple HTTP methods")
     func testMultipleHTTPMethods() throws {
         // given
         let strMethod1 = "GET"
@@ -184,8 +192,8 @@ final class RouterGraphTest: XCTestCase {
         let handler: OpenAPIHandler = { a, b, c in (HTTPResponse(status: .ok), HTTPBody(bodyString)) }
 
         // when
-        XCTAssertNoThrow(try graph.add(method: method1, path: path, handler: handler))
-        XCTAssertNoThrow(try graph.add(method: method2, path: path, handler: handler))
+        #expect(throws: Never.self) { try graph.add(method: method1, path: path, handler: handler) }
+        #expect(throws: Never.self) { try graph.add(method: method2, path: path, handler: handler) }
 
         // then
         var node: Node? = graph.root()
@@ -193,29 +201,29 @@ final class RouterGraphTest: XCTestCase {
         // first node is GET
         let node1 = node?.children[strMethod1]
         if case .httpMethod(let retrievedMethod) = node1?.value {
-            XCTAssert(retrievedMethod == method1)
+            #expect(retrievedMethod == method1)
         }
         else {
-            XCTFail("Not an HTTP method")
+            Issue.record("Not an HTTP method")
         }
         // but there is also a POST node at level 1
         let node2 = node?.children[strMethod2]
         if case .httpMethod(let retrievedMethod) = node2?.value {
-            XCTAssert(retrievedMethod == method2)
+            #expect(retrievedMethod == method2)
         }
         else {
-            XCTFail("Not an HTTP method")
+            Issue.record("Not an HTTP method")
         }
 
         // all other nodes but last are path elements
         node = node1?.children["element1"]
-        XCTAssertNotNil(node1)
-        XCTAssert(node1?.children.count == 1)
-        if case .pathElement(let element) = node1?.value { XCTAssert(element == "element1") }
+        #expect(node1 != nil)
+        #expect(node1?.children.count == 1)
+        if case .pathElement(let element) = node1?.value { #expect(element == "element1") }
         node = node2?.children["element2"]
-        XCTAssertNotNil(node2)
-        XCTAssert(node2?.children.count == 1)
-        if case .pathElement(let element) = node2?.value { XCTAssert(element == "element2") }
+        #expect(node2 != nil)
+        #expect(node2?.children.count == 1)
+        if case .pathElement(let element) = node2?.value { #expect(element == "element2") }
     }
     //    func testDeepSearch() {
     //        // given
@@ -270,6 +278,7 @@ final class RouterGraphTest: XCTestCase {
     //        }
     //    }
 
+    @Test("No method path")
     func testNoMethodPath() {
         // given
         let strMethod = "GET"
@@ -279,8 +288,13 @@ final class RouterGraphTest: XCTestCase {
         // when
         // then
         let noExistingMethod = HTTPRequest.Method("POST")!
-        XCTAssertThrowsError(try graph.find(method: noExistingMethod, path: "/dummy"))
+        // #expect(throws: OpenAPILambdaRouterError.noRouteForMethod(noExistingMethod).self) {
+        #expect(throws: OpenAPILambdaRouterError.self) {
+            try graph.find(method: noExistingMethod, path: "/dummy")
+        }
     }
+
+    @Test("No two param children")
     func testNoTwoParamChilds() {
         let strMethod = "GET"
         let method = HTTPRequest.Method(strMethod)!
@@ -291,10 +305,15 @@ final class RouterGraphTest: XCTestCase {
         let handler: OpenAPIHandler = { a, b, c in (HTTPResponse(status: .ok), HTTPBody(bodyString)) }
 
         // when
-        XCTAssertNoThrow(try graph.add(method: method, path: path1, handler: handler))
+        #expect(throws: Never.self) { try graph.add(method: method, path: path1, handler: handler) }
+
         // then
-        XCTAssertThrowsError(try graph.add(method: method, path: path2, handler: handler))
+        #expect(throws: URIPathCollectionError.self) {
+            try graph.add(method: method, path: path2, handler: handler)
+        }
     }
+
+    @Test("Find handler 1")
     func testFindHandler1() throws {
         // given
         let strMethod = "GET"
@@ -303,11 +322,13 @@ final class RouterGraphTest: XCTestCase {
         let pathToTest = "/element1/element2"
 
         //when
-        XCTAssertNoThrow(try graph.find(method: method, path: pathToTest))
+        #expect(throws: Never.self) { try graph.find(method: method, path: pathToTest) }
         let (handler, metadata) = try graph.find(method: method, path: pathToTest)
-        XCTAssert(metadata.count == 0)
-        XCTAssertNotNil(handler)
+        #expect(metadata.count == 0)
+        #expect(handler != nil)
     }
+
+    @Test("Find handler 2")
     func testFindHandler2() throws {
         // given
         let strMethod = "GET"
@@ -316,12 +337,13 @@ final class RouterGraphTest: XCTestCase {
         let pathToTest = "/element3/value1/element4"
 
         //when
-        XCTAssertNoThrow(try graph.find(method: method, path: pathToTest))
+        #expect(throws: Never.self) { try graph.find(method: method, path: pathToTest) }
         let (handler, metadata) = try graph.find(method: method, path: pathToTest)
-        XCTAssert(metadata.count == 1)
-        XCTAssertNotNil(handler)
+        #expect(metadata.count == 1)
+        #expect(handler != nil)
     }
 
+    @Test("Find handler 3")
     func testFindHandler3() throws {
         // given
         let strMethod = "GET"
@@ -330,12 +352,13 @@ final class RouterGraphTest: XCTestCase {
         let pathToTest = "/element5/value1"
 
         //when
-        XCTAssertNoThrow(try graph.find(method: method, path: pathToTest))
+        #expect(throws: Never.self) { try graph.find(method: method, path: pathToTest) }
         let (handler, metadata) = try graph.find(method: method, path: pathToTest)
-        XCTAssert(metadata.count == 1)
-        XCTAssertNotNil(handler)
+        #expect(metadata.count == 1)
+        #expect(handler != nil)
     }
 
+    @Test("Find handler error 1")
     func testFindHandlerError1() throws {
         // given
         let strMethod = "GET"
@@ -344,9 +367,12 @@ final class RouterGraphTest: XCTestCase {
         let pathToTest = "/element6/value1"
 
         //when
-        XCTAssertThrowsError(try graph.find(method: method, path: pathToTest))
+        #expect(throws: OpenAPILambdaRouterError.self) {
+            try graph.find(method: method, path: pathToTest)
+        }
     }
 
+    @Test("Find handler error 2")
     func testFindHandlerError2() throws {
         // given
         let strMethod = "GET"
@@ -355,9 +381,12 @@ final class RouterGraphTest: XCTestCase {
         let pathToTest = "/element6"
 
         //when
-        XCTAssertThrowsError(try graph.find(method: method, path: pathToTest))
+        #expect(throws: OpenAPILambdaRouterError.self) {
+            try graph.find(method: method, path: pathToTest)
+        }
     }
 
+    @Test("Find handler error no HTTP method")
     func testFindHandlerErrorNoHttpMethod() throws {
         // given
         let strMethod = "GET"
@@ -366,7 +395,9 @@ final class RouterGraphTest: XCTestCase {
         let pathToTest = "/element1/element2"
 
         //when
-        XCTAssertThrowsError(try graph.find(method: HTTPRequest.Method(rawValue: "POST")!, path: pathToTest))
+        #expect(throws: OpenAPILambdaRouterError.self) {
+            try graph.find(method: HTTPRequest.Method(rawValue: "POST")!, path: pathToTest)
+        }
     }
 
     private func prepareGraph(for method: HTTPRequest.Method) -> URIPath {
@@ -376,8 +407,8 @@ final class RouterGraphTest: XCTestCase {
         let bodyString = "bodyString"
         let handler: OpenAPIHandler = { a, b, c in (HTTPResponse(status: .ok), HTTPBody(bodyString)) }
 
-        XCTAssertNoThrow(try graph.add(method: method, path: path1, handler: handler))
-        XCTAssertNoThrow(try graph.add(method: method, path: path2, handler: handler))
+        try! graph.add(method: method, path: path1, handler: handler)
+        try! graph.add(method: method, path: path2, handler: handler)
         return graph
     }
 
@@ -389,11 +420,12 @@ final class RouterGraphTest: XCTestCase {
         let bodyString = "bodyString"
         let handler: OpenAPIHandler = { a, b, c in (HTTPResponse(status: .ok), HTTPBody(bodyString)) }
 
-        XCTAssertNoThrow(try graph.add(method: method, path: path1, handler: handler))
-        XCTAssertNoThrow(try graph.add(method: method, path: path2, handler: handler))
-        XCTAssertNoThrow(try graph.add(method: method, path: path3, handler: handler))
+        try! graph.add(method: method, path: path1, handler: handler)
+        try! graph.add(method: method, path: path2, handler: handler)
+        try! graph.add(method: method, path: path3, handler: handler)
 
         return graph
     }
 
 }
+#endif
diff --git a/Tests/OpenAPILambdaTests/Router/RouterNodeTest.swift b/Tests/OpenAPILambdaTests/Router/RouterNodeTest.swift
index bd6a4c1..dee9a86 100644
--- a/Tests/OpenAPILambdaTests/Router/RouterNodeTest.swift
+++ b/Tests/OpenAPILambdaTests/Router/RouterNodeTest.swift
@@ -15,128 +15,150 @@
 import HTTPTypes
 import OpenAPIRuntime
 
-import XCTest
 @testable import OpenAPILambda
 
-final class RouterNodeTest: XCTestCase {
+// only run unit tests on Swift 6.x
+#if swift(>=6.0)
+import Testing
+
+struct RouterNodeTests {
+    @Test("First node is root")
     func testFirstNodeIsRoot() throws {
         // given
         let node = Node()
         // when
         guard case .root = node.value else {
-            XCTFail("Top level node is not root")
+            Issue.record("Top level node is not root")
             return
         }
         // then
         // succeed
     }
+
+    @Test("Add path element")
     func testAddPathElement() throws {
         // given
         let pathElement = "test"
         let node = Node()
         // when
-        XCTAssertNoThrow(try node.add(pathElement: pathElement))
+        #expect(throws: Never.self) { try node.add(pathElement: pathElement) }
         // then
-        XCTAssert(node.children.count == 1)
+        #expect(node.children.count == 1)
         let child = node.children[pathElement]
         if case .pathElement(let element) = child?.value {
-            XCTAssert(element == pathElement)
+            #expect(element == pathElement)
         }
         else {
-            XCTFail("Not a path element")
+            Issue.record("Not a path element")
         }
     }
+
+    @Test("Add HTTP method")
     func testAddHTTPMethod() throws {
         // given
         let methodStr = "GET"
         let method = HTTPRequest.Method(methodStr)!
         let node = Node()
         // when
-        XCTAssertNoThrow(try node.add(httpMethod: method))
+        #expect(throws: Never.self) { try node.add(httpMethod: method) }
         // then
-        XCTAssert(node.children.count == 1)
+        #expect(node.children.count == 1)
         let child = node.children[methodStr]
         if case .httpMethod(let retrievedMethod) = child?.value {
-            XCTAssert(retrievedMethod == method)
+            #expect(retrievedMethod == method)
         }
         else {
-            XCTFail("Not an HTTP method")
+            Issue.record("Not an HTTP method")
         }
     }
+
+    @Test("Add parameter")
     func testAddParameter() throws {
         // given
         let parameter = "parameter"
         let node = Node()
         // when
-        XCTAssertNoThrow(try node.add(parameter: "parameter"))
+        #expect(throws: Never.self) { try node.add(parameter: "parameter") }
         // then
-        XCTAssert(node.children.count == 1)
+        #expect(node.children.count == 1)
         let child = node.children[parameter]
         if case .pathParameter(let param) = child?.value {
-            XCTAssert(param == parameter)
+            #expect(param == parameter)
         }
         else {
-            XCTFail("Not a parameter")
+            Issue.record("Not a parameter")
         }
     }
+
+    @Test("Add handler")
     func testAddHandler() async throws {
         // given
         let bodyString = "bodyString"
         let handler: OpenAPIHandler = { a, b, c in (HTTPResponse(status: .ok), HTTPBody(bodyString)) }
         let node = Node()
         // when
-        XCTAssertNoThrow(try node.add(handler: handler))
+        #expect(throws: Never.self) { try node.add(handler: handler) }
         // then
-        XCTAssert(node.children.count == 1)
+        #expect(node.children.count == 1)
         let child = node.children["handler"]
         if case .handler(let retrievedHandler) = child?.value {
             let request = HTTPRequest(method: .init("GET")!, scheme: "https", authority: nil, path: "")
             let (response, body) = try await retrievedHandler(request, nil, ServerRequestMetadata())
-            XCTAssert(response.status == .ok)
+            #expect(response.status == .ok)
             let retrievedBody = try? await String(collecting: body ?? "", upTo: 10 * 1024 * 1024)
-            XCTAssert(retrievedBody == bodyString)
+            #expect(retrievedBody == bodyString)
         }
         else {
-            XCTFail("Not a handler")
+            Issue.record("Not a handler")
         }
     }
+
+    @Test("Cannot add node to handler")
     func testCanNotAddNodeToHandler() {
         // given
         let bodyString = "bodyString"
         let handler: OpenAPIHandler = { a, b, c in (HTTPResponse(status: .ok), HTTPBody(bodyString)) }
         let node = Node()
-        XCTAssertNoThrow(try node.add(handler: handler))
+        let _ = try? node.add(handler: handler)
         // when
         let child = node.children["handler"]
         // should throw an error
-        XCTAssertThrowsError(try child?.add(pathElement: "test"))
+        #expect(throws: URIPathCollectionError.self) {
+            try child?.add(pathElement: "test")
+        }
     }
+
+    @Test("Add duplicate node")
     func testAddDuplicateNode() throws {
         // given
         let pathElement = "test"
         let node = Node()
         // when
-        XCTAssertNoThrow(try node.add(pathElement: pathElement))
-        XCTAssertNoThrow(try node.add(pathElement: pathElement))
+        #expect(throws: Never.self) { try node.add(pathElement: pathElement) }
+        #expect(throws: Never.self) { try node.add(pathElement: pathElement) }
         // then
-        XCTAssert(node.children.count == 1)
+        #expect(node.children.count == 1)
     }
+
+    @Test("Returns new node")
     func testReturnsNewNode() throws {
         // given
         let pathElement = "test"
         let node = Node()
         // when
         let newNode = try? node.add(pathElement: pathElement)
-        XCTAssertNotNil(newNode)
+        #expect(newNode != nil)
         // then
-        XCTAssert(node.children.count == 1)
+        #expect(node.children.count == 1)
         if case .pathElement(let element) = newNode?.value {
-            XCTAssert(element == pathElement)
+            #expect(element == pathElement)
         }
         else {
-            XCTFail("Not a path element")
+            Issue.record("Not a path element")
         }
     }
+
+    @Test("Returns existing child")
     func testReturnsExistingChild() throws {
         // given
         let pathElement = "test"
@@ -144,18 +166,20 @@ final class RouterNodeTest: XCTestCase {
         // when
         let _ = try? node.add(pathElement: pathElement)
         let existingNode = try? node.add(pathElement: pathElement)
-        XCTAssertNotNil(existingNode)
+        #expect(existingNode != nil)
 
         // then
-        XCTAssert(node.children.count == 1)
-        XCTAssert(existingNode?.children.count == 0)
+        #expect(node.children.count == 1)
+        #expect(existingNode?.children.count == 0)
         if case .pathElement(let element) = existingNode?.value {
-            XCTAssert(element == pathElement)
+            #expect(element == pathElement)
         }
         else {
-            XCTFail("Not a path element")
+            Issue.record("Not a path element")
         }
     }
+
+    @Test("Retrieve param child exists")
     func testRetrieveParamChildExist() {
         // given
         let pathElement = "element1"
@@ -163,14 +187,15 @@ final class RouterNodeTest: XCTestCase {
 
         // when
         let pathNode = try? root.add(pathElement: pathElement)
-        XCTAssertNotNil(pathNode)
+        #expect(pathNode != nil)
         let _ = try? pathNode?.add(parameter: "param1")
 
         // then
         let paramNode = pathNode!.parameterChild()
-        XCTAssertNotNil(paramNode)
-
+        #expect(paramNode != nil)
     }
+
+    @Test("Retrieve param child does not exist")
     func testRetrieveParamChildNOTExist() {
         // given
         let pathElement = "element1"
@@ -178,12 +203,13 @@ final class RouterNodeTest: XCTestCase {
 
         // when
         let pathNode = try? root.add(pathElement: pathElement)
-        XCTAssertNotNil(pathNode)
+        #expect(pathNode != nil)
         let _ = try? pathNode?.add(pathElement: "element2")
 
         // then
         let paramNode = pathNode!.parameterChild()
-        XCTAssertNil(paramNode)
+        #expect(paramNode == nil)
     }
 
 }
+#endif