From 358920684f129ba0d6c6867490762d221fdf8fb5 Mon Sep 17 00:00:00 2001 From: Mustii <26250654+mustiikhalil@users.noreply.github.com> Date: Sat, 14 Feb 2026 11:06:14 +0100 Subject: [PATCH 1/2] 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. And tests will always be fast --- .../Tests/Flatbuffers/ByteBufferTests.swift | 44 +- .../Flatbuffers/FlatBuffersArraysTests.swift | 148 ++++--- .../FlatBuffersMonsterWriterTests.swift | 282 ++++++------ .../Flatbuffers/FlatBuffersNanInfTests.swift | 94 ++-- .../Flatbuffers/FlatBuffersStructsTests.swift | 11 +- .../Tests/Flatbuffers/FlatBuffersTests.swift | 68 +-- .../Flatbuffers/FlatBuffersUnionTests.swift | 137 +++--- .../Flatbuffers/FlatBuffersVectorsTests.swift | 53 ++- .../Flatbuffers/FlatbuffersDoubleTests.swift | 10 +- .../Flatbuffers/FlatbuffersMoreDefaults.swift | 81 ++-- .../FlatbuffersVerifierTests.swift | 400 +++++++++++------- .../Flexbuffers/FlexBuffersJSONTests.swift | 26 +- .../Flexbuffers/FlexBuffersReaderTests.swift | 86 ++-- .../Flexbuffers/FlexBuffersStringTests.swift | 8 +- .../Flexbuffers/FlexBuffersWriterTests.swift | 56 ++- .../FlatBuffersMonsterWriterTests.swift | 261 ++++++------ .../FlexBuffersJSONTests.swift | 26 +- .../FlexBuffersReaderTests.swift | 88 ++-- .../FlexBuffersStringTests.swift | 8 +- .../FlexBuffersWriterTests.swift | 56 ++- 20 files changed, 1057 insertions(+), 886 deletions(-) diff --git a/tests/swift/Tests/Flatbuffers/ByteBufferTests.swift b/tests/swift/Tests/Flatbuffers/ByteBufferTests.swift index ce8f12811b..1fc1d3c85a 100644 --- a/tests/swift/Tests/Flatbuffers/ByteBufferTests.swift +++ b/tests/swift/Tests/Flatbuffers/ByteBufferTests.swift @@ -14,51 +14,58 @@ * limitations under the License. */ -import XCTest +import Foundation +import Testing @testable import FlatBuffers -final class ByteBufferTests: XCTestCase { +struct ByteBufferTests { + + @Test func testCopyingMemory() { let count = 100 let ptr = UnsafeMutableRawPointer.allocate(byteCount: count, alignment: 1) let byteBuffer = ByteBuffer(copyingMemoryBound: ptr, capacity: count) byteBuffer.withUnsafeBytes { memory in - XCTAssertNotEqual(memory.baseAddress, ptr) + #expect(memory.baseAddress! != ptr) } } + @Test func testSamePointer() { let count = 100 let ptr = UnsafeMutableRawPointer.allocate(byteCount: count, alignment: 1) let byteBuffer = ByteBuffer(assumingMemoryBound: ptr, capacity: count) byteBuffer.withUnsafeBytes { memory in - XCTAssertEqual(memory.baseAddress!, ptr) + #expect(memory.baseAddress! == ptr) } } + @Test func testSameDataPtr() { let count = 100 let ptr = Data(repeating: 0, count: count) let byteBuffer = ByteBuffer(data: ptr) byteBuffer.withUnsafeBytes { memory in ptr.withUnsafeBytes { ptr in - XCTAssertEqual(memory.baseAddress!, ptr.baseAddress!) + #expect(memory.baseAddress! == ptr.baseAddress!) } } } + @Test func testSameArrayPtr() { let count = 100 let ptr: [UInt8] = Array(repeating: 0, count: count) let byteBuffer = ByteBuffer(bytes: ptr) ptr.withUnsafeBytes { ptr in byteBuffer.withUnsafeBytes { memory in - XCTAssertEqual(memory.baseAddress, ptr.baseAddress) + #expect(memory.baseAddress == ptr.baseAddress) } } } + @Test func testReadingDoubleBuffer() { let count = 8 let array: [Double] = Array(repeating: 8.8, count: count) @@ -69,15 +76,16 @@ final class ByteBufferTests: XCTestCase { } let byteBuffer = ByteBuffer(bytes: bytes) byteBuffer.withUnsafePointerToSlice(index: 0, count: count) { ptr in - XCTAssertEqual(ptr.count, count) + #expect(ptr.count == count) bytes.withUnsafeBufferPointer { - XCTAssertEqual( - UnsafeRawPointer($0.baseAddress), - UnsafeRawPointer(ptr.baseAddress)) + #expect( + UnsafeRawPointer($0.baseAddress) == + UnsafeRawPointer(ptr.baseAddress)) } } } + @Test func testReadingNativeStructs() { let array = [ MyGame_Example_Vec3( @@ -111,11 +119,11 @@ final class ByteBufferTests: XCTestCase { let byteBuffer = ByteBuffer(bytes: bytes) byteBuffer .withUnsafePointerToSlice(index: 0, count: count) { bufferPointer in - XCTAssertEqual(bufferPointer.count, count) + #expect(bufferPointer.count == count) bytes.withUnsafeBufferPointer { ptr in - XCTAssertEqual( - UnsafeRawPointer(ptr.baseAddress), - UnsafeRawPointer(bufferPointer.baseAddress)) + #expect( + UnsafeRawPointer(ptr.baseAddress) == + UnsafeRawPointer(bufferPointer.baseAddress)) } } } @@ -126,11 +134,3 @@ private struct TestNativeStructs: NativeStruct { let y: Double let z: Int } - -extension MyGame_Example_Color: CaseIterable { - public static let allCases: [MyGame_Example_Color] = [ - .red, - .blue, - .green, - ] -} diff --git a/tests/swift/Tests/Flatbuffers/FlatBuffersArraysTests.swift b/tests/swift/Tests/Flatbuffers/FlatBuffersArraysTests.swift index 4b85c595d1..79b40ddb7e 100644 --- a/tests/swift/Tests/Flatbuffers/FlatBuffersArraysTests.swift +++ b/tests/swift/Tests/Flatbuffers/FlatBuffersArraysTests.swift @@ -16,19 +16,22 @@ #if compiler(>=6.2) -import XCTest +import Testing @testable import FlatBuffers -@available(macOS 26.0, iOS 26.0, watchOS 26.0, tvOS 26.0, *) -final class FlatBuffersArraysTests: XCTestCase { +struct FlatBuffersArraysTests { + @available(macOS 26.0, iOS 26.0, watchOS 26.0, tvOS 26.0, *) + @Test func testStructSizes() { - XCTAssertEqual(MemoryLayout.size, 32) - XCTAssertEqual(MemoryLayout.size, 160) - XCTAssertEqual(MemoryLayout.size, 2496) + #expect(MemoryLayout.size == 32) + #expect(MemoryLayout.size == 160) + #expect((MemoryLayout.size == 2496)) } + @available(macOS 26.0, iOS 26.0, watchOS 26.0, tvOS 26.0, *) + @Test func testGoldenData() { // swiftformat:disable all let data: [UInt8] = [ @@ -45,9 +48,11 @@ final class FlatBuffersArraysTests: XCTestCase { ] // swiftformat:enable all - XCTAssertEqual(data, createArrayTable()) + #expect(data == createArrayTable()) } + @available(macOS 26.0, iOS 26.0, watchOS 26.0, tvOS 26.0, *) + @Test func testData() throws { var buf = ByteBuffer(bytes: createArrayTable()) let table: MyGame_Example_ArrayTable = try getCheckedRoot( @@ -58,6 +63,8 @@ final class FlatBuffersArraysTests: XCTestCase { verifyNativeStruct(a: table.a) } + @available(macOS 26.0, iOS 26.0, watchOS 26.0, tvOS 26.0, *) + @Test func testObjectAPI() throws { var buf = ByteBuffer(bytes: createArrayTable()) let table: MyGame_Example_ArrayTable = try getCheckedRoot( @@ -66,105 +73,110 @@ final class FlatBuffersArraysTests: XCTestCase { verifyNativeStruct(a: table.unpack().a) } + @available(macOS 26.0, iOS 26.0, watchOS 26.0, tvOS 26.0, *) + @Test func testDefaults() { - XCTAssertEqual( - MyGame_Example_NestedStruct(), - MyGame_Example_NestedStruct( - a: [0, 0], - b: .a, - c: [0, 0], - d: [0, 0])) + #expect( + MyGame_Example_NestedStruct() == + MyGame_Example_NestedStruct( + a: [0, 0], + b: .a, + c: [0, 0], + d: [0, 0])) } + @available(macOS 26.0, iOS 26.0, watchOS 26.0, tvOS 26.0, *) func verifyNativeStruct(a: MyGame_Example_ArrayStruct?) { let a = a! - XCTAssertEqual(a.a, 12.34) - XCTAssertEqual(a.b.count, 15) + #expect(a.a == 12.34) + #expect(a.b.count == 15) var sum: Int32 = 0 for i in a.b.startIndex.. [UInt8] { var builder = FlatBufferBuilder(initialSize: 1024) diff --git a/tests/swift/Tests/Flatbuffers/FlatBuffersMonsterWriterTests.swift b/tests/swift/Tests/Flatbuffers/FlatBuffersMonsterWriterTests.swift index 63679f248e..567d16ac9f 100644 --- a/tests/swift/Tests/Flatbuffers/FlatBuffersMonsterWriterTests.swift +++ b/tests/swift/Tests/Flatbuffers/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 = Data([ @@ -47,6 +48,7 @@ class FlatBuffersMonsterWriterTests: XCTestCase { readVerifiedMonster(fb: _data) } + @Test func testReadFromOtherLanguages() { let path = { #if os(macOS) @@ -71,6 +73,7 @@ class FlatBuffersMonsterWriterTests: XCTestCase { readVerifiedMonster(fb: _data) } + @Test func testCreateMonsterData() { let bytes = createMonster(withPrefix: false) var buffer = ByteBuffer(data: bytes.data) @@ -80,30 +83,32 @@ class FlatBuffersMonsterWriterTests: XCTestCase { readMonster(monster: monster) } + @Test(.bug("https://github.com/google/flatbuffers/issues/8642")) func testCreateMonsterResetTests() { var builder = createMonster(withPrefix: false) var buffer = ByteBuffer(data: builder.data) let monster: MyGame_Example_Monster = getRoot(byteBuffer: &buffer) readMonster(monster: monster) builder.clear() - XCTAssertEqual(builder.capacity, 1) - XCTAssertEqual(builder.size, 0) + #expect(builder.capacity == 1) + #expect(builder.size == 0) write(fbb: &builder, prefix: false) var _buffer = ByteBuffer(data: builder.data) - XCTAssertEqual(_buffer.capacity, 304) + #expect(_buffer.capacity == 304) let _monster: MyGame_Example_Monster = getRoot(byteBuffer: &_buffer) readMonster(monster: _monster) builder.clear(keepingCapacity: true) - XCTAssertEqual(builder.capacity, 512) - XCTAssertEqual(builder.size, 0) + #expect(builder.capacity == 512) + #expect(builder.size == 0) } + @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, @@ -127,11 +132,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, @@ -150,11 +156,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, @@ -175,6 +182,7 @@ class FlatBuffersMonsterWriterTests: XCTestCase { readMonster(monster: getPrefixedSizeRoot(byteBuffer: &buffer)) } + @Test func testCreateMonsterUsingCreateMonsterMethodWithNilPos() { var fbb = FlatBufferBuilder(initialSize: 1) let name = fbb.create(string: "Frodo") @@ -184,10 +192,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") @@ -207,10 +216,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] = [ @@ -242,6 +252,7 @@ class FlatBuffersMonsterWriterTests: XCTestCase { readObjectApi(monster: unpacked) } + @Test func testArrayOfBools() { let boolArray = [false, true, false, true, false, true, false] var fbb = FlatBufferBuilder(initialSize: 1) @@ -257,37 +268,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) @@ -296,13 +311,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) @@ -311,7 +327,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) @@ -321,13 +337,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 testCreateMessage() { let fbb = createMonster(withPrefix: false) let byteBuffer = fbb.buffer @@ -335,7 +352,7 @@ class FlatBuffersMonsterWriterTests: XCTestCase { firstMessage.withUnsafeReadableBytes { ptr in var bytes = ByteBuffer(contiguousBytes: ptr, count: ptr.count) var monster: Monster = getRoot(byteBuffer: &bytes) - self.readFlatbufferMonster(monster: &monster) + readFlatbufferMonster(monster: &monster) } let secondByteBuffer = fbb.sizedBuffer @@ -343,10 +360,11 @@ class FlatBuffersMonsterWriterTests: XCTestCase { secondMessage.withUnsafeReadableBytes { ptr in var bytes = ByteBuffer(contiguousBytes: ptr, count: ptr.count) var monster: Monster = getRoot(byteBuffer: &bytes) - self.readFlatbufferMonster(monster: &monster) + readFlatbufferMonster(monster: &monster) } } + @Test func testForceRetainedObject() { let byteBuffer = { // swiftformat:disable all @@ -452,95 +470,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.. FlatBufferBuilder { - var fbb = FlatBufferBuilder() - let msg = Swift_Tests_NanInfTable.createNanInfTable( - &fbb, - valueNan: .nan, - valueInf: .infinity, - valueNinf: -.infinity, - value: 100.0) - fbb.finish(offset: msg) - return fbb - } +struct FlatBuffersNanInfTests { + @Test func testInfNanBinary() { let fbb = createTestTable() let data = fbb.sizedByteArray var buffer = ByteBuffer(bytes: data) let table: Swift_Tests_NanInfTable = getRoot(byteBuffer: &buffer) - XCTAssert(table.defaultNan.isNaN) - XCTAssertEqual(table.defaultInf, .infinity) - XCTAssertEqual(table.defaultNinf, -.infinity) - XCTAssert(table.valueNan.isNaN) - XCTAssertEqual(table.valueInf, .infinity) - XCTAssertEqual(table.valueNinf, -.infinity) - XCTAssertEqual(table.value, 100.0) + #expect(table.defaultNan.isNaN) + #expect(table.defaultInf == .infinity) + #expect(table.defaultNinf == -.infinity) + #expect(table.valueNan.isNaN) + #expect(table.valueInf == .infinity) + #expect(table.valueNinf == -.infinity) + #expect(table.value == 100.0) } - func testInfNanJSON() { + @Test + func testInfNanJSON() throws { let fbb = createTestTable() var bb = fbb.sizedBuffer - do { - struct Test: Decodable { - let valueInf: Double - let value: Int - let valueNan: Double - let valueNinf: Double - } - let reader: Swift_Tests_NanInfTable = try getCheckedRoot(byteBuffer: &bb) - let encoder = JSONEncoder() - encoder.keyEncodingStrategy = .convertToSnakeCase - encoder.nonConformingFloatEncodingStrategy = - .convertToString( - positiveInfinity: "inf", - negativeInfinity: "-inf", - nan: "nan") - let data = try encoder.encode(reader) - let decoder = JSONDecoder() - decoder.nonConformingFloatDecodingStrategy = .convertFromString( + struct Test: Decodable { + let valueInf: Double + let value: Int + let valueNan: Double + let valueNinf: Double + } + let reader: Swift_Tests_NanInfTable = try getCheckedRoot(byteBuffer: &bb) + let encoder = JSONEncoder() + encoder.keyEncodingStrategy = .convertToSnakeCase + encoder.nonConformingFloatEncodingStrategy = + .convertToString( positiveInfinity: "inf", negativeInfinity: "-inf", nan: "nan") - decoder.keyDecodingStrategy = .convertFromSnakeCase - let value = try decoder.decode(Test.self, from: data) - XCTAssertEqual(value.value, 100) - XCTAssertEqual(value.valueInf, .infinity) - XCTAssertEqual(value.valueNinf, -.infinity) - } catch { - XCTFail(error.localizedDescription) - } + let data = try encoder.encode(reader) + let decoder = JSONDecoder() + decoder.nonConformingFloatDecodingStrategy = .convertFromString( + positiveInfinity: "inf", + negativeInfinity: "-inf", + nan: "nan") + decoder.keyDecodingStrategy = .convertFromSnakeCase + let value = try decoder.decode(Test.self, from: data) + #expect(value.value == 100) + #expect(value.valueInf == .infinity) + #expect(value.valueNinf == -.infinity) } + func createTestTable() -> FlatBufferBuilder { + var fbb = FlatBufferBuilder() + let msg = Swift_Tests_NanInfTable.createNanInfTable( + &fbb, + valueNan: .nan, + valueInf: .infinity, + valueNinf: -.infinity, + value: 100.0) + fbb.finish(offset: msg) + return fbb + } } diff --git a/tests/swift/Tests/Flatbuffers/FlatBuffersStructsTests.swift b/tests/swift/Tests/Flatbuffers/FlatBuffersStructsTests.swift index b80c93e04a..33bbefe7ca 100644 --- a/tests/swift/Tests/Flatbuffers/FlatBuffersStructsTests.swift +++ b/tests/swift/Tests/Flatbuffers/FlatBuffersStructsTests.swift @@ -14,12 +14,13 @@ * limitations under the License. */ -import XCTest +import Testing @testable import FlatBuffers -final class FlatBuffersStructsTests: XCTestCase { +struct FlatBuffersStructsTests { + @Test func testWritingAndMutatingBools() { var fbb = FlatBufferBuilder() let start = TestMutatingBool.startTestMutatingBool(&fbb) @@ -30,11 +31,11 @@ final class FlatBuffersStructsTests: XCTestCase { var buffer = fbb.sizedBuffer let testMutatingBool: TestMutatingBool = getRoot(byteBuffer: &buffer) let property = testMutatingBool.mutableB - XCTAssertEqual(property?.property, false) + #expect(property?.property == false) property?.mutate(property: false) - XCTAssertEqual(property?.property, false) + #expect(property?.property == false) property?.mutate(property: true) - XCTAssertEqual(property?.property, true) + #expect(property?.property == true) } } diff --git a/tests/swift/Tests/Flatbuffers/FlatBuffersTests.swift b/tests/swift/Tests/Flatbuffers/FlatBuffersTests.swift index 7a01ecce09..7dc4a34d46 100644 --- a/tests/swift/Tests/Flatbuffers/FlatBuffersTests.swift +++ b/tests/swift/Tests/Flatbuffers/FlatBuffersTests.swift @@ -14,44 +14,49 @@ * limitations under the License. */ -import XCTest +import Testing @testable import Common @testable import FlatBuffers -final class FlatBuffersTests: XCTestCase { +struct FlatBuffersTests { let country = "Norway" - func testEndian() { XCTAssertEqual(isLitteEndian, true) } + @Test + func testEndian() { #expect(isLitteEndian == true) } + @Test func testOffset() { let o = Offset() let b = Offset(offset: 1) - XCTAssertEqual(o.isEmpty, true) - XCTAssertEqual(b.isEmpty, false) + #expect(o.isEmpty == true) + #expect(b.isEmpty == false) } + @Test func testCreateString() { let helloWorld = "Hello, world!" var b = FlatBufferBuilder(initialSize: 16) - XCTAssertEqual(b.create(string: country).o, 12) - XCTAssertEqual(b.create(string: helloWorld).o, 32) + #expect(b.create(string: country).o == 12) + #expect(b.create(string: helloWorld).o == 32) b.clear() - XCTAssertEqual(b.create(string: helloWorld).o, 20) - XCTAssertEqual(b.create(string: country).o, 32) + #expect(b.create(string: helloWorld).o == 20) + #expect(b.create(string: country).o == 32) b.clear() - XCTAssertEqual(b.create(string: String(repeating: "a", count: 257)).o, 264) + #expect(b.create(string: String(repeating: "a", count: 257)).o == 264) } + @Test func testStartTable() { var b = FlatBufferBuilder(initialSize: 16) - XCTAssertNoThrow(b.startTable(with: 0)) + _ = b.startTable(with: 0) b.clear() - XCTAssertEqual(b.create(string: country).o, 12) - XCTAssertEqual(b.startTable(with: 0), 12) + #expect(b.create(string: country).o == 12) + #expect(b.startTable(with: 0) == 12) } + @Test func testCreateFinish() { var b = FlatBufferBuilder(initialSize: 16) let countryOff = Country.createCountry( @@ -66,9 +71,10 @@ final class FlatBuffersTests: XCTestCase { 200, 0, 0, 0, 6, 0, 0, 0, 78, 111, 114, 119, 97, 121, 0, 0, ] // swiftformat:enable all - XCTAssertEqual(b.sizedByteArray, v) + #expect(b.sizedByteArray == v) } + @Test func testCreateFinishWithPrefix() { var b = FlatBufferBuilder(initialSize: 16) let countryOff = Country.createCountry( @@ -83,9 +89,10 @@ final class FlatBuffersTests: XCTestCase { 100, 0, 0, 0, 200, 0, 0, 0, 6, 0, 0, 0, 78, 111, 114, 119, 97, 121, 0, 0, ] // swiftformat:enable all - XCTAssertEqual(b.sizedByteArray, v) + #expect(b.sizedByteArray == v) } + @Test func testReadCountry() { // swiftformat:disable all let v: [UInt8] = [ @@ -95,18 +102,20 @@ final class FlatBuffersTests: XCTestCase { // swiftformat:enable all let buffer = ByteBuffer(bytes: v) let c = Country.getRootAsCountry(buffer) - XCTAssertEqual(c.lan, 100) - XCTAssertEqual(c.log, 200) - XCTAssertEqual(c.nameVector, [78, 111, 114, 119, 97, 121]) - XCTAssertEqual(c.name, country) + #expect(c.lan == 100) + #expect(c.log == 200) + #expect(c.nameVector == [78, 111, 114, 119, 97, 121]) + #expect(c.name == country) } + @Test func testWriteNullableStrings() { var b = FlatBufferBuilder() - XCTAssertTrue(b.create(string: nil).isEmpty) - XCTAssertTrue(b.createShared(string: nil).isEmpty) + #expect(b.create(string: nil).isEmpty) + #expect(b.createShared(string: nil).isEmpty) } + @Test func testWriteOptionalValues() { var b = FlatBufferBuilder() let root = optional_scalars_ScalarStuff.createScalarStuff( @@ -121,16 +130,17 @@ final class FlatBuffersTests: XCTestCase { b.finish(offset: root) var buffer = b.sizedBuffer let scalarTable: optional_scalars_ScalarStuff = getRoot(byteBuffer: &buffer) - XCTAssertEqual(scalarTable.justI8, 80) - XCTAssertNil(scalarTable.maybeI8) - XCTAssertEqual(scalarTable.maybeBool, true) - XCTAssertEqual(scalarTable.defaultI8, 42) - XCTAssertEqual(scalarTable.justU8, 100) - XCTAssertEqual(scalarTable.maybeU8, 10) - XCTAssertEqual(scalarTable.justEnum, .one) - XCTAssertNil(scalarTable.maybeEnum) + #expect(scalarTable.justI8 == 80) + #expect(scalarTable.maybeI8 == nil) + #expect(scalarTable.maybeBool == true) + #expect(scalarTable.defaultI8 == 42) + #expect(scalarTable.justU8 == 100) + #expect(scalarTable.maybeU8 == 10) + #expect(scalarTable.justEnum == .one) + #expect(scalarTable.maybeEnum == nil) } + @Test func testAlignmentCrash() { var builder = FlatBufferBuilder(initialSize: 256) diff --git a/tests/swift/Tests/Flatbuffers/FlatBuffersUnionTests.swift b/tests/swift/Tests/Flatbuffers/FlatBuffersUnionTests.swift index bf43d592ae..faf8f93a1e 100644 --- a/tests/swift/Tests/Flatbuffers/FlatBuffersUnionTests.swift +++ b/tests/swift/Tests/Flatbuffers/FlatBuffersUnionTests.swift @@ -14,12 +14,14 @@ * limitations under the License. */ -import XCTest +import Foundation +import Testing @testable import FlatBuffers -final class FlatBuffersUnionTests: XCTestCase { +struct FlatBuffersUnionTests { + @Test func testCreateMonstor() { var b = FlatBufferBuilder(initialSize: 20) @@ -36,8 +38,8 @@ final class FlatBuffersUnionTests: XCTestCase { b.finish(offset: root) let buffer = b.sizedByteArray // swiftformat:disable all - XCTAssertEqual( - buffer, + #expect( + buffer == [ 16, 0, 0, 0, 0, 0, 10, 0, 16, 0, 8, 0, 7, 0, 12, 0, 10, 0, 0, 0, 0, 0, 0, 1, 8, 0, 0, 0, 20, 0, 0, 0, 1, 0, 0, 0, 12, 0, 0, 0, 8, 0, 12, 0, 8, 0, 6, 0, 8, 0, 0, 0, 0, 0, 5, 0, 4, 0, 0, @@ -45,15 +47,16 @@ final class FlatBuffersUnionTests: XCTestCase { ]) // swiftformat:enable all let monster = LocalMonster.getRootAsMonster(bb: ByteBuffer(bytes: buffer)) - XCTAssertEqual(monster.weapon(at: 0)?.dmg, dmg) - XCTAssertEqual(monster.weapon(at: 0)?.name, str) - XCTAssertEqual(monster.weapon(at: 0)?.nameVector, [65, 120, 101]) + #expect(monster.weapon(at: 0)?.dmg == dmg) + #expect(monster.weapon(at: 0)?.name == str) + #expect(monster.weapon(at: 0)?.nameVector == [65, 120, 101]) let p: Weapon? = monster.equiped() - XCTAssertEqual(p?.dmg, dmg) - XCTAssertEqual(p?.name, str) - XCTAssertEqual(p?.nameVector, [65, 120, 101]) + #expect(p?.dmg == dmg) + #expect(p?.name == str) + #expect(p?.nameVector == [65, 120, 101]) } + @Test func testEndTableFinish() { var builder = FlatBufferBuilder(initialSize: 20) let sword = builder.create(string: "Sword") @@ -84,8 +87,8 @@ final class FlatBuffersUnionTests: XCTestCase { path: path) builder.finish(offset: orc) // swiftformat:disable all - XCTAssertEqual( - builder.sizedByteArray, + #expect( + builder.sizedByteArray == [ 32, 0, 0, 0, 0, 0, 26, 0, 48, 0, 36, 0, 0, 0, 34, 0, 28, 0, 0, 0, 24, 0, 23, 0, 16, 0, 15, 0, 8, 0, 4, 0, 26, 0, 0, 0, 44, 0, 0, 0, 104, 0, 0, 0, 0, 0, 0, 1, 60, 0, 0, 0, 0, 0, 0, 0, @@ -99,6 +102,7 @@ final class FlatBuffersUnionTests: XCTestCase { // swiftformat:enable all } + @Test func testEnumVector() { let vectorOfEnums: [ColorsNameSpace.RGB] = [.blue, .green] @@ -109,8 +113,8 @@ final class FlatBuffersUnionTests: XCTestCase { let end = ColorsNameSpace.Monster.endMonster(&builder, start: start) builder.finish(offset: end) // swiftformat:disable all - XCTAssertEqual( - builder.sizedByteArray, + #expect( + builder.sizedByteArray == [ 12, 0, 0, 0, 0, 0, 6, 0, 8, 0, 4, 0, 6, 0, 0, 0, 4, 0, 0, 0, 2, 0, 0, 0, 2, 0, 0, 0, 1, 0, 0, 0, @@ -118,12 +122,13 @@ final class FlatBuffersUnionTests: XCTestCase { // swiftformat:enable all let monster = ColorsNameSpace.Monster .getRootAsMonster(bb: builder.sizedBuffer) - XCTAssertEqual(monster.colorsCount, 2) + #expect(monster.colorsCount == 2) let colors = monster.colors - XCTAssertEqual(colors[0], .blue) - XCTAssertEqual(colors[1], .green) + #expect(colors[0] == .blue) + #expect(colors[1] == .green) } + @Test func testUnionVector() { var fb = FlatBufferBuilder() @@ -149,30 +154,30 @@ final class FlatBuffersUnionTests: XCTestCase { var buffer = fb.sizedBuffer let movie: Movie = getRoot(byteBuffer: &buffer) - XCTAssertEqual(movie.charactersType.count, characterType.count) - XCTAssertEqual(movie.characters.count, characters.count) + #expect(movie.charactersType.count == characterType.count) + #expect(movie.characters.count == characters.count) let bufferCharactersType = movie.charactersType for (index, element) in bufferCharactersType.enumerated() { - XCTAssertEqual(element, characterType[index]) + #expect(element == characterType[index]) } - XCTAssertEqual( - movie.characters(at: 0, type: BookReader_Mutable.self)?.booksRead, - 7) - XCTAssertEqual( - movie.characters(at: 1, type: Attacker.self)?.swordAttackDamage, - swordDmg) - XCTAssertEqual( - movie.characters(at: 2, type: BookReader_Mutable.self)?.booksRead, - 2) + #expect( + movie.characters(at: 0, type: BookReader_Mutable.self)?.booksRead == + 7) + #expect( + movie.characters(at: 1, type: Attacker.self)?.swordAttackDamage == + swordDmg) + #expect( + movie.characters(at: 2, type: BookReader_Mutable.self)?.booksRead == + 2) var objc: MovieT? = movie.unpack() - XCTAssertEqual( - movie.charactersType.count, objc?.characters.count ?? 0) - XCTAssertEqual( - movie.characters(at: 0, type: BookReader_Mutable.self)?.booksRead, - (objc?.characters[0]?.value as? BookReader)?.booksRead) + #expect( + movie.charactersType.count == objc?.characters.count ?? 0) + #expect( + movie.characters(at: 0, type: BookReader_Mutable.self)?.booksRead == + (objc?.characters[0]?.value as? BookReader)?.booksRead) fb.clear() let newMovie = Movie.pack(&fb, obj: &objc) fb.finish(offset: newMovie) @@ -180,17 +185,18 @@ final class FlatBuffersUnionTests: XCTestCase { var _buffer = fb.sizedBuffer let packedMovie: Movie = getRoot(byteBuffer: &_buffer) - XCTAssertEqual( - packedMovie.characters(at: 0, type: BookReader_Mutable.self)?.booksRead, - movie.characters(at: 0, type: BookReader_Mutable.self)?.booksRead) - XCTAssertEqual( - packedMovie.characters(at: 1, type: Attacker.self)?.swordAttackDamage, - movie.characters(at: 1, type: Attacker.self)?.swordAttackDamage) - XCTAssertEqual( - packedMovie.characters(at: 2, type: BookReader_Mutable.self)?.booksRead, - movie.characters(at: 2, type: BookReader_Mutable.self)?.booksRead) + #expect( + packedMovie.characters(at: 0, type: BookReader_Mutable.self)?.booksRead == + movie.characters(at: 0, type: BookReader_Mutable.self)?.booksRead) + #expect( + packedMovie.characters(at: 1, type: Attacker.self)?.swordAttackDamage == + movie.characters(at: 1, type: Attacker.self)?.swordAttackDamage) + #expect( + packedMovie.characters(at: 2, type: BookReader_Mutable.self)?.booksRead == + movie.characters(at: 2, type: BookReader_Mutable.self)?.booksRead) } + @Test func testStringUnion() { let string = "Awesome \\\\t\t\nstring!" var fb = FlatBufferBuilder() @@ -214,30 +220,31 @@ final class FlatBuffersUnionTests: XCTestCase { var buffer = fb.sizedBuffer let movie: Movie = getRoot(byteBuffer: &buffer) - XCTAssertEqual(movie.mainCharacter(type: String.self), string) - XCTAssertEqual( - movie.characters(at: 0, type: BookReader_Mutable.self)?.booksRead, - 7) - XCTAssertEqual(movie.characters(at: 1, type: String.self), string) + #expect(movie.mainCharacter(type: String.self) == string) + #expect( + movie.characters(at: 0, type: BookReader_Mutable.self)?.booksRead == + 7) + #expect(movie.characters(at: 1, type: String.self) == string) var objc: MovieT? = movie.unpack() - XCTAssertEqual(objc?.mainCharacter?.value as? String, string) - XCTAssertEqual((objc?.characters[0]?.value as? BookReader)?.booksRead, 7) - XCTAssertEqual(objc?.characters[1]?.value as? String, string) + #expect(objc?.mainCharacter?.value as? String == string) + #expect((objc?.characters[0]?.value as? BookReader)?.booksRead == 7) + #expect(objc?.characters[1]?.value as? String == string) fb.clear() let newMovie = Movie.pack(&fb, obj: &objc) fb.finish(offset: newMovie) var _buffer = fb.sizedBuffer let packedMovie: Movie = getRoot(byteBuffer: &_buffer) - XCTAssertEqual(packedMovie.mainCharacter(type: String.self), string) - XCTAssertEqual( - packedMovie.characters(at: 0, type: BookReader_Mutable.self)?.booksRead, - 7) - XCTAssertEqual(packedMovie.characters(at: 1, type: String.self), string) + #expect(packedMovie.mainCharacter(type: String.self) == string) + #expect( + packedMovie.characters(at: 0, type: BookReader_Mutable.self)?.booksRead == + 7) + #expect(packedMovie.characters(at: 1, type: String.self) == string) } - func testEncoding() { + @Test + func testEncoding() throws { let string = "Awesome \\\\t\t\nstring!" var fb = FlatBufferBuilder() @@ -265,16 +272,12 @@ final class FlatBuffersUnionTests: XCTestCase { Movie.finish(&fb, end: end) var sizedBuffer = fb.sizedBuffer - do { - let reader: Movie = try getCheckedRoot(byteBuffer: &sizedBuffer) - let encoder = JSONEncoder() - encoder.keyEncodingStrategy = .convertToSnakeCase - encoder.outputFormatting = [.sortedKeys] - let data = try encoder.encode(reader) - XCTAssertEqual(String(data: data, encoding: .utf8), jsonData) - } catch { - XCTFail(error.localizedDescription) - } + let reader: Movie = try getCheckedRoot(byteBuffer: &sizedBuffer) + let encoder = JSONEncoder() + encoder.keyEncodingStrategy = .convertToSnakeCase + encoder.outputFormatting = [.sortedKeys] + let data = try encoder.encode(reader) + #expect(String(data: data, encoding: .utf8) == jsonData) } var jsonData: String { diff --git a/tests/swift/Tests/Flatbuffers/FlatBuffersVectorsTests.swift b/tests/swift/Tests/Flatbuffers/FlatBuffersVectorsTests.swift index 27d3a4610b..5ebcd528ae 100644 --- a/tests/swift/Tests/Flatbuffers/FlatBuffersVectorsTests.swift +++ b/tests/swift/Tests/Flatbuffers/FlatBuffersVectorsTests.swift @@ -14,12 +14,13 @@ * limitations under the License. */ -import XCTest +import Testing @testable import FlatBuffers -final class FlatBuffersVectors: XCTestCase { +struct FlatBuffersVectors { + @Test func testCreatingTwoCountries() { let norway = "Norway" let denmark = "Denmark" @@ -40,8 +41,8 @@ final class FlatBuffersVectors: XCTestCase { let vectorOffset = b.createVector(ofOffsets: vector) b.finish(offset: vectorOffset) // swiftformat:disable all - XCTAssertEqual( - b.sizedByteArray, + #expect( + b.sizedByteArray == [ 4, 0, 0, 0, 2, 0, 0, 0, 48, 0, 0, 0, 16, 0, 0, 0, 0, 0, 10, 0, 18, 0, 4, 0, 8, 0, 12, 0, 10, 0, 0, 0, 40, 0, 0, 0, 100, 0, 0, 0, 200, 0, 0, 0, 0, 0, 10, 0, 16, 0, 4, 0, 8, 0, 12, 0, 10, @@ -51,18 +52,20 @@ final class FlatBuffersVectors: XCTestCase { // swiftformat:enable all } + @Test func testCreateIntArray() { let numbers: [Int32] = [1, 2, 3, 4, 5] var b = FlatBufferBuilder(initialSize: 20) let o = b.createVector(numbers, size: numbers.count) b.finish(offset: o) // swiftformat:disable all - XCTAssertEqual( - b.sizedByteArray, + #expect( + b.sizedByteArray == [4, 0, 0, 0, 5, 0, 0, 0, 1, 0, 0, 0, 2, 0, 0, 0, 3, 0, 0, 0, 4, 0, 0, 0, 5, 0, 0, 0]) // swiftformat:enable all } + @Test func testCreateStructArray() { struct Vec: NativeStruct { let x, y, z: Float32 @@ -76,8 +79,8 @@ final class FlatBuffersVectors: XCTestCase { let o = b.createVector(ofStructs: vector) b.finish(offset: o) // swiftformat:disable all - XCTAssertEqual( - b.sizedByteArray, + #expect( + b.sizedByteArray == [ 4, 0, 0, 0, 3, 0, 0, 0, 0, 0, 128, 63, 0, 0, 0, 64, 0, 0, 64, 64, 0, 0, 128, 64, 0, 0, 160, 64, 0, 0, 192, 64, 0, 0, 224, 64, 0, 0, 0, 65, 0, 0, 16, 65, @@ -85,28 +88,31 @@ final class FlatBuffersVectors: XCTestCase { // swiftformat:enable all } + @Test func testCreateEmptyIntArray() { let numbers: [Int32] = [] var b = FlatBufferBuilder(initialSize: 20) let o = b.createVector(numbers, size: numbers.count) b.finish(offset: o) - XCTAssertEqual(b.sizedByteArray, [4, 0, 0, 0, 0, 0, 0, 0]) + #expect(b.sizedByteArray == [4, 0, 0, 0, 0, 0, 0, 0]) } + @Test func testCreateVectorOfStrings() { let strs = ["Denmark", "Norway"] var b = FlatBufferBuilder(initialSize: 20) let o = b.createVector(ofStrings: strs) b.finish(offset: o) // swiftformat:disable all - XCTAssertEqual( - b.sizedByteArray, + #expect( + b.sizedByteArray == [ 4, 0, 0, 0, 2, 0, 0, 0, 20, 0, 0, 0, 4, 0, 0, 0, 6, 0, 0, 0, 78, 111, 114, 119, 97, 121, 0, 0, 7, 0, 0, 0, 68, 101, 110, 109, 97, 114, 107, 0, ]) // swiftformat:enable all } + @Test func testCreateSharedStringVector() { let norway = "Norway" let denmark = "Denmark" @@ -119,8 +125,8 @@ final class FlatBuffersVectors: XCTestCase { let end = b.createVector(ofOffsets: v) b.finish(offset: end) // swiftformat:disable all - XCTAssertEqual( - b.sizedByteArray, + #expect( + b.sizedByteArray == [ 4, 0, 0, 0, 4, 0, 0, 0, 28, 0, 0, 0, 12, 0, 0, 0, 20, 0, 0, 0, 4, 0, 0, 0, 7, 0, 0, 0, 68, 101, 110, 109, 97, 114, 107, 0, 6, 0, 0, 0, 78, 111, 114, 119, 97, 121, 0, 0, @@ -128,6 +134,7 @@ final class FlatBuffersVectors: XCTestCase { // swiftformat:enable all } + @Test func testReadInt32Array() { let data: [Int32] = [1, 2, 3, 4, 5] var b = FlatBufferBuilder(initialSize: 20) @@ -136,10 +143,11 @@ final class FlatBuffersVectors: XCTestCase { b.finish(offset: end) let number = Numbers.getRootAsNumbers(ByteBuffer(bytes: b.sizedByteArray)) for (index, num) in number.vArrayInt32.enumerated() { - XCTAssertEqual(num, data[index]) + #expect(num == data[index]) } } + @Test func testReadDoubleArray() { let data: [Double] = [1, 2, 3, 4, 5] var b = FlatBufferBuilder(initialSize: 20) @@ -148,10 +156,11 @@ final class FlatBuffersVectors: XCTestCase { b.finish(offset: end) let number = Numbers.getRootAsNumbers(ByteBuffer(bytes: b.sizedByteArray)) for (index, num) in number.vArrayDouble.enumerated() { - XCTAssertEqual(num, data[index]) + #expect(num == data[index]) } } + @Test func testHasForArray() { var builder = FlatBufferBuilder(initialSize: 20) let emptyVector = [UInt8]() @@ -166,14 +175,14 @@ final class FlatBuffersVectors: XCTestCase { var byteBuffer = ByteBuffer(bytes: builder.sizedByteArray) let msg: Swift_Tests_Vectors = getRoot(byteBuffer: &byteBuffer) - XCTAssertEqual(msg.none_.isEmpty, true) - XCTAssertEqual(msg.empty.isEmpty, true) - XCTAssertEqual(msg.empty.count, 0) - XCTAssertEqual(msg.array.isEmpty, false) - XCTAssertEqual(msg.array.count, 3) + #expect(msg.none_.isEmpty == true) + #expect(msg.empty.isEmpty == true) + #expect(msg.empty.count == 0) + #expect(msg.array.isEmpty == false) + #expect(msg.array.count == 3) for i in msg.array.startIndex...size - XCTAssertNoThrow(try verifier.rangeInBuffer(position: 24, size: size)) - XCTAssertThrowsError(try verifier.rangeInBuffer(position: 26, size: size)) - XCTAssertThrowsError(try verifier.rangeInBuffer(position: 26, size: size)) - XCTAssertThrowsError(try verifier.rangeInBuffer(position: 30, size: size)) - XCTAssertThrowsError(try verifier.rangeInBuffer(position: 32, size: size)) - XCTAssertThrowsError(try verifier.rangeInBuffer(position: 34, size: size)) + try verifier.rangeInBuffer(position: 24, size: size) + #expect(throws: FlatbuffersErrors.outOfBounds(position: 34, end: 32)) { + try verifier.rangeInBuffer(position: 26, size: size) + } + #expect(throws: FlatbuffersErrors.outOfBounds(position: 34, end: 32)) { + try verifier.rangeInBuffer( + position: 26, + size: size) + } + #expect(throws: FlatbuffersErrors.outOfBounds(position: 38, end: 32)) { + try verifier.rangeInBuffer( + position: 30, + size: size) + } + #expect(throws: FlatbuffersErrors.outOfBounds(position: 40, end: 32)) { + try verifier.rangeInBuffer( + position: 32, + size: size) + } + #expect(throws: FlatbuffersErrors.outOfBounds(position: 42, end: 32)) { + try verifier.rangeInBuffer( + position: 34, + size: size) + } verifier = try! Verifier( buffer: &buffer, options: .init(maxDepth: 0, maxTableCount: 0, maxApparentSize: 4)) - do { + + #expect(throws: FlatbuffersErrors.apparentSizeTooLarge) { try verifier.rangeInBuffer(position: 24, size: size) - } catch { - XCTAssertEqual( - error as! FlatbuffersErrors, - .apparentSizeTooLarge) } } - func testPositionInBuffer() { + @Test + func testPositionInBuffer() throws { let verifier = try! Verifier(buffer: &buffer) - XCTAssertNoThrow(try verifier.inBuffer(position: 0, of: Int64.self)) - XCTAssertNoThrow(try verifier.inBuffer(position: 24, of: Int64.self)) - XCTAssertThrowsError(try verifier.inBuffer(position: -9, of: Int64.self)) - XCTAssertThrowsError(try verifier.inBuffer(position: 25, of: Int64.self)) - XCTAssertThrowsError(try verifier.inBuffer(position: 26, of: Int32.self)) - XCTAssertThrowsError(try verifier.inBuffer(position: 26, of: Int64.self)) - XCTAssertThrowsError(try verifier.inBuffer(position: 30, of: Int64.self)) - XCTAssertThrowsError(try verifier.inBuffer(position: 32, of: Int64.self)) - XCTAssertThrowsError(try verifier.inBuffer(position: 34, of: Int64.self)) + try verifier.inBuffer(position: 0, of: Int64.self) + try verifier.inBuffer(position: 24, of: Int64.self) + + #expect( + throws: FlatbuffersErrors.missAlignedPointer( + position: -9, + type: "Int64")) + { + try verifier.inBuffer(position: -9, of: Int64.self) + } + #expect( + throws: FlatbuffersErrors.missAlignedPointer( + position: 25, + type: "Int64")) + { + try verifier.inBuffer(position: 25, of: Int64.self) + } + #expect( + throws: FlatbuffersErrors.missAlignedPointer( + position: 26, + type: "Int32")) + { + try verifier.inBuffer(position: 26, of: Int32.self) + } + #expect( + throws: FlatbuffersErrors.missAlignedPointer( + position: 26, + type: "Int64")) + { + try verifier.inBuffer(position: 26, of: Int64.self) + } + #expect( + throws: FlatbuffersErrors.missAlignedPointer( + position: 30, + type: "Int64")) + { + try verifier.inBuffer(position: 30, of: Int64.self) + } + #expect(throws: FlatbuffersErrors.outOfBounds(position: 40, end: 32)) { + try verifier.inBuffer( + position: 32, + of: Int64.self) + } + #expect( + throws: FlatbuffersErrors.missAlignedPointer( + position: 34, + type: "Int64")) + { + try verifier.inBuffer(position: 34, of: Int64.self) + } } - func testVisitTable() { + @Test + func testVisitTable() throws { var verifier = try! Verifier(buffer: &validFlatbuffersObject) - XCTAssertNoThrow(try verifier.visitTable(at: 48)) + _ = try verifier.visitTable(at: 48) verifier.reset() } - func testTableVerifier() { + @Test + func testTableVerifier() throws { var verifier = try! Verifier(buffer: &validFlatbuffersObject) var tableVerifer = try! verifier.visitTable(at: 48) - XCTAssertEqual(verifier.depth, 1) - XCTAssertEqual(verifier.tableCount, 1) - - XCTAssertNoThrow( - try tableVerifer.visit( - field: 4, - fieldName: "Vec", - required: false, - type: Vec3.self)) - XCTAssertNoThrow( - try tableVerifer.visit( - field: 8, - fieldName: "hp", - required: false, - type: Int16.self)) - - XCTAssertNoThrow( - try tableVerifer.visit( - field: 10, - fieldName: "name", - required: true, - type: ForwardOffset.self)) - - XCTAssertNoThrow( - try tableVerifer.visit( - field: 14, - fieldName: "inventory", - required: false, - type: ForwardOffset>.self)) - - XCTAssertNoThrow( - try tableVerifer.visit( - field: 22, - fieldName: "test4", - required: false, - type: ForwardOffset> - .self)) - - XCTAssertNoThrow( - try tableVerifer.visit( - field: 24, - fieldName: "Vector of strings", - required: false, - type: ForwardOffset, String>>.self)) - - do { + #expect(verifier.depth == 1) + #expect(verifier.tableCount == 1) + + try tableVerifer.visit( + field: 4, + fieldName: "Vec", + required: false, + type: Vec3.self) + + try tableVerifer.visit( + field: 8, + fieldName: "hp", + required: false, + type: Int16.self) + + try tableVerifer.visit( + field: 10, + fieldName: "name", + required: true, + type: ForwardOffset.self) + + try tableVerifer.visit( + field: 14, + fieldName: "inventory", + required: false, + type: ForwardOffset>.self) + + try tableVerifer.visit( + field: 22, + fieldName: "test4", + required: false, + type: ForwardOffset> + .self) + + try tableVerifer.visit( + field: 24, + fieldName: "Vector of strings", + required: false, + type: ForwardOffset, String>>.self) + + #expect(throws: FlatbuffersErrors.missAlignedPointer( + position: 25, + type: "UInt16")) + { try tableVerifer.visit( field: 13, fieldName: "notvalid", required: false, type: Int16.self) - } catch { - XCTAssertEqual( - error as! FlatbuffersErrors, - .missAlignedPointer(position: 25, type: "UInt16")) } - do { - try tableVerifer.visit( - unionKey: 18, - unionField: 20, - unionKeyName: "testType", - fieldName: "test", - required: false, - completion: { (verifier, key: MyGame_Example_Any_, pos) in - switch key { - case .none_: - break - case .monster: - try ForwardOffset.verify( - &verifier, - at: pos, - of: MyGame_Example_Monster.self) - - case .testsimpletablewithenum: - break - case .mygameExample2Monster: - break - } - }) - } catch { - XCTAssertEqual( - error as! FlatbuffersErrors, - .missAlignedPointer(position: 25, type: "UInt16")) - } + try tableVerifer.visit( + unionKey: 18, + unionField: 20, + unionKeyName: "testType", + fieldName: "test", + required: false, + completion: { (verifier, key: MyGame_Example_Any_, pos) in + switch key { + case .none_: + break // NOTE - SWIFT doesnt support none + case .monster: + try ForwardOffset.verify( + &verifier, + at: pos, + of: MyGame_Example_Monster.self) + case .testsimpletablewithenum: + try ForwardOffset.verify( + &verifier, + at: pos, + of: MyGame_Example_TestSimpleTableWithEnum.self) + case .mygameExample2Monster: + try ForwardOffset.verify( + &verifier, + at: pos, + of: MyGame_Example2_Monster.self) + } + }) + tableVerifer.finish() - XCTAssertEqual(verifier.depth, 0) + #expect(verifier.depth == 0) } - func testVerifyUnionVectors() { + @Test + func testVerifyUnionVectors() throws { // swiftformat:disable all var byteBuffer = ByteBuffer(bytes: [ 20, 0, 0, 0, 77, 79, 86, 73, 12, 0, 12, 0, 0, 0, 0, 0, 8, 0, 4, 0, 12, 0, 0, 0, 8, 0, 0, 0, @@ -281,10 +340,11 @@ final class FlatbuffersVerifierTests: XCTestCase { 0, 0, 7, 0, 0, 0, 0, 0, 6, 0, 8, 0, 4, 0, 6, 0, 0, 0, 8, 0, 0, 0, ]) // swiftformat:enable all - XCTAssertNoThrow(try getCheckedRoot(byteBuffer: &byteBuffer) as Movie) + _ = try getCheckedRoot(byteBuffer: &byteBuffer) as Movie } - func testErrorWrongFileId() { + @Test + func testErrorWrongFileId() throws{ // swiftformat:disable all var byteBuffer = ByteBuffer(bytes: [ 20, 0, 0, 0, 77, 79, 86, 73, 12, 0, 12, 0, 0, 0, 0, 0, 8, 0, 4, 0, 12, 0, 0, 0, 8, 0, 0, 0, @@ -292,12 +352,14 @@ final class FlatbuffersVerifierTests: XCTestCase { 0, 0, 7, 0, 0, 0, 0, 0, 6, 0, 8, 0, 4, 0, 6, 0, 0, 0, 8, 0, 0, 0, ]) // swiftformat:enable all - XCTAssertThrowsError( + #expect(throws: FlatbuffersErrors.bufferIdDidntMatchPassedId) { try getCheckedRoot( byteBuffer: &byteBuffer, - fileId: "FLEX") as Movie) + fileId: "FLEX") as Movie + } } + @Test func testVerifyPrefixedBuffer() { // swiftformat:disable all var byteBuffer = ByteBuffer(bytes: [ @@ -306,41 +368,50 @@ final class FlatbuffersVerifierTests: XCTestCase { 0, 2, 0, 0, 0, 7, 0, 0, 0, 0, 0, 6, 0, 8, 0, 4, 0, 6, 0, 0, 0, 8, 0, 0, 0, ]) // swiftformat:enable all - XCTAssertThrowsError( - try getCheckedPrefixedSizeRoot(byteBuffer: &byteBuffer) as Movie) + #expect(throws: FlatbuffersErrors.prefixedSizeNotEqualToBufferSize) { + try getCheckedPrefixedSizeRoot(byteBuffer: &byteBuffer) as Movie + } } - func testFullVerifier() { - XCTAssertNoThrow( + @Test + func testFullVerifier() throws { + _ = try getCheckedRoot( - byteBuffer: &validFlatbuffersObject) as MyGame_Example_Monster) + byteBuffer: &validFlatbuffersObject) as MyGame_Example_Monster } - func testFullVerifierWithFileId() { - XCTAssertNoThrow( - try getCheckedRoot( - byteBuffer: &validFlatbuffersObject, - fileId: MyGame_Example_Monster.id) as MyGame_Example_Monster) + @Test + func testFullVerifierWithFileId() throws { + _ = try getCheckedRoot( + byteBuffer: &validFlatbuffersObject, + fileId: MyGame_Example_Monster.id) as MyGame_Example_Monster } + @Test func testInvalidBuffer() { - XCTAssertThrowsError( + #expect(throws: FlatbuffersErrors.self) { try getCheckedRoot( - byteBuffer: &invalidFlatbuffersObject) as MyGame_Example_Monster) + byteBuffer: &self.invalidFlatbuffersObject) as MyGame_Example_Monster + } } + @Test func testInvalidBuffer2() { - XCTAssertThrowsError( + #expect(throws: FlatbuffersErrors.self) { try getCheckedRoot( - byteBuffer: &invalidFlatbuffersObject2) as MyGame_Example_Monster) + byteBuffer: &self.invalidFlatbuffersObject2) as MyGame_Example_Monster + } } + @Test func testInvalidBuffer3() { - XCTAssertThrowsError( + #expect(throws: FlatbuffersErrors.self) { try getCheckedRoot( - byteBuffer: &invalidFlatbuffersObject3) as MyGame_Example_Monster) + byteBuffer: &self.invalidFlatbuffersObject3) as MyGame_Example_Monster + } } + @Test func testValidUnionBuffer() { let string = "Awesome \\\\t\t\nstring!" var fb = FlatBufferBuilder() @@ -362,9 +433,14 @@ final class FlatbuffersVerifierTests: XCTestCase { charactersVectorOffset: characterVector) Movie.finish(&fb, end: end) var buf = fb.sizedBuffer - XCTAssertNoThrow(try getCheckedRoot(byteBuffer: &buf) as Movie) + do { + _ = try getCheckedRoot(byteBuffer: &buf) as Movie + } catch { + Issue.record(error) + } } + @Test func testNestedTables() throws { var builder = FlatBufferBuilder() let name = builder.create(string: "Monster") @@ -383,22 +459,22 @@ final class FlatbuffersVerifierTests: XCTestCase { var verifier = try! Verifier(buffer: &sizedBuffer) var tableVerifer = try! verifier.visitTable( at: try getOffset(at: 0, within: verifier)) - XCTAssertEqual(verifier.depth, 1) - XCTAssertEqual(verifier.tableCount, 1) + #expect(verifier.depth == 1) + #expect(verifier.tableCount == 1) let position = try tableVerifer.dereference(28)! var nestedTable = try verifier.visitTable( at: try getOffset(at: position, within: verifier)) - XCTAssertEqual(verifier.depth, 2) - XCTAssertEqual(verifier.tableCount, 2) + #expect(verifier.depth == 2) + #expect(verifier.tableCount == 2) nestedTable.finish() - XCTAssertEqual(verifier.depth, 1) - XCTAssertEqual(verifier.tableCount, 2) + #expect(verifier.depth == 1) + #expect(verifier.tableCount == 2) tableVerifer.finish() - XCTAssertEqual(verifier.depth, 0) - XCTAssertEqual(verifier.tableCount, 2) + #expect(verifier.depth == 0) + #expect(verifier.tableCount == 2) } func add(buffer: inout ByteBuffer, v: Int32, p: Int) { diff --git a/tests/swift/Tests/Flexbuffers/FlexBuffersJSONTests.swift b/tests/swift/Tests/Flexbuffers/FlexBuffersJSONTests.swift index c254666666..8cb5ca9b51 100644 --- a/tests/swift/Tests/Flexbuffers/FlexBuffersJSONTests.swift +++ b/tests/swift/Tests/Flexbuffers/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) } } diff --git a/tests/swift/Tests/Flexbuffers/FlexBuffersReaderTests.swift b/tests/swift/Tests/Flexbuffers/FlexBuffersReaderTests.swift index 42ecad3a5f..12cc820607 100644 --- a/tests/swift/Tests/Flexbuffers/FlexBuffersReaderTests.swift +++ b/tests/swift/Tests/Flexbuffers/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(data: fbx.data)) - 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(data: fbx.data)) 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(data: fbx.data)) - 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.. 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.. Date: Wed, 6 May 2026 05:32:19 +0200 Subject: [PATCH 2/2] Updates flag to make sure that Wasm testing works --- .github/workflows/build.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml index a5a6bab3d8..810d515aeb 100644 --- a/.github/workflows/build.yml +++ b/.github/workflows/build.yml @@ -534,7 +534,7 @@ jobs: run: | swift sdk list swift build --build-tests --swift-sdk swift-6.2.1-RELEASE_wasm - wasmtime --dir . .build/wasm32-unknown-wasip1/debug/FlatBuffers.Test.Swift.WasmPackageTests.xctest + wasmtime --dir . .build/wasm32-unknown-wasip1/debug/FlatBuffers.Test.Swift.WasmPackageTests.xctest --testing-library swift-testing build-ts: name: Build TS