BigfootDev/flatbuffers
1
0
Fork 1
mirror of https://github.com/google/flatbuffers.git synced 2026-07-05 16:06:54 +00:00
Code Issues Packages Projects Releases Wiki Activity

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

Browse Source 
* 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
This commit is contained in:
mustiikhalil
2026-05-08 03:49:41 +02:00
committed by GitHub
parent e6bbb3d22e
commit 392165432a
21 changed files with 1054 additions and 883 deletions
Download Patch File Download Diff File Expand all files Collapse all files

386
tests/swift/Tests/Flatbuffers/FlatbuffersVerifierTests.swift
View File

@@ -14,25 +14,20 @@
* limitations under the License.
*/
import XCTest
import Testing
@testable import FlatBuffers
final class FlatbuffersVerifierTests: XCTestCase {
final class FlatbuffersVerifierTests {
var buffer: ByteBuffer!
var validFlatbuffersObject: ByteBuffer!
var invalidFlatbuffersObject: ByteBuffer!
var invalidFlatbuffersObject2: ByteBuffer!
var invalidFlatbuffersObject3: ByteBuffer!
private var buffer: ByteBuffer
private var validFlatbuffersObject: ByteBuffer
private var invalidFlatbuffersObject: ByteBuffer
private var invalidFlatbuffersObject2: ByteBuffer
private var invalidFlatbuffersObject3: ByteBuffer
override func setUp() {
init() {
// swiftformat:disable all
let memory = UnsafeMutableRawPointer.allocate(byteCount: 32, alignment: 1)
buffer = ByteBuffer(assumingMemoryBound: memory, capacity: 32)
add(buffer: &buffer, v: 4, p: 16)
add(buffer: &buffer, v: 4, p: 20)
validFlatbuffersObject = ByteBuffer(bytes: [
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, 0, 0,
@@ -94,186 +89,250 @@ final class FlatbuffersVerifierTests: XCTestCase {
109, 97, 0, 0, 0, 6, 0, 0, 0, 66, 97, 114, 110, 101, 121, 0, 0, 5, 0, 0, 0, 70, 114, 111, 100,
0x00, 111, 0, 0, 0,
])
let memory = UnsafeMutableRawPointer.allocate(byteCount: 32, alignment: 1)
buffer = ByteBuffer(assumingMemoryBound: memory, capacity: 32)
add(buffer: &buffer, v: 4, p: 16)
add(buffer: &buffer, v: 4, p: 20)
// swiftformat:enable all
}
func testVeriferInitPassing() {
@Test
func testVeriferInitPassing() throws {
let memory = UnsafeMutableRawPointer.allocate(byteCount: 8, alignment: 1)
var buffer = ByteBuffer(
assumingMemoryBound: memory,
capacity: Int(FlatBufferMaxSize) - 1)
XCTAssertNoThrow(try Verifier(buffer: &buffer))
_ = try Verifier(buffer: &buffer)
}
@Test
func testVeriferInitFailing() {
let memory = UnsafeMutableRawPointer.allocate(byteCount: 8, alignment: 1)
var buffer = ByteBuffer(
assumingMemoryBound: memory,
capacity: Int(FlatBufferMaxSize) + 1)
XCTAssertThrowsError(try Verifier(buffer: &buffer))
#expect(throws: FlatbuffersErrors.exceedsMaxSizeAllowed) {
try Verifier(buffer: &buffer)
}
}
@Test
func testFailingID() {
let dutData: [UInt8] = [1, 2, 3, 4, 5, 6, 7]
var buff = ByteBuffer(bytes: dutData)
do {
#expect(throws: FlatbuffersErrors.bufferDoesntContainID) {
let _: Monster = try getCheckedRoot(byteBuffer: &buff, fileId: "ABCD")
XCTFail("This should always fail")
} catch {
XCTAssertEqual(error as? FlatbuffersErrors, .bufferDoesntContainID)
}
}
func testVerifierCheckAlignment() {
@Test
func testVerifierCheckAlignment() throws {
let verifier = try! Verifier(buffer: &buffer)
do {
#expect(throws: FlatbuffersErrors.missAlignedPointer(
position: 20,
type: "Int"))
{
try verifier.isAligned(position: 20, type: Int.self)
} catch {
XCTAssertEqual(
error as? FlatbuffersErrors,
.missAlignedPointer(position: 20, type: "Int"))
}
XCTAssertNoThrow(try verifier.isAligned(position: 16, type: Int.self))
try verifier.isAligned(position: 16, type: Int.self)
let newVerifer = try! Verifier(buffer: &buffer, checkAlignment: false)
XCTAssertNoThrow(try newVerifer.isAligned(position: 16, type: Int.self))
try newVerifer.isAligned(position: 16, type: Int.self)
}
func testRangeInBuffer() {
@Test
func testRangeInBuffer() throws {
var verifier = try! Verifier(buffer: &buffer)
let size = MemoryLayout<Int64>.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)
#expect(verifier.depth == 1)
#expect(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))
try tableVerifer.visit(
field: 4,
fieldName: "Vec",
required: false,
type: Vec3.self)
XCTAssertNoThrow(
try tableVerifer.visit(
field: 10,
fieldName: "name",
required: true,
type: ForwardOffset<String>.self))
try tableVerifer.visit(
field: 8,
fieldName: "hp",
required: false,
type: Int16.self)
XCTAssertNoThrow(
try tableVerifer.visit(
field: 14,
fieldName: "inventory",
required: false,
type: ForwardOffset<Vector<UInt8, UInt8>>.self))
try tableVerifer.visit(
field: 10,
fieldName: "name",
required: true,
type: ForwardOffset<String>.self)
XCTAssertNoThrow(
try tableVerifer.visit(
field: 22,
fieldName: "test4",
required: false,
type: ForwardOffset<Vector<MyGame_Example_Test, MyGame_Example_Test>>
.self))
try tableVerifer.visit(
field: 14,
fieldName: "inventory",
required: false,
type: ForwardOffset<Vector<UInt8, UInt8>>.self)
XCTAssertNoThrow(
try tableVerifer.visit(
field: 24,
fieldName: "Vector of strings",
required: false,
type: ForwardOffset<Vector<ForwardOffset<String>, String>>.self))
try tableVerifer.visit(
field: 22,
fieldName: "test4",
required: false,
type: ForwardOffset<Vector<MyGame_Example_Test, MyGame_Example_Test>>
.self)
do {
try tableVerifer.visit(
field: 24,
fieldName: "Vector of strings",
required: false,
type: ForwardOffset<Vector<ForwardOffset<String>, 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<MyGame_Example_Monster>.verify(
&verifier,
at: pos,
of: MyGame_Example_Monster.self)
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<MyGame_Example_Monster>.verify(
&verifier,
at: pos,
of: MyGame_Example_Monster.self)
case .testsimpletablewithenum:
try ForwardOffset<MyGame_Example_TestSimpleTableWithEnum>.verify(
&verifier,
at: pos,
of: MyGame_Example_TestSimpleTableWithEnum.self)
case .mygameExample2Monster:
try ForwardOffset<MyGame_Example2_Monster>.verify(
&verifier,
at: pos,
of: MyGame_Example2_Monster.self)
}
})
case .testsimpletablewithenum:
break
case .mygameExample2Monster:
break
}
})
} catch {
XCTAssertEqual(
error as! FlatbuffersErrors,
.missAlignedPointer(position: 25, type: "UInt16"))
}
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) {