[Swift] Migrate to use Swift Testing (#9076)

* Migrating from Xctests to swift testing This migrates to the new Swift testing framework, which would allow us to always use the latest tech from swift moving forward. * Updates flag to make sure that Wasm testing works
2026-06-29 05:20:01 +00:00 · 2026-05-08 03:49:41 +02:00
parent e6bbb3d22e
commit 392165432a
21 changed files with 1054 additions and 883 deletions
--- a/tests/swift/Wasm.tests/Tests/FlatBuffers.Test.Swift.WasmTests/FlatBuffersMonsterWriterTests.swift
+++ b/tests/swift/Wasm.tests/Tests/FlatBuffers.Test.Swift.WasmTests/FlatBuffersMonsterWriterTests.swift
@@ -15,7 +15,7 @@
 */

 import Foundation
-import XCTest
+import Testing

@testable import FlatBuffers

@@ -24,8 +24,9 @@ typealias Monster = MyGame_Example_Monster
 typealias Vec3 = MyGame_Example_Vec3
 typealias Stat = MyGame_Example_Stat

-class FlatBuffersMonsterWriterTests: XCTestCase {
+struct FlatBuffersMonsterWriterTests {

+  @Test
  func testData() {
    // swiftformat:disable all
    let data: [UInt8] = [
@@ -47,11 +48,12 @@ class FlatBuffersMonsterWriterTests: XCTestCase {
    readVerifiedMonster(fb: _data)
  }

+  @Test
  func testCreateMonster() {
    let bytes = createMonster(withPrefix: false)
    // swiftformat:disable all
-    XCTAssertEqual(
-      bytes.sizedByteArray,
+    #expect(
+      bytes.sizedByteArray ==
      [
        48, 0, 0, 0, 77, 79, 78, 83, 0, 0, 0, 0, 36, 0, 72, 0, 40, 0, 0, 0, 38, 0, 32, 0, 0, 0, 28,
        0, 0, 0, 27, 0, 20, 0, 16, 0, 12, 0, 4, 0, 0, 0, 0, 0, 0, 0, 11, 0, 36, 0, 0, 0, 164, 0, 0,
@@ -75,11 +77,12 @@ class FlatBuffersMonsterWriterTests: XCTestCase {
    readMonster(monster: monster)
  }

+  @Test
  func testCreateMonsterResizedBuffer() {
    let bytes = createMonster(withPrefix: false)
    // swiftformat:disable all
-    XCTAssertEqual(
-      bytes.sizedByteArray,
+    #expect(
+      bytes.sizedByteArray ==
      [
        48, 0, 0, 0, 77, 79, 78, 83, 0, 0, 0, 0, 36, 0, 72, 0, 40, 0, 0, 0, 38, 0, 32, 0, 0, 0, 28,
        0, 0, 0, 27, 0, 20, 0, 16, 0, 12, 0, 4, 0, 0, 0, 0, 0, 0, 0, 11, 0, 36, 0, 0, 0, 164, 0, 0,
@@ -98,11 +101,12 @@ class FlatBuffersMonsterWriterTests: XCTestCase {
    readVerifiedMonster(fb: bytes.sizedBuffer)
  }

+  @Test
  func testCreateMonsterPrefixed() {
    let bytes = createMonster(withPrefix: true)
    // swiftformat:disable all
-    XCTAssertEqual(
-      bytes.sizedByteArray,
+    #expect(
+      bytes.sizedByteArray ==
      [
        44, 1, 0, 0, 44, 0, 0, 0, 77, 79, 78, 83, 36, 0, 72, 0, 40, 0, 0, 0, 38, 0, 32, 0, 0, 0, 28,
        0, 0, 0, 27, 0, 20, 0, 16, 0, 12, 0, 4, 0, 0, 0, 0, 0, 0, 0, 11, 0, 36, 0, 0, 0, 164, 0, 0,
@@ -123,6 +127,7 @@ class FlatBuffersMonsterWriterTests: XCTestCase {
    readMonster(monster: getPrefixedSizeRoot(byteBuffer: &buffer))
  }

+  @Test
  func testCreateMonsterUsingCreateMonsterMethodWithNilPos() {
    var fbb = FlatBufferBuilder(initialSize: 1)
    let name = fbb.create(string: "Frodo")
@@ -132,10 +137,11 @@ class FlatBuffersMonsterWriterTests: XCTestCase {
    fbb.finish(offset: root)
    var buffer = fbb.sizedBuffer
    let newMonster: Monster = getRoot(byteBuffer: &buffer)
-    XCTAssertNil(newMonster.pos)
-    XCTAssertEqual(newMonster.name, "Frodo")
+    #expect(newMonster.pos == nil)
+    #expect(newMonster.name == "Frodo")
  }

+  @Test
  func testCreateMonsterUsingCreateMonsterMethodWithPosX() {
    var fbb = FlatBufferBuilder(initialSize: 1)
    let name = fbb.create(string: "Barney")
@@ -155,10 +161,11 @@ class FlatBuffersMonsterWriterTests: XCTestCase {

    var buffer = fbb.sizedBuffer
    let newMonster: Monster = getRoot(byteBuffer: &buffer)
-    XCTAssertEqual(newMonster.pos!.x, 10)
-    XCTAssertEqual(newMonster.name, "Barney")
+    #expect(newMonster.pos!.x == 10)
+    #expect(newMonster.name == "Barney")
  }

+  @Test
  func testReadMonsterFromUnsafePointerWithoutCopying() {
    // swiftformat:disable all
    var array: [UInt8] = [
@@ -190,6 +197,7 @@ class FlatBuffersMonsterWriterTests: XCTestCase {
    readObjectApi(monster: unpacked)
  }

+  @Test
  func testArrayOfBools() {
    let boolArray = [false, true, false, true, false, true, false]
    var fbb = FlatBufferBuilder(initialSize: 1)
@@ -205,37 +213,41 @@ class FlatBuffersMonsterWriterTests: XCTestCase {
    let monster: Monster = getRoot(byteBuffer: &buffer)
    let values = monster.testarrayofbools

-    XCTAssertEqual(boolArray.count, values.count)
+    #expect(boolArray.count == values.count)

    for (index, bool) in monster.testarrayofbools.enumerated() {
-      XCTAssertEqual(bool, boolArray[index])
+      #expect(bool == boolArray[index])
    }
  }

  func readVerifiedMonster(fb: ByteBuffer) {
    var byteBuffer = fb
-    XCTAssertNoThrow(
+    do {
      try readMonster(
        monster: getCheckedRoot(
-          byteBuffer: &byteBuffer) as MyGame_Example_Monster))
+          byteBuffer: &byteBuffer) as MyGame_Example_Monster)
+    } catch {
+      Issue.record(error)
+    }
  }

+  @Test(.bug("https://github.com/google/flatbuffers/issues/8133"))
  func testUnalignedRead() {
    // Aligned read
    let fbb = createMonster(withPrefix: false)
    let testAligned: () -> Bool = {
      var buffer = fbb.sizedBuffer
      var monster: Monster = getRoot(byteBuffer: &buffer)
-      self.readFlatbufferMonster(monster: &monster)
+      readFlatbufferMonster(monster: &monster)
      return true
    }
-    XCTAssertEqual(testAligned(), true)
+    #expect(testAligned() == true)
    let testUnaligned: () -> Bool = {
      var bytes: [UInt8] = [0x00]
      bytes.append(contentsOf: fbb.sizedByteArray)
      return bytes.withUnsafeMutableBytes { ptr in
        guard var baseAddress = ptr.baseAddress else {
-          XCTFail("Base pointer is not defined")
+          Issue.record("Base pointer is not defined")
          return false
        }
        baseAddress = baseAddress.advanced(by: 1)
@@ -244,13 +256,14 @@ class FlatBuffersMonsterWriterTests: XCTestCase {
          assumingMemoryBound: unlignedPtr,
          capacity: ptr.count - 1)
        var monster: Monster = getRoot(byteBuffer: &bytes)
-        self.readFlatbufferMonster(monster: &monster)
+        readFlatbufferMonster(monster: &monster)
        return true
      }
    }
-    XCTAssertEqual(testUnaligned(), true)
+    #expect(testUnaligned() == true)
  }

+  @Test
  func testReadingRemovedSizeUnalignedBuffer() {
    // Aligned read
    let fbb = createMonster(withPrefix: true)
@@ -259,7 +272,7 @@ class FlatBuffersMonsterWriterTests: XCTestCase {
      bytes.append(contentsOf: fbb.sizedByteArray)
      return bytes.withUnsafeMutableBytes { ptr in
        guard var baseAddress = ptr.baseAddress else {
-          XCTFail("Base pointer is not defined")
+          Issue.record("Base pointer is not defined")
          return false
        }
        baseAddress = baseAddress.advanced(by: 1)
@@ -269,13 +282,14 @@ class FlatBuffersMonsterWriterTests: XCTestCase {
          capacity: ptr.count - 1)
        var newBuf = FlatBuffersUtils.removeSizePrefix(bb: bytes)
        var monster: Monster = getRoot(byteBuffer: &newBuf)
-        self.readFlatbufferMonster(monster: &monster)
+        readFlatbufferMonster(monster: &monster)
        return true
      }
    }
-    XCTAssertEqual(testUnaligned(), true)
+    #expect(testUnaligned() == true)
  }

+  @Test
  func testForceRetainedObject() {
    let byteBuffer = {
      // swiftformat:disable all
@@ -381,95 +395,95 @@ class FlatBuffersMonsterWriterTests: XCTestCase {
    var fb = fb

    let monster: Monster = getRoot(byteBuffer: &fb)
-    XCTAssertFalse(monster.mutate(mana: 10))
-    XCTAssertEqual(monster.testarrayoftables[0].name, "Barney")
-    XCTAssertEqual(monster.testarrayoftables[1].name, "Frodo")
-    XCTAssertEqual(monster.testarrayoftables[2].name, "Wilma")
+    #expect(monster.mutate(mana: 10) == false)
+    #expect(monster.testarrayoftables[0].name == "Barney")
+    #expect(monster.testarrayoftables[1].name == "Frodo")
+    #expect(monster.testarrayoftables[2].name == "Wilma")

    // Example of searching for a table by the key
-    XCTAssertNotNil(monster.testarrayoftablesBy(key: "Frodo"))
-    XCTAssertNotNil(monster.testarrayoftablesBy(key: "Barney"))
-    XCTAssertNotNil(monster.testarrayoftablesBy(key: "Wilma"))
+    #expect(monster.testarrayoftablesBy(key: "Frodo") != nil)
+    #expect(monster.testarrayoftablesBy(key: "Barney") != nil)
+    #expect(monster.testarrayoftablesBy(key: "Wilma") != nil)

-    XCTAssertEqual(monster.testType, .monster)
+    #expect(monster.testType == .monster)

-    XCTAssertEqual(monster.mutate(inventory: 1, at: 0), true)
-    XCTAssertEqual(monster.mutate(inventory: 2, at: 1), true)
-    XCTAssertEqual(monster.mutate(inventory: 3, at: 2), true)
-    XCTAssertEqual(monster.mutate(inventory: 4, at: 3), true)
-    XCTAssertEqual(monster.mutate(inventory: 5, at: 4), true)
+    #expect(monster.mutate(inventory: 1, at: 0) == true)
+    #expect(monster.mutate(inventory: 2, at: 1) == true)
+    #expect(monster.mutate(inventory: 3, at: 2) == true)
+    #expect(monster.mutate(inventory: 4, at: 3) == true)
+    #expect(monster.mutate(inventory: 5, at: 4) == true)

    for i in 0..<monster.inventory.count {
-      XCTAssertEqual(monster.inventory[i], Byte(i + 1))
+      #expect(monster.inventory[i] == Byte(i + 1))
    }

-    XCTAssertEqual(monster.mutate(inventory: 0, at: 0), true)
-    XCTAssertEqual(monster.mutate(inventory: 1, at: 1), true)
-    XCTAssertEqual(monster.mutate(inventory: 2, at: 2), true)
-    XCTAssertEqual(monster.mutate(inventory: 3, at: 3), true)
-    XCTAssertEqual(monster.mutate(inventory: 4, at: 4), true)
+    #expect(monster.mutate(inventory: 0, at: 0) == true)
+    #expect(monster.mutate(inventory: 1, at: 1) == true)
+    #expect(monster.mutate(inventory: 2, at: 2) == true)
+    #expect(monster.mutate(inventory: 3, at: 3) == true)
+    #expect(monster.mutate(inventory: 4, at: 4) == true)

    let vec = monster.mutablePos
-    XCTAssertEqual(vec?.x, 1)
-    XCTAssertTrue(vec?.mutate(x: 55.0) ?? false)
-    XCTAssertTrue(vec?.mutate(test1: 55) ?? false)
-    XCTAssertEqual(vec?.x, 55.0)
-    XCTAssertEqual(vec?.test1, 55.0)
-    XCTAssertTrue(vec?.mutate(x: 1) ?? false)
-    XCTAssertEqual(vec?.x, 1)
-    XCTAssertTrue(vec?.mutate(test1: 3) ?? false)
+    #expect(vec?.x == 1)
+    #expect(vec?.mutate(x: 55.0) == true)
+    #expect(vec?.mutate(test1: 55) == true)
+    #expect(vec?.x == 55.0)
+    #expect(vec?.test1 == 55.0)
+    #expect(vec?.mutate(x: 1) == true)
+    #expect(vec?.x == 1)
+    #expect(vec?.mutate(test1: 3) == true)

    let mutableTest4 = monster.mutableTest4
    let orignalValues = mutableTest4[0].a
-    XCTAssertEqual(mutableTest4[0].mutate(a: 100), true)
-    XCTAssertNotEqual(monster.test4[0].a, orignalValues)
-    XCTAssertEqual(monster.test4[0].a, 100)
-    XCTAssertEqual(mutableTest4[0].mutate(a: orignalValues), true)
+    #expect(mutableTest4[0].mutate(a: 100) == true)
+    #expect(monster.test4[0].a != orignalValues)
+    #expect(monster.test4[0].a == 100)
+    #expect(mutableTest4[0].mutate(a: orignalValues) == true)
  }

  func readFlatbufferMonster(monster: inout MyGame_Example_Monster) {
-    XCTAssertEqual(monster.hp, 80)
-    XCTAssertEqual(monster.mana, 150)
-    XCTAssertEqual(monster.name, "MyMonster")
+    #expect(monster.hp == 80)
+    #expect(monster.mana == 150)
+    #expect(monster.name == "MyMonster")
    let pos = monster.pos
-    XCTAssertEqual(pos?.x, 1)
-    XCTAssertEqual(pos?.y, 2)
-    XCTAssertEqual(pos?.z, 3)
-    XCTAssertEqual(pos?.test1, 3)
-    XCTAssertEqual(pos?.test2, .green)
+    #expect(pos?.x == 1)
+    #expect(pos?.y == 2)
+    #expect(pos?.z == 3)
+    #expect(pos?.test1 == 3)
+    #expect(pos?.test2 == .green)
    let test = pos?.test3
-    XCTAssertEqual(test?.a, 5)
-    XCTAssertEqual(test?.b, 6)
-    XCTAssertEqual(monster.testType, .monster)
+    #expect(test?.a == 5)
+    #expect(test?.b == 6)
+    #expect(monster.testType == .monster)
    let monster2 = monster.test(type: Monster.self)
-    XCTAssertEqual(monster2?.name, "Fred")
+    #expect(monster2?.name == "Fred")

-    XCTAssertEqual(monster.mutate(mana: 10), false)
+    #expect(monster.mutate(mana: 10) == false)

-    XCTAssertEqual(monster.mana, 150)
-    XCTAssertEqual(monster.inventory.count, 5)
+    #expect(monster.mana == 150)
+    #expect(monster.inventory.count == 5)
    var sum: Byte = 0
    for inventory in monster.inventory {
      sum += inventory
    }
-    XCTAssertEqual(sum, 10)
+    #expect(sum == 10)

    monster.withUnsafePointerToInventory { ptr, count in
      var sum: UInt8 = 0
      for pointee in ptr.startIndex..<ptr.endIndex {
        sum += ptr[pointee]
      }
-      XCTAssertEqual(sum, 10)
+      #expect(sum == 10)
    }

-    XCTAssertEqual(monster.test4.count, 2)
+    #expect(monster.test4.count == 2)

    let test4 = monster.test4
    var sum0 = 0
    for test0 in test4 {
      sum0 += Int(test0.a) + Int(test0.b)
    }
-    XCTAssertEqual(sum0, 100)
+    #expect(sum0 == 100)

    monster.withUnsafePointerToTest4 { ptr, count in
      guard let ptr = ptr.baseAddress else { return }
@@ -485,7 +499,7 @@ class FlatBuffersMonsterWriterTests: XCTestCase {
        pointerSum += Int(bindedMemory[pointee].a) +
          Int(bindedMemory[pointee].b)
      }
-      XCTAssertEqual(pointerSum, 100)
+      #expect(pointerSum == 100)
    }

    let mutableTest4 = monster.mutableTest4
@@ -493,87 +507,84 @@ class FlatBuffersMonsterWriterTests: XCTestCase {
    for test0 in mutableTest4 {
      sum2 += Int(test0.a) + Int(test0.b)
    }
-    XCTAssertEqual(sum2, 100)
+    #expect(sum2 == 100)

    let stringArray = monster.testarrayofstring
-    XCTAssertEqual(stringArray.count, 2)
-    XCTAssertEqual(stringArray[0], "test1")
-    XCTAssertEqual(stringArray[1], "test2")
-    XCTAssertEqual(monster.testbool, true)
+    #expect(stringArray.count == 2)
+    #expect(stringArray[0] == "test1")
+    #expect(stringArray[1] == "test2")
+    #expect(monster.testbool == true)

    let array = monster.nameSegmentArray
-    XCTAssertEqual(String(bytes: array ?? [], encoding: .utf8), "MyMonster")
+    #expect(String(bytes: array ?? [], encoding: .utf8) == "MyMonster")

    if 0 == monster.testarrayofbools.count {
-      XCTAssertEqual(monster.testarrayofbools.isEmpty, true)
+      #expect(monster.testarrayofbools.isEmpty == true)
    } else {
-      XCTAssertEqual(monster.testarrayofbools.isEmpty, false)
+      #expect(monster.testarrayofbools.isEmpty == false)
    }
  }

  func readObjectApi(monster: MyGame_Example_MonsterT) {
-    XCTAssertEqual(monster.hp, 80)
-    XCTAssertEqual(monster.mana, 150)
-    XCTAssertEqual(monster.name, "MyMonster")
+    #expect(monster.hp == 80)
+    #expect(monster.mana == 150)
+    #expect(monster.name == "MyMonster")
    let pos = monster.pos
-    XCTAssertEqual(pos?.x, 1)
-    XCTAssertEqual(pos?.y, 2)
-    XCTAssertEqual(pos?.z, 3)
-    XCTAssertEqual(pos?.test1, 3)
-    XCTAssertEqual(pos?.test2, .green)
+    #expect(pos?.x == 1)
+    #expect(pos?.y == 2)
+    #expect(pos?.z == 3)
+    #expect(pos?.test1 == 3)
+    #expect(pos?.test2 == .green)
    let test = pos?.test3
-    XCTAssertEqual(test?.a, 5)
-    XCTAssertEqual(test?.b, 6)
+    #expect(test?.a == 5)
+    #expect(test?.b == 6)
    let monster2 = monster.test?.value as? MyGame_Example_MonsterT
-    XCTAssertEqual(monster2?.name, "Fred")
-    XCTAssertEqual(monster.mana, 150)
+    #expect(monster2?.name == "Fred")
+    #expect(monster.mana == 150)
    monster.mana = 10
-    XCTAssertEqual(monster.mana, 10)
+    #expect(monster.mana == 10)
    monster.mana = 150
-    XCTAssertEqual(monster.mana, 150)
+    #expect(monster.mana == 150)

-    XCTAssertEqual(monster.inventory.count, 5)
+    #expect(monster.inventory.count == 5)
    var sum: Byte = 0
    for i in monster.inventory {
      sum += i
    }
-    XCTAssertEqual(sum, 10)
-    XCTAssertEqual(monster.test4.count, 2)
+    #expect(sum == 10)
+    #expect(monster.test4.count == 2)
    var sum0 = 0
    for test in monster.test4 {
      sum0 += Int(test.a) + Int(test.b)
    }
-    XCTAssertEqual(sum0, 100)
-    XCTAssertEqual(monster.testbool, true)
+    #expect(sum0 == 100)
+    #expect(monster.testbool == true)
  }

-  func testEncoding() {
+  @Test
+  func testEncoding() throws {
    let fbb = createMonster(withPrefix: false)
    var sizedBuffer = fbb.sizedBuffer
-    do {
-      struct Test: Decodable {
-        struct Pos: Decodable {
-          let x, y, z: Int
-        }
-        let hp: Int
-        let inventory: [UInt8]
-        let name: String
-        let pos: Pos
+    struct Test: Decodable {
+      struct Pos: Decodable {
+        let x, y, z: Int
      }
-      let reader: Monster = try getCheckedRoot(byteBuffer: &sizedBuffer)
-      let encoder = JSONEncoder()
-      encoder.keyEncodingStrategy = .convertToSnakeCase
-      let data = try encoder.encode(reader)
-      let decoder = JSONDecoder()
-      decoder.keyDecodingStrategy = .convertFromSnakeCase
-      let value = try decoder.decode(Test.self, from: data)
-      XCTAssertEqual(value.name, "MyMonster")
-      XCTAssertEqual(value.pos.x, 1)
-      XCTAssertEqual(value.pos.y, 2)
-      XCTAssertEqual(value.pos.z, 3)
-    } catch {
-      XCTFail(error.localizedDescription)
+      let hp: Int
+      let inventory: [UInt8]
+      let name: String
+      let pos: Pos
    }
+    let reader: Monster = try getCheckedRoot(byteBuffer: &sizedBuffer)
+    let encoder = JSONEncoder()
+    encoder.keyEncodingStrategy = .convertToSnakeCase
+    let data = try encoder.encode(reader)
+    let decoder = JSONDecoder()
+    decoder.keyDecodingStrategy = .convertFromSnakeCase
+    let value = try decoder.decode(Test.self, from: data)
+    #expect(value.name == "MyMonster")
+    #expect(value.pos.x == 1)
+    #expect(value.pos.y == 2)
+    #expect(value.pos.z == 3)
  }

  var jsonData: String {
--- a/tests/swift/Wasm.tests/Tests/FlexBuffers.Test.Swift.WasmTests/FlexBuffersJSONTests.swift
+++ b/tests/swift/Wasm.tests/Tests/FlexBuffers.Test.Swift.WasmTests/FlexBuffersJSONTests.swift
@@ -16,17 +16,19 @@

 import Common
 import FlexBuffers
-import XCTest
+import Foundation
+import Testing

-final class FlexBuffersJSONTests: XCTestCase {
+struct FlexBuffersJSONTests {
+  @Test
  func testEncodingJSON() throws {
    let buf: ByteBuffer = createProperBuffer().sizedByteBuffer
    let reference = try getRoot(buffer: buf)!

    let json = reference.jsonString()
    // swiftformat:disable all
-    XCTAssertEqual(
-      json,
+    #expect(
+      json ==
      "{\"bar\": [1, 2, 3], \"bar3\": [1, 2, 3], \"bool\": true, \"bools\": [true, false, true, false], \"foo\": 100.0, \"mymap\": {\"foo\": \"Fred\"}, \"vec\": [-100, \"Fred\", 4.0, \"M\", false, 4.0]}"
    )
    // swiftformat:enable all
@@ -37,15 +39,15 @@ final class FlexBuffersJSONTests: XCTestCase {
        with: data,
        options: []) as! [String: Any]

-    XCTAssertEqual(decodedData["bar"] as! [Int], [1, 2, 3])
-    XCTAssertEqual(decodedData["bar3"] as! [Int], [1, 2, 3])
+    #expect(decodedData["bar"] as! [Int] == [1, 2, 3])
+    #expect(decodedData["bar3"] as! [Int] == [1, 2, 3])

    let vec: [Any] = decodedData["vec"] as! [Any]
-    XCTAssertEqual(vec[0] as! Int, -100)
-    XCTAssertEqual(vec[1] as! String, "Fred")
-    XCTAssertEqual(vec[2] as! Double, 4.0)
-    XCTAssertEqual(vec[3] as! String, "M")
-    XCTAssertEqual(vec[4] as! Bool, false)
-    XCTAssertEqual(vec[5] as! Double, 4.0)
+    #expect(vec[0] as! Int == -100)
+    #expect(vec[1] as! String == "Fred")
+    #expect(vec[2] as! Double == 4.0)
+    #expect(vec[3] as! String == "M")
+    #expect(vec[4] as! Bool == false)
+    #expect(vec[5] as! Double == 4.0)
  }
 }
--- a/tests/swift/Wasm.tests/Tests/FlexBuffers.Test.Swift.WasmTests/FlexBuffersReaderTests.swift
+++ b/tests/swift/Wasm.tests/Tests/FlexBuffers.Test.Swift.WasmTests/FlexBuffersReaderTests.swift
@@ -15,22 +15,26 @@
 */

 import Common
-import XCTest
+import Foundation
+import Testing

@testable import FlexBuffers

-final class FlexBuffersReaderTests: XCTestCase {
+struct FlexBuffersReaderTests {

+  @Test
  func testReadingProperBuffer() throws {
    let buf: ByteBuffer = createProperBuffer().byteBuffer
    try validate(buffer: buf)
  }

+  @Test
  func testReadingSizedBuffer() throws {
    let buf: ByteBuffer = createSizedBuffer()
    try validate(buffer: buf)
  }

+  @Test(.bug("https://github.com/google/flatbuffers/issues/8642"))
  func testReset() throws {
    var fbx = FlexBuffersWriter(
      initialSize: 8,
@@ -38,87 +42,87 @@ final class FlexBuffersReaderTests: XCTestCase {
    write(fbx: &fbx)

    try validate(buffer: ByteBuffer(bytes: fbx.sizedByteArray))
-    XCTAssertEqual(fbx.capacity, 512)
+    #expect(fbx.capacity == 512)
    fbx.reset()
-    XCTAssertEqual(fbx.writerIndex, 0)
-    XCTAssertEqual(fbx.capacity, 8)
+    #expect(fbx.writerIndex == 0)
+    #expect(fbx.capacity == 8)

    write(fbx: &fbx)
    try validate(buffer: ByteBuffer(bytes: fbx.sizedByteArray))
    fbx.reset(keepingCapacity: true)
-    XCTAssertEqual(fbx.writerIndex, 0)
-    XCTAssertEqual(fbx.capacity, 512)
+    #expect(fbx.writerIndex == 0)
+    #expect(fbx.capacity == 512)

    write(fbx: &fbx)
    try validate(buffer: ByteBuffer(bytes: fbx.sizedByteArray))
-    XCTAssertEqual(fbx.capacity, 512)
+    #expect(fbx.capacity == 512)
  }

  private func validate(buffer buf: ByteBuffer) throws {
    let reference = try getRoot(buffer: buf)!
-    XCTAssertEqual(reference.type, .map)
+    #expect(reference.type == .map)
    let map = reference.map!
-    XCTAssertEqual(map.count, 7)
+    #expect(map.count == 7)
    let vecRef = map["vec"]!
-    XCTAssertEqual(vecRef.type, .vector)
+    #expect(vecRef.type == .vector)
    let vec = vecRef.vector!
-    XCTAssertEqual(vec.count, 6)
-    XCTAssertEqual(vec[0]?.type, .int)
-    XCTAssertEqual(vec[0]?.int, -100)
-    XCTAssertEqual(vec[1]?.type, .string)
-    XCTAssertEqual(vec[1]?.cString, "Fred")
-    XCTAssertNil(vec[1]?.int)
-    XCTAssertEqual(vec[2]?.double, 4.0)
-    XCTAssertTrue(vec[3]?.type == .blob)
+    #expect(vec.count == 6)
+    #expect(vec[0]?.type == .int)
+    #expect(vec[0]?.int == -100)
+    #expect(vec[1]?.type == .string)
+    #expect(vec[1]?.cString == "Fred")
+    #expect(vec[1]?.int == nil)
+    #expect(vec[2]?.double == 4.0)
+    #expect(vec[3]?.type == .blob)

    let blob = vec[3]!.blob { pointer in
      Array(pointer)
    }

-    XCTAssertEqual(blob?.count, 1)
-    XCTAssertEqual(blob?[0], 77)
-    XCTAssertEqual(vec[4]?.type, .bool)
-    XCTAssertEqual(vec[4]?.bool, false)
-    XCTAssertEqual(vec[5]?.double, 4.0)  // Shared with vec[2]
+    #expect(blob?.count == 1)
+    #expect(blob?[0] == 77)
+    #expect(vec[4]?.type == .bool)
+    #expect(vec[4]?.bool == false)
+    #expect(vec[5]?.double == 4.0)  // Shared with vec[2]

    let barVec = map["bar"]!.typedVector!
-    XCTAssertEqual(barVec.count, 3)
-    XCTAssertEqual(barVec[2]?.int, 3)
-    XCTAssertEqual(barVec[2]?.asInt(), UInt8(3))
+    #expect(barVec.count == 3)
+    #expect(barVec[2]?.int == 3)
+    #expect(barVec[2]?.asInt() == UInt8(3))

    let fixedVec = map["bar3"]!.fixedTypedVector!
-    XCTAssertEqual(fixedVec.count, 3)
-    XCTAssertEqual(fixedVec[2]?.int, 3)
-    XCTAssertEqual(fixedVec[2]?.asInt(), UInt8(3))
-    XCTAssertEqual(map["bool"]?.bool, true)
+    #expect(fixedVec.count == 3)
+    #expect(fixedVec[2]?.int == 3)
+    #expect(fixedVec[2]?.asInt() == UInt8(3))
+    #expect(map["bool"]?.bool == true)

    let boolsVector = map["bools"]!.typedVector!
-    XCTAssertEqual(boolsVector.type, .bool)
-    XCTAssertEqual(boolsVector[0]?.bool, true)
-    XCTAssertEqual(boolsVector[1]?.bool, false)
+    #expect(boolsVector.type == .bool)
+    #expect(boolsVector[0]?.bool == true)
+    #expect(boolsVector[1]?.bool == false)

    let bools = [true, false, true, false]
    boolsVector.withUnsafeRawBufferPointer { buff in
      for i in 0..<boolsVector.count {
-        XCTAssertEqual(buff.load(fromByteOffset: i, as: Bool.self), bools[i])
+        #expect(buff.load(fromByteOffset: i, as: Bool.self) == bools[i])
      }
    }
-    XCTAssertEqual(map["foo"]?.double, 100)
-    XCTAssertNil(map["unknown"])
+    #expect(map["foo"]?.double == 100)
+    #expect(map["unknown"] == nil)
    let mymap = map["mymap"]?.map

    // Check if both addresses used are the same for keys and strings
-    XCTAssertEqual(mymap?.keys[0]?.cString, map.keys[4]?.cString)
+    #expect(mymap?.keys[0]?.cString == map.keys[4]?.cString)
    map.keys[4]?.withUnsafeRawPointer { pointer in
      mymap?.keys[0]?.withUnsafeRawPointer { mymapPointer in
-        XCTAssertEqual(pointer, mymapPointer)
+        #expect(pointer == mymapPointer)
      }
    }

-    XCTAssertEqual(mymap?.values[0]?.cString, vec[1]?.cString)
+    #expect(mymap?.values[0]?.cString == vec[1]?.cString)
    vec[1]?.withUnsafeRawPointer { pointer in
      mymap?.values[0]?.withUnsafeRawPointer { mymapPointer in
-        XCTAssertEqual(pointer, mymapPointer)
+        #expect(pointer == mymapPointer)
      }
    }
  }
@@ -127,7 +131,7 @@ final class FlexBuffersReaderTests: XCTestCase {
    #if os(macOS)
    // Gets the current path of this test file then
    // strips out the nested directories.
-    let filePath = URL(filePath: #file)
+    let filePath = URL(filePath: #filePath)
      .deletingLastPathComponent()
      .deletingLastPathComponent()
      .deletingLastPathComponent()
--- a/tests/swift/Wasm.tests/Tests/FlexBuffers.Test.Swift.WasmTests/FlexBuffersStringTests.swift
+++ b/tests/swift/Wasm.tests/Tests/FlexBuffers.Test.Swift.WasmTests/FlexBuffersStringTests.swift
@@ -16,10 +16,12 @@

 import Common
 import FlexBuffers
-import XCTest
+import Foundation
+import Testing

-final class FlexBuffersStringTests: XCTestCase {
+struct FlexBuffersStringTests {

+  @Test
  func testEncodingUnicodeString() {
    let text = "プ画をみて✋"

@@ -38,6 +40,6 @@ final class FlexBuffersStringTests: XCTestCase {
      return String(data: data, encoding: .unicode)
    }

-    XCTAssertEqual(builtString, text)
+    #expect(builtString == text)
  }
 }
--- a/tests/swift/Wasm.tests/Tests/FlexBuffers.Test.Swift.WasmTests/FlexBuffersWriterTests.swift
+++ b/tests/swift/Wasm.tests/Tests/FlexBuffers.Test.Swift.WasmTests/FlexBuffersWriterTests.swift
@@ -16,9 +16,10 @@

 import Common
 import FlexBuffers
-import XCTest
+import Testing

-final class FlexBuffersWriterTests: XCTestCase {
+struct FlexBuffersWriterTests {
+  @Test
  func testDeallocation() {
    let buf: ByteBuffer = {
      var fbx = FlexBuffersWriter()
@@ -28,12 +29,13 @@ final class FlexBuffersWriterTests: XCTestCase {
    }()

    buf.withUnsafeBytes {
-      XCTAssertEqual(
-        Array($0),
-        [5, 72, 101, 108, 108, 111, 0, 6, 20, 1])
+      #expect(
+        Array($0) ==
+          [5, 72, 101, 108, 108, 111, 0, 6, 20, 1])
    }
  }

+  @Test
  func testAddingVectorOfScalars() {
    var fbx = FlexBuffersWriter()
    fbx.vector {
@@ -45,8 +47,8 @@ final class FlexBuffersWriterTests: XCTestCase {

    buf.withUnsafeBytes {
      // swiftformat:disable all
-      XCTAssertEqual(
-        Array($0),
+      #expect(
+        Array($0) ==
        [
          10, 0, 0, 0, 1, 0, 0, 0, 2, 0, 0, 0, 3, 0, 0, 0, 4, 0, 0, 0, 5, 0, 0, 0, 6, 0, 0, 0, 7, 0,
          0, 0, 8, 0, 0, 0, 9, 0, 0, 0, 20, 0, 0, 0, 1, 41, 46, 2, 40, 1,
@@ -55,6 +57,7 @@ final class FlexBuffersWriterTests: XCTestCase {
    }
  }

+  @Test
  func testAddingVectorOfUnsignedScalars() {
    var fbx = FlexBuffersWriter()
    fbx.vector {
@@ -66,8 +69,8 @@ final class FlexBuffersWriterTests: XCTestCase {

    buf.withUnsafeBytes {
      // swiftformat:disable all
-      XCTAssertEqual(
-        Array($0),
+      #expect(
+        Array($0) ==
        [
          10, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0,
          0, 0, 4, 0, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 0, 0, 0, 0, 6, 0, 0, 0, 0, 0, 0, 0, 7, 0, 0, 0,
@@ -78,6 +81,7 @@ final class FlexBuffersWriterTests: XCTestCase {
    }
  }

+  @Test
  func testAddingVectorOfBools() {
    var fbx = FlexBuffersWriter()
    fbx.vector {
@@ -89,13 +93,14 @@ final class FlexBuffersWriterTests: XCTestCase {

    buf.withUnsafeBytes {
      // swiftformat:disable all
-      XCTAssertEqual(
-        Array($0),
+      #expect(
+        Array($0) ==
        [4, 1, 0, 1, 0, 1, 5, 144, 2, 40, 1])
      // swiftformat:enable all
    }
  }

+  @Test
  func testSortingWithinMap() {
    var fbx = FlexBuffersWriter()
    fbx.map {
@@ -106,8 +111,8 @@ final class FlexBuffersWriterTests: XCTestCase {
    let buf: ByteBuffer = fbx.sizedByteBuffer
    buf.withUnsafeBytes {
      // swiftformat:disable all
-      XCTAssertEqual(
-        Array($0),
+      #expect(
+        Array($0) ==
        [
          98, 111, 111, 108, 50, 0, 98, 111, 111, 108, 49, 0, 2, 7, 14, 2, 1, 2, 1, 0, 104, 104, 4,
          36, 1,
@@ -117,6 +122,7 @@ final class FlexBuffersWriterTests: XCTestCase {
    }
  }

+  @Test
  func testSharingKeyWithinMap() {
    var fbx = FlexBuffersWriter(initialSize: 1000, flags: .shareKeysAndStrings)
    fbx.map {
@@ -128,8 +134,8 @@ final class FlexBuffersWriterTests: XCTestCase {
    let buf: ByteBuffer = fbx.sizedByteBuffer
    buf.withUnsafeBytes {
      // swiftformat:disable all
-      XCTAssertEqual(
-        Array($0),
+      #expect(
+        Array($0) ==
        [
          119, 101, 108, 99, 111, 109, 101, 0, 7, 119, 101, 108, 99, 111, 109, 101, 0, 3, 18, 19,
          20, 3, 1, 3, 15, 16, 17, 20, 20, 20, 6, 36, 1,
@@ -139,19 +145,21 @@ final class FlexBuffersWriterTests: XCTestCase {
    }
  }

+  @Test
  func testNestingVectorInMap() {
    let buf: ByteBuffer = createSizedBuffer()

    buf.withUnsafeBytes {
      // swiftformat:disable all
-      XCTAssertEqual(
-        Array($0),
+      #expect(
+        Array($0) ==
        flexbufferGolden
      )
      // swiftformat:enable all
    }
  }

+  @Test
  func testAddingNil() {
    var fbx = FlexBuffersWriter(
      initialSize: 8,
@@ -165,14 +173,15 @@ final class FlexBuffersWriterTests: XCTestCase {
    let buf: ByteBuffer = fbx.sizedByteBuffer
    buf.withUnsafeBytes {
      // swiftformat:disable all
-      XCTAssertEqual(
-        Array($0),
+      #expect(
+        Array($0) ==
        [118, 0, 1, 3, 1, 1, 1, 0, 0, 2, 36, 1]
      )
      // swiftformat:enable all
    }
  }

+  @Test
  func testAddingManually() {
    var fbx = FlexBuffersWriter(
      initialSize: 8,
@@ -209,14 +218,15 @@ final class FlexBuffersWriterTests: XCTestCase {
    let buf: ByteBuffer = fbx.sizedByteBuffer
    buf.withUnsafeBytes {
      // swiftformat:disable all
-      XCTAssertEqual(
-        Array($0),
+      #expect(
+        Array($0) ==
        flexbufferGolden
      )
      // swiftformat:enable all
    }
  }

+  @Test
  func testEncodingAllTypes() {
    var fbx = FlexBuffersWriter()
    fbx.vector {
@@ -240,8 +250,8 @@ final class FlexBuffersWriterTests: XCTestCase {

    buf.withUnsafeBytes {
      // swiftformat:disable all
-      XCTAssertEqual(
-        Array($0),
+      #expect(
+        Array($0) ==
        allTypesGolden)
      // swiftformat:enable all
    }