BigfootDev/flatbuffers
1
0
Fork 1
mirror of https://github.com/google/flatbuffers.git synced 2026-11-12 06:56:21 +00:00
Code Issues Packages Projects Releases Wiki Activity

Bigfoot

Browse Source
This commit is contained in:
rboullard
2026-08-17 01:21:55 +02:00
parent 5761d6e67a
commit 4bd1e24e75
265 changed files with 20617 additions and 24457 deletions
Download Patch File Download Diff File Expand all files Collapse all files
tests/swift/Tests/Flatbuffers/ByteBufferTests.swift
+18 -22
View File
@@ -14,58 +14,51 @@
* limitations under the License.
*/
import Foundation
import Testing
import XCTest
@testable import FlatBuffers
struct ByteBufferTests {
@Test
final class ByteBufferTests: XCTestCase {
func testCopyingMemory() {
let count = 100
let ptr = UnsafeMutableRawPointer.allocate(byteCount: count, alignment: 1)
let byteBuffer = ByteBuffer(copyingMemoryBound: ptr, capacity: count)
byteBuffer.withUnsafeBytes { memory in
#expect(memory.baseAddress! != ptr)
XCTAssertNotEqual(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
#expect(memory.baseAddress! == ptr)
XCTAssertEqual(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
#expect(memory.baseAddress! == ptr.baseAddress!)
XCTAssertEqual(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
#expect(memory.baseAddress == ptr.baseAddress)
XCTAssertEqual(memory.baseAddress, ptr.baseAddress)
}
}
}
@Test
func testReadingDoubleBuffer() {
let count = 8
let array: [Double] = Array(repeating: 8.8, count: count)
@@ -76,16 +69,15 @@ struct ByteBufferTests {
}
let byteBuffer = ByteBuffer(bytes: bytes)
byteBuffer.withUnsafePointerToSlice(index: 0, count: count) { ptr in
#expect(ptr.count == count)
XCTAssertEqual(ptr.count, count)
bytes.withUnsafeBufferPointer {
#expect(
UnsafeRawPointer($0.baseAddress) ==
UnsafeRawPointer(ptr.baseAddress))
XCTAssertEqual(
UnsafeRawPointer($0.baseAddress),
UnsafeRawPointer(ptr.baseAddress))
}
}
}
@Test
func testReadingNativeStructs() {
let array = [
MyGame_Example_Vec3(
@@ -119,11 +111,11 @@ struct ByteBufferTests {
let byteBuffer = ByteBuffer(bytes: bytes)
byteBuffer
.withUnsafePointerToSlice(index: 0, count: count) { bufferPointer in
#expect(bufferPointer.count == count)
XCTAssertEqual(bufferPointer.count, count)
bytes.withUnsafeBufferPointer { ptr in
#expect(
UnsafeRawPointer(ptr.baseAddress) ==
UnsafeRawPointer(bufferPointer.baseAddress))
XCTAssertEqual(
UnsafeRawPointer(ptr.baseAddress),
UnsafeRawPointer(bufferPointer.baseAddress))
}
}
}
@@ -134,3 +126,7 @@ private struct TestNativeStructs: NativeStruct {
let y: Double
let z: Int
}
extension MyGame_Example_Color: CaseIterable {
public static var allCases: [MyGame_Example_Color] = [.red, .blue, .green]
}
tests/swift/Tests/Flatbuffers/FlatBuffersArraysTests.swift
+67 -79
View File
@@ -16,22 +16,18 @@
#if compiler(>=6.2)
import Testing
import XCTest
@testable import FlatBuffers
struct FlatBuffersArraysTests {
@available(macOS 26.0, iOS 26.0, watchOS 26.0, tvOS 26.0, *)
final class FlatBuffersArraysTests: XCTestCase {
@available(macOS 26.0, iOS 26.0, watchOS 26.0, tvOS 26.0, *)
@Test
func testStructSizes() {
#expect(MemoryLayout<MyGame_Example_NestedStruct>.size == 32)
#expect(MemoryLayout<MyGame_Example_ArrayStruct>.size == 160)
#expect((MemoryLayout<MyGame_Example_LargeArrayStruct>.size == 2496))
XCTAssertEqual(MemoryLayout<MyGame_Example_NestedStruct>.size, 32)
XCTAssertEqual(MemoryLayout<MyGame_Example_ArrayStruct>.size, 160)
}
@available(macOS 26.0, iOS 26.0, watchOS 26.0, tvOS 26.0, *)
@Test
func testGoldenData() {
// swiftformat:disable all
let data: [UInt8] = [
@@ -48,11 +44,9 @@ struct FlatBuffersArraysTests {
]
// swiftformat:enable all
#expect(data == createArrayTable())
XCTAssertEqual(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(
@@ -63,8 +57,6 @@ struct FlatBuffersArraysTests {
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(
@@ -73,110 +65,105 @@ struct FlatBuffersArraysTests {
verifyNativeStruct(a: table.unpack().a)
}
@available(macOS 26.0, iOS 26.0, watchOS 26.0, tvOS 26.0, *)
@Test
func testDefaults() {
#expect(
MyGame_Example_NestedStruct() ==
MyGame_Example_NestedStruct(
a: [0, 0],
b: .a,
c: [0, 0],
d: [0, 0]))
XCTAssertEqual(
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!
#expect(a.a == 12.34)
#expect(a.b.count == 15)
XCTAssertEqual(a.a, 12.34)
XCTAssertEqual(a.b.count, 15)
var sum: Int32 = 0
for i in a.b.startIndex..<a.b.endIndex {
sum += a.b[i]
}
#expect(sum == 120)
#expect(a.c == -127)
#expect(a.d.count == 2)
XCTAssertEqual(sum, 120)
XCTAssertEqual(a.c, -127)
XCTAssertEqual(a.d.count, 2)
let nestedStruct1 = a.d[0]
#expect(nestedStruct1.a.toArray() == [-1, 2])
#expect(nestedStruct1.b == .a)
#expect(nestedStruct1.c.toArray() == [.c, .b])
#expect(
nestedStruct1.d.toArray() ==
[0x1122334455667788, -0x1122334455667788])
XCTAssertEqual(nestedStruct1.a.toArray(), [-1, 2])
XCTAssertEqual(nestedStruct1.b, .a)
XCTAssertEqual(nestedStruct1.c.toArray(), [.c, .b])
XCTAssertEqual(
nestedStruct1.d.toArray(),
[0x1122334455667788, -0x1122334455667788])
let nestedStruct2 = a.d[1]
#expect(nestedStruct2.a.toArray() == [3, -4])
#expect(nestedStruct2.b == .b)
#expect(nestedStruct2.c.toArray() == [.b, .a])
#expect(
nestedStruct2.d.toArray() ==
[-0x1122334455667788, 0x1122334455667788])
XCTAssertEqual(nestedStruct2.a.toArray(), [3, -4])
XCTAssertEqual(nestedStruct2.b, .b)
XCTAssertEqual(nestedStruct2.c.toArray(), [.b, .a])
XCTAssertEqual(
nestedStruct2.d.toArray(),
[-0x1122334455667788, 0x1122334455667788])
#expect(a.e == 1)
#expect(a.f.count == 2)
XCTAssertEqual(a.e, 1)
XCTAssertEqual(a.f.count, 2)
}
@available(macOS 26.0, iOS 26.0, watchOS 26.0, tvOS 26.0, *)
func verifyMutations(in table: MyGame_Example_ArrayTable) {
let a = table.mutableA!
#expect(a.a == 12.34)
#expect(a.b.count == 15)
XCTAssertEqual(a.a, 12.34)
XCTAssertEqual(a.b.count, 15)
var sum: Int32 = 0
for i in a.b.startIndex..<a.b.endIndex {
sum += a.b[i]
}
#expect(sum == 120)
#expect(a.c == -127)
#expect(a.d.count == 2)
XCTAssertEqual(sum, 120)
XCTAssertEqual(a.c, -127)
XCTAssertEqual(a.d.count, 2)
let nestedStruct1 = a.d[0]
#expect(nestedStruct1.a.reduce(0) { $0 + $1 } == 1)
#expect(nestedStruct1.b == .a)
#expect(nestedStruct1.c[0] == .c)
#expect(nestedStruct1.c[1] == .b)
XCTAssertEqual(nestedStruct1.a.reduce(0) { $0 + $1 }, 1)
XCTAssertEqual(nestedStruct1.b, .a)
XCTAssertEqual(nestedStruct1.c[0], .c)
XCTAssertEqual(nestedStruct1.c[1], .b)
let nestedStruct2 = a.d[1]
#expect(nestedStruct2.a.reduce(0) { $0 + $1 } == -1)
#expect(nestedStruct2.b == .b)
#expect(nestedStruct2.c[0] == .b)
#expect(nestedStruct2.c[1] == .a)
#expect(nestedStruct2.d[0] == -0x1122334455667788)
#expect(nestedStruct2.d[1] == 0x1122334455667788)
XCTAssertEqual(nestedStruct2.a.reduce(0) { $0 + $1 }, -1)
XCTAssertEqual(nestedStruct2.b, .b)
XCTAssertEqual(nestedStruct2.c[0], .b)
XCTAssertEqual(nestedStruct2.c[1], .a)
XCTAssertEqual(nestedStruct2.d[0], -0x1122334455667788)
XCTAssertEqual(nestedStruct2.d[1], 0x1122334455667788)
#expect(a.mutate(b: 1000, at: 0) == true)
#expect(a.mutate(b: 2000, at: 1) == true)
XCTAssertTrue(a.mutate(b: 1000, at: 0))
XCTAssertTrue(a.mutate(b: 2000, at: 1))
#expect(nestedStruct2.mutate(c: .a, at: 0) == true)
#expect(nestedStruct2.mutate(c: .b, at: 1) == true)
XCTAssertTrue(nestedStruct2.mutate(c: .a, at: 0))
XCTAssertTrue(nestedStruct2.mutate(c: .b, at: 1))
#expect(nestedStruct2.c[0] == .a)
#expect(nestedStruct2.c[1] == .b)
XCTAssertEqual(nestedStruct2.c[0], .a)
XCTAssertEqual(nestedStruct2.c[1], .b)
#expect(nestedStruct2.mutate(d: 0, at: 0) == true)
#expect(nestedStruct2.mutate(d: 0, at: 1) == true)
XCTAssertTrue(nestedStruct2.mutate(d: 0, at: 0))
XCTAssertTrue(nestedStruct2.mutate(d: 0, at: 1))
#expect(nestedStruct2.d.reduce(0) { $0 + $1 } == 0)
XCTAssertEqual(nestedStruct2.d.reduce(0) { $0 + $1 }, 0)
let nativeStruct = table.a?.d[1]
#expect(nativeStruct?.c[0] == .a)
#expect(nativeStruct?.c[1] == .b)
XCTAssertEqual(nativeStruct?.c[0], .a)
XCTAssertEqual(nativeStruct?.c[1], .b)
#expect(nativeStruct?.d[0] == 0)
#expect(nativeStruct?.d[1] == 0)
XCTAssertEqual(nativeStruct?.d[0], 0)
XCTAssertEqual(nativeStruct?.d[1], 0)
#expect(a.mutate(b: 1, at: 0) == true)
#expect(a.mutate(b: 2, at: 1) == true)
XCTAssertTrue(a.mutate(b: 1, at: 0))
XCTAssertTrue(a.mutate(b: 2, at: 1))
#expect(nestedStruct2.mutate(c: .b, at: 0) == true)
#expect(nestedStruct2.mutate(c: .a, at: 1) == true)
XCTAssertTrue(nestedStruct2.mutate(c: .b, at: 0))
XCTAssertTrue(nestedStruct2.mutate(c: .a, at: 1))
#expect(nestedStruct2.mutate(d: -0x1122334455667788, at: 0) == true)
#expect(nestedStruct2.mutate(d: 0x1122334455667788, at: 1) == true)
XCTAssertTrue(nestedStruct2.mutate(d: -0x1122334455667788, at: 0))
XCTAssertTrue(nestedStruct2.mutate(d: 0x1122334455667788, at: 1))
}
@available(macOS 26.0, iOS 26.0, watchOS 26.0, tvOS 26.0, *)
private func createArrayTable() -> [UInt8] {
var builder = FlatBufferBuilder(initialSize: 1024)
@@ -246,3 +233,4 @@ extension InlineArray: @retroactive Equatable where Element: Equatable {
}
#endif
tests/swift/Tests/Flatbuffers/FlatBuffersMonsterWriterTests.swift
+136 -152
View File
@@ -15,7 +15,7 @@
*/
import Foundation
import Testing
import XCTest
@testable import FlatBuffers
@@ -24,9 +24,8 @@ typealias Monster = MyGame_Example_Monster
typealias Vec3 = MyGame_Example_Vec3
typealias Stat = MyGame_Example_Stat
struct FlatBuffersMonsterWriterTests {
class FlatBuffersMonsterWriterTests: XCTestCase {
@Test
func testData() {
// swiftformat:disable all
let data = Data([
@@ -48,13 +47,12 @@ struct FlatBuffersMonsterWriterTests {
readVerifiedMonster(fb: _data)
}
@Test
func testReadFromOtherLanguages() {
let path = {
#if os(macOS)
// Gets the current path of this test file then
// strips out the nested directories.
let filePath = URL(filePath: #filePath)
let filePath = URL(filePath: #file)
.deletingLastPathComponent()
return filePath.absoluteString
#else
@@ -73,7 +71,6 @@ struct FlatBuffersMonsterWriterTests {
readVerifiedMonster(fb: _data)
}
@Test
func testCreateMonsterData() {
let bytes = createMonster(withPrefix: false)
var buffer = ByteBuffer(data: bytes.data)
@@ -83,32 +80,30 @@ struct FlatBuffersMonsterWriterTests {
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()
#expect(builder.capacity == 1)
#expect(builder.size == 0)
XCTAssertEqual(builder.capacity, 1)
XCTAssertEqual(builder.size, 0)
write(fbb: &builder, prefix: false)
var _buffer = ByteBuffer(data: builder.data)
#expect(_buffer.capacity == 304)
XCTAssertEqual(_buffer.capacity, 304)
let _monster: MyGame_Example_Monster = getRoot(byteBuffer: &_buffer)
readMonster(monster: _monster)
builder.clear(keepingCapacity: true)
#expect(builder.capacity == 512)
#expect(builder.size == 0)
XCTAssertEqual(builder.capacity, 512)
XCTAssertEqual(builder.size, 0)
}
@Test
func testCreateMonster() {
let bytes = createMonster(withPrefix: false)
// swiftformat:disable all
#expect(
bytes.sizedByteArray ==
XCTAssertEqual(
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,
@@ -132,12 +127,11 @@ struct FlatBuffersMonsterWriterTests {
readMonster(monster: monster)
}
@Test
func testCreateMonsterResizedBuffer() {
let bytes = createMonster(withPrefix: false)
// swiftformat:disable all
#expect(
bytes.sizedByteArray ==
XCTAssertEqual(
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,
@@ -156,12 +150,11 @@ struct FlatBuffersMonsterWriterTests {
readVerifiedMonster(fb: bytes.sizedBuffer)
}
@Test
func testCreateMonsterPrefixed() {
let bytes = createMonster(withPrefix: true)
// swiftformat:disable all
#expect(
bytes.sizedByteArray ==
XCTAssertEqual(
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,
@@ -182,7 +175,6 @@ struct FlatBuffersMonsterWriterTests {
readMonster(monster: getPrefixedSizeRoot(byteBuffer: &buffer))
}
@Test
func testCreateMonsterUsingCreateMonsterMethodWithNilPos() {
var fbb = FlatBufferBuilder(initialSize: 1)
let name = fbb.create(string: "Frodo")
@@ -192,11 +184,10 @@ struct FlatBuffersMonsterWriterTests {
fbb.finish(offset: root)
var buffer = fbb.sizedBuffer
let newMonster: Monster = getRoot(byteBuffer: &buffer)
#expect(newMonster.pos == nil)
#expect(newMonster.name == "Frodo")
XCTAssertNil(newMonster.pos)
XCTAssertEqual(newMonster.name, "Frodo")
}
@Test
func testCreateMonsterUsingCreateMonsterMethodWithPosX() {
var fbb = FlatBufferBuilder(initialSize: 1)
let name = fbb.create(string: "Barney")
@@ -216,11 +207,10 @@ struct FlatBuffersMonsterWriterTests {
var buffer = fbb.sizedBuffer
let newMonster: Monster = getRoot(byteBuffer: &buffer)
#expect(newMonster.pos!.x == 10)
#expect(newMonster.name == "Barney")
XCTAssertEqual(newMonster.pos!.x, 10)
XCTAssertEqual(newMonster.name, "Barney")
}
@Test
func testReadMonsterFromUnsafePointerWithoutCopying() {
// swiftformat:disable all
var array: [UInt8] = [
@@ -252,7 +242,6 @@ struct FlatBuffersMonsterWriterTests {
readObjectApi(monster: unpacked)
}
@Test
func testArrayOfBools() {
let boolArray = [false, true, false, true, false, true, false]
var fbb = FlatBufferBuilder(initialSize: 1)
@@ -268,41 +257,37 @@ struct FlatBuffersMonsterWriterTests {
let monster: Monster = getRoot(byteBuffer: &buffer)
let values = monster.testarrayofbools
#expect(boolArray.count == values.count)
XCTAssertEqual(boolArray.count, values.count)
for (index, bool) in monster.testarrayofbools.enumerated() {
#expect(bool == boolArray[index])
XCTAssertEqual(bool, boolArray[index])
}
}
func readVerifiedMonster(fb: ByteBuffer) {
var byteBuffer = fb
do {
XCTAssertNoThrow(
try readMonster(
monster: getCheckedRoot(
byteBuffer: &byteBuffer) as MyGame_Example_Monster)
} catch {
Issue.record(error)
}
byteBuffer: &byteBuffer) as MyGame_Example_Monster))
}
@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)
readFlatbufferMonster(monster: &monster)
self.readFlatbufferMonster(monster: &monster)
return true
}
#expect(testAligned() == true)
XCTAssertEqual(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 {
Issue.record("Base pointer is not defined")
XCTFail("Base pointer is not defined")
return false
}
baseAddress = baseAddress.advanced(by: 1)
@@ -311,14 +296,13 @@ struct FlatBuffersMonsterWriterTests {
assumingMemoryBound: unlignedPtr,
capacity: ptr.count - 1)
var monster: Monster = getRoot(byteBuffer: &bytes)
readFlatbufferMonster(monster: &monster)
self.readFlatbufferMonster(monster: &monster)
return true
}
}
#expect(testUnaligned() == true)
XCTAssertEqual(testUnaligned(), true)
}
@Test
func testReadingRemovedSizeUnalignedBuffer() {
// Aligned read
let fbb = createMonster(withPrefix: true)
@@ -327,7 +311,7 @@ struct FlatBuffersMonsterWriterTests {
bytes.append(contentsOf: fbb.sizedByteArray)
return bytes.withUnsafeMutableBytes { ptr in
guard var baseAddress = ptr.baseAddress else {
Issue.record("Base pointer is not defined")
XCTFail("Base pointer is not defined")
return false
}
baseAddress = baseAddress.advanced(by: 1)
@@ -337,34 +321,32 @@ struct FlatBuffersMonsterWriterTests {
capacity: ptr.count - 1)
var newBuf = FlatBuffersUtils.removeSizePrefix(bb: bytes)
var monster: Monster = getRoot(byteBuffer: &newBuf)
readFlatbufferMonster(monster: &monster)
self.readFlatbufferMonster(monster: &monster)
return true
}
}
#expect(testUnaligned() == true)
XCTAssertEqual(testUnaligned(), true)
}
@Test
func testCreateMessage() {
let fbb = createMonster(withPrefix: false)
let byteBuffer = fbb.buffer
let firstMessage = GRPCMessage<Monster>(byteBuffer: byteBuffer)
let firstMessage = Message<Monster>(byteBuffer: byteBuffer)
firstMessage.withUnsafeReadableBytes { ptr in
var bytes = ByteBuffer(contiguousBytes: ptr, count: ptr.count)
var monster: Monster = getRoot(byteBuffer: &bytes)
readFlatbufferMonster(monster: &monster)
self.readFlatbufferMonster(monster: &monster)
}
let secondByteBuffer = fbb.sizedBuffer
let secondMessage = GRPCMessage<Monster>(byteBuffer: secondByteBuffer)
let secondMessage = Message<Monster>(byteBuffer: secondByteBuffer)
secondMessage.withUnsafeReadableBytes { ptr in
var bytes = ByteBuffer(contiguousBytes: ptr, count: ptr.count)
var monster: Monster = getRoot(byteBuffer: &bytes)
readFlatbufferMonster(monster: &monster)
self.readFlatbufferMonster(monster: &monster)
}
}
@Test
func testForceRetainedObject() {
let byteBuffer = {
// swiftformat:disable all
@@ -470,95 +452,95 @@ struct FlatBuffersMonsterWriterTests {
var fb = fb
let monster: Monster = getRoot(byteBuffer: &fb)
#expect(monster.mutate(mana: 10) == false)
#expect(monster.testarrayoftables[0].name == "Barney")
#expect(monster.testarrayoftables[1].name == "Frodo")
#expect(monster.testarrayoftables[2].name == "Wilma")
XCTAssertFalse(monster.mutate(mana: 10))
XCTAssertEqual(monster.testarrayoftables[0].name, "Barney")
XCTAssertEqual(monster.testarrayoftables[1].name, "Frodo")
XCTAssertEqual(monster.testarrayoftables[2].name, "Wilma")
// Example of searching for a table by the key
#expect(monster.testarrayoftablesBy(key: "Frodo") != nil)
#expect(monster.testarrayoftablesBy(key: "Barney") != nil)
#expect(monster.testarrayoftablesBy(key: "Wilma") != nil)
XCTAssertNotNil(monster.testarrayoftablesBy(key: "Frodo"))
XCTAssertNotNil(monster.testarrayoftablesBy(key: "Barney"))
XCTAssertNotNil(monster.testarrayoftablesBy(key: "Wilma"))
#expect(monster.testType == .monster)
XCTAssertEqual(monster.testType, .monster)
#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)
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)
for i in 0..<monster.inventory.count {
#expect(monster.inventory[i] == Byte(i + 1))
XCTAssertEqual(monster.inventory[i], Byte(i + 1))
}
#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)
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)
let vec = monster.mutablePos
#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)
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)
let mutableTest4 = monster.mutableTest4
let orignalValues = mutableTest4[0].a
#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)
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)
}
func readFlatbufferMonster(monster: inout MyGame_Example_Monster) {
#expect(monster.hp == 80)
#expect(monster.mana == 150)
#expect(monster.name == "MyMonster")
XCTAssertEqual(monster.hp, 80)
XCTAssertEqual(monster.mana, 150)
XCTAssertEqual(monster.name, "MyMonster")
let pos = monster.pos
#expect(pos?.x == 1)
#expect(pos?.y == 2)
#expect(pos?.z == 3)
#expect(pos?.test1 == 3)
#expect(pos?.test2 == .green)
XCTAssertEqual(pos?.x, 1)
XCTAssertEqual(pos?.y, 2)
XCTAssertEqual(pos?.z, 3)
XCTAssertEqual(pos?.test1, 3)
XCTAssertEqual(pos?.test2, .green)
let test = pos?.test3
#expect(test?.a == 5)
#expect(test?.b == 6)
#expect(monster.testType == .monster)
XCTAssertEqual(test?.a, 5)
XCTAssertEqual(test?.b, 6)
XCTAssertEqual(monster.testType, .monster)
let monster2 = monster.test(type: Monster.self)
#expect(monster2?.name == "Fred")
XCTAssertEqual(monster2?.name, "Fred")
#expect(monster.mutate(mana: 10) == false)
XCTAssertEqual(monster.mutate(mana: 10), false)
#expect(monster.mana == 150)
#expect(monster.inventory.count == 5)
XCTAssertEqual(monster.mana, 150)
XCTAssertEqual(monster.inventory.count, 5)
var sum: Byte = 0
for inventory in monster.inventory {
sum += inventory
}
#expect(sum == 10)
XCTAssertEqual(sum, 10)
monster.withUnsafePointerToInventory { ptr, count in
var sum: UInt8 = 0
for pointee in ptr.startIndex..<ptr.endIndex {
sum += ptr[pointee]
}
#expect(sum == 10)
XCTAssertEqual(sum, 10)
}
#expect(monster.test4.count == 2)
XCTAssertEqual(monster.test4.count, 2)
let test4 = monster.test4
var sum0 = 0
for test0 in test4 {
sum0 += Int(test0.a) + Int(test0.b)
}
#expect(sum0 == 100)
XCTAssertEqual(sum0, 100)
monster.withUnsafePointerToTest4 { ptr, count in
guard let ptr = ptr.baseAddress else { return }
@@ -574,7 +556,7 @@ struct FlatBuffersMonsterWriterTests {
pointerSum += Int(bindedMemory[pointee].a) +
Int(bindedMemory[pointee].b)
}
#expect(pointerSum == 100)
XCTAssertEqual(pointerSum, 100)
}
let mutableTest4 = monster.mutableTest4
@@ -582,84 +564,87 @@ struct FlatBuffersMonsterWriterTests {
for test0 in mutableTest4 {
sum2 += Int(test0.a) + Int(test0.b)
}
#expect(sum2 == 100)
XCTAssertEqual(sum2, 100)
let stringArray = monster.testarrayofstring
#expect(stringArray.count == 2)
#expect(stringArray[0] == "test1")
#expect(stringArray[1] == "test2")
#expect(monster.testbool == true)
XCTAssertEqual(stringArray.count, 2)
XCTAssertEqual(stringArray[0], "test1")
XCTAssertEqual(stringArray[1], "test2")
XCTAssertEqual(monster.testbool, true)
let array = monster.nameSegmentArray
#expect(String(bytes: array ?? [], encoding: .utf8) == "MyMonster")
XCTAssertEqual(String(bytes: array ?? [], encoding: .utf8), "MyMonster")
if 0 == monster.testarrayofbools.count {
#expect(monster.testarrayofbools.isEmpty == true)
XCTAssertEqual(monster.testarrayofbools.isEmpty, true)
} else {
#expect(monster.testarrayofbools.isEmpty == false)
XCTAssertEqual(monster.testarrayofbools.isEmpty, false)
}
}
func readObjectApi(monster: MyGame_Example_MonsterT) {
#expect(monster.hp == 80)
#expect(monster.mana == 150)
#expect(monster.name == "MyMonster")
XCTAssertEqual(monster.hp, 80)
XCTAssertEqual(monster.mana, 150)
XCTAssertEqual(monster.name, "MyMonster")
let pos = monster.pos
#expect(pos?.x == 1)
#expect(pos?.y == 2)
#expect(pos?.z == 3)
#expect(pos?.test1 == 3)
#expect(pos?.test2 == .green)
XCTAssertEqual(pos?.x, 1)
XCTAssertEqual(pos?.y, 2)
XCTAssertEqual(pos?.z, 3)
XCTAssertEqual(pos?.test1, 3)
XCTAssertEqual(pos?.test2, .green)
let test = pos?.test3
#expect(test?.a == 5)
#expect(test?.b == 6)
XCTAssertEqual(test?.a, 5)
XCTAssertEqual(test?.b, 6)
let monster2 = monster.test?.value as? MyGame_Example_MonsterT
#expect(monster2?.name == "Fred")
#expect(monster.mana == 150)
XCTAssertEqual(monster2?.name, "Fred")
XCTAssertEqual(monster.mana, 150)
monster.mana = 10
#expect(monster.mana == 10)
XCTAssertEqual(monster.mana, 10)
monster.mana = 150
#expect(monster.mana == 150)
XCTAssertEqual(monster.mana, 150)
#expect(monster.inventory.count == 5)
XCTAssertEqual(monster.inventory.count, 5)
var sum: Byte = 0
for i in monster.inventory {
sum += i
}
#expect(sum == 10)
#expect(monster.test4.count == 2)
XCTAssertEqual(sum, 10)
XCTAssertEqual(monster.test4.count, 2)
var sum0 = 0
for test in monster.test4 {
sum0 += Int(test.a) + Int(test.b)
}
#expect(sum0 == 100)
#expect(monster.testbool == true)
XCTAssertEqual(sum0, 100)
XCTAssertEqual(monster.testbool, true)
}
@Test
func testEncoding() throws {
func testEncoding() {
let fbb = createMonster(withPrefix: false)
var sizedBuffer = fbb.sizedBuffer
struct Test: Decodable {
struct Pos: Decodable {
let x, y, z: Int
do {
struct Test: Decodable {
struct Pos: Decodable {
let x, y, z: Int
}
let hp: Int
let inventory: [UInt8]
let name: String
let pos: Pos
}
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)
XCTAssertEqual(value.name, "MyMonster")
XCTAssertEqual(value.pos.x, 1)
XCTAssertEqual(value.pos.y, 2)
XCTAssertEqual(value.pos.z, 3)
} catch {
XCTFail(error.localizedDescription)
}
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 {
@@ -668,7 +653,6 @@ struct FlatBuffersMonsterWriterTests {
"""
}
@Test
func testContiguousBytes() {
let byteArray: [UInt8] = [3, 1, 4, 1, 5, 9]
var fbb = FlatBufferBuilder(initialSize: 1)
@@ -686,7 +670,7 @@ struct FlatBuffersMonsterWriterTests {
monster.withUnsafePointerToInventory { ptr, count in
let array = Array(ptr)
for (index, value) in values.enumerated() {
#expect(array[index] == value)
XCTAssertEqual(array[index], value)
}
}
}
tests/swift/Tests/Flatbuffers/FlatBuffersNanInfTests.swift
+52 -50
View File
@@ -14,59 +14,11 @@
* limitations under the License.
*/
import Foundation
import Testing
import XCTest
@testable import FlatBuffers
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)
#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)
}
@Test
func testInfNanJSON() throws {
let fbb = createTestTable()
var bb = fbb.sizedBuffer
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(
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)
}
final class FlatBuffersNanInfTests: XCTestCase {
func createTestTable() -> FlatBufferBuilder {
var fbb = FlatBufferBuilder()
@@ -79,4 +31,54 @@ struct FlatBuffersNanInfTests {
fbb.finish(offset: msg)
return fbb
}
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)
}
func testInfNanJSON() {
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(
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)
}
}
}
tests/swift/Tests/Flatbuffers/FlatBuffersStructsTests.swift
+5 -6
View File
@@ -14,13 +14,12 @@
* limitations under the License.
*/
import Testing
import XCTest
@testable import FlatBuffers
struct FlatBuffersStructsTests {
final class FlatBuffersStructsTests: XCTestCase {
@Test
func testWritingAndMutatingBools() {
var fbb = FlatBufferBuilder()
let start = TestMutatingBool.startTestMutatingBool(&fbb)
@@ -31,11 +30,11 @@ struct FlatBuffersStructsTests {
var buffer = fbb.sizedBuffer
let testMutatingBool: TestMutatingBool = getRoot(byteBuffer: &buffer)
let property = testMutatingBool.mutableB
#expect(property?.property == false)
XCTAssertEqual(property?.property, false)
property?.mutate(property: false)
#expect(property?.property == false)
XCTAssertEqual(property?.property, false)
property?.mutate(property: true)
#expect(property?.property == true)
XCTAssertEqual(property?.property, true)
}
}
tests/swift/Tests/Flatbuffers/FlatBuffersTests.swift
+29 -39
View File
@@ -14,49 +14,44 @@
* limitations under the License.
*/
import Testing
import XCTest
@testable import Common
@testable import FlatBuffers
struct FlatBuffersTests {
final class FlatBuffersTests: XCTestCase {
let country = "Norway"
@Test
func testEndian() { #expect(isLitteEndian == true) }
func testEndian() { XCTAssertEqual(isLitteEndian, true) }
@Test
func testOffset() {
let o = Offset()
let b = Offset(offset: 1)
#expect(o.isEmpty == true)
#expect(b.isEmpty == false)
XCTAssertEqual(o.isEmpty, true)
XCTAssertEqual(b.isEmpty, false)
}
@Test
func testCreateString() {
let helloWorld = "Hello, world!"
var b = FlatBufferBuilder(initialSize: 16)
#expect(b.create(string: country).o == 12)
#expect(b.create(string: helloWorld).o == 32)
XCTAssertEqual(b.create(string: country).o, 12)
XCTAssertEqual(b.create(string: helloWorld).o, 32)
b.clear()
#expect(b.create(string: helloWorld).o == 20)
#expect(b.create(string: country).o == 32)
XCTAssertEqual(b.create(string: helloWorld).o, 20)
XCTAssertEqual(b.create(string: country).o, 32)
b.clear()
#expect(b.create(string: String(repeating: "a", count: 257)).o == 264)
XCTAssertEqual(b.create(string: String(repeating: "a", count: 257)).o, 264)
}
@Test
func testStartTable() {
var b = FlatBufferBuilder(initialSize: 16)
_ = b.startTable(with: 0)
XCTAssertNoThrow(b.startTable(with: 0))
b.clear()
#expect(b.create(string: country).o == 12)
#expect(b.startTable(with: 0) == 12)
XCTAssertEqual(b.create(string: country).o, 12)
XCTAssertEqual(b.startTable(with: 0), 12)
}
@Test
func testCreateFinish() {
var b = FlatBufferBuilder(initialSize: 16)
let countryOff = Country.createCountry(
@@ -71,10 +66,9 @@ struct FlatBuffersTests {
200, 0, 0, 0, 6, 0, 0, 0, 78, 111, 114, 119, 97, 121, 0, 0,
]
// swiftformat:enable all
#expect(b.sizedByteArray == v)
XCTAssertEqual(b.sizedByteArray, v)
}
@Test
func testCreateFinishWithPrefix() {
var b = FlatBufferBuilder(initialSize: 16)
let countryOff = Country.createCountry(
@@ -89,10 +83,9 @@ struct FlatBuffersTests {
100, 0, 0, 0, 200, 0, 0, 0, 6, 0, 0, 0, 78, 111, 114, 119, 97, 121, 0, 0,
]
// swiftformat:enable all
#expect(b.sizedByteArray == v)
XCTAssertEqual(b.sizedByteArray, v)
}
@Test
func testReadCountry() {
// swiftformat:disable all
let v: [UInt8] = [
@@ -102,20 +95,18 @@ struct FlatBuffersTests {
// swiftformat:enable all
let buffer = ByteBuffer(bytes: v)
let c = Country.getRootAsCountry(buffer)
#expect(c.lan == 100)
#expect(c.log == 200)
#expect(c.nameVector == [78, 111, 114, 119, 97, 121])
#expect(c.name == country)
XCTAssertEqual(c.lan, 100)
XCTAssertEqual(c.log, 200)
XCTAssertEqual(c.nameVector, [78, 111, 114, 119, 97, 121])
XCTAssertEqual(c.name, country)
}
@Test
func testWriteNullableStrings() {
var b = FlatBufferBuilder()
#expect(b.create(string: nil).isEmpty)
#expect(b.createShared(string: nil).isEmpty)
XCTAssertTrue(b.create(string: nil).isEmpty)
XCTAssertTrue(b.createShared(string: nil).isEmpty)
}
@Test
func testWriteOptionalValues() {
var b = FlatBufferBuilder()
let root = optional_scalars_ScalarStuff.createScalarStuff(
@@ -130,17 +121,16 @@ struct FlatBuffersTests {
b.finish(offset: root)
var buffer = b.sizedBuffer
let scalarTable: optional_scalars_ScalarStuff = getRoot(byteBuffer: &buffer)
#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)
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)
}
@Test
func testAlignmentCrash() {
var builder = FlatBufferBuilder(initialSize: 256)
tests/swift/Tests/Flatbuffers/FlatBuffersUnionTests.swift
+67 -70
View File
@@ -14,14 +14,12 @@
* limitations under the License.
*/
import Foundation
import Testing
import XCTest
@testable import FlatBuffers
struct FlatBuffersUnionTests {
final class FlatBuffersUnionTests: XCTestCase {
@Test
func testCreateMonstor() {
var b = FlatBufferBuilder(initialSize: 20)
@@ -38,8 +36,8 @@ struct FlatBuffersUnionTests {
b.finish(offset: root)
let buffer = b.sizedByteArray
// swiftformat:disable all
#expect(
buffer ==
XCTAssertEqual(
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,
@@ -47,16 +45,15 @@ struct FlatBuffersUnionTests {
])
// swiftformat:enable all
let monster = LocalMonster.getRootAsMonster(bb: ByteBuffer(bytes: buffer))
#expect(monster.weapon(at: 0)?.dmg == dmg)
#expect(monster.weapon(at: 0)?.name == str)
#expect(monster.weapon(at: 0)?.nameVector == [65, 120, 101])
XCTAssertEqual(monster.weapon(at: 0)?.dmg, dmg)
XCTAssertEqual(monster.weapon(at: 0)?.name, str)
XCTAssertEqual(monster.weapon(at: 0)?.nameVector, [65, 120, 101])
let p: Weapon? = monster.equiped()
#expect(p?.dmg == dmg)
#expect(p?.name == str)
#expect(p?.nameVector == [65, 120, 101])
XCTAssertEqual(p?.dmg, dmg)
XCTAssertEqual(p?.name, str)
XCTAssertEqual(p?.nameVector, [65, 120, 101])
}
@Test
func testEndTableFinish() {
var builder = FlatBufferBuilder(initialSize: 20)
let sword = builder.create(string: "Sword")
@@ -87,8 +84,8 @@ struct FlatBuffersUnionTests {
path: path)
builder.finish(offset: orc)
// swiftformat:disable all
#expect(
builder.sizedByteArray ==
XCTAssertEqual(
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,
@@ -102,7 +99,6 @@ struct FlatBuffersUnionTests {
// swiftformat:enable all
}
@Test
func testEnumVector() {
let vectorOfEnums: [ColorsNameSpace.RGB] = [.blue, .green]
@@ -113,8 +109,8 @@ struct FlatBuffersUnionTests {
let end = ColorsNameSpace.Monster.endMonster(&builder, start: start)
builder.finish(offset: end)
// swiftformat:disable all
#expect(
builder.sizedByteArray ==
XCTAssertEqual(
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,
@@ -122,13 +118,12 @@ struct FlatBuffersUnionTests {
// swiftformat:enable all
let monster = ColorsNameSpace.Monster
.getRootAsMonster(bb: builder.sizedBuffer)
#expect(monster.colorsCount == 2)
XCTAssertEqual(monster.colorsCount, 2)
let colors = monster.colors
#expect(colors[0] == .blue)
#expect(colors[1] == .green)
XCTAssertEqual(colors[0], .blue)
XCTAssertEqual(colors[1], .green)
}
@Test
func testUnionVector() {
var fb = FlatBufferBuilder()
@@ -154,30 +149,30 @@ struct FlatBuffersUnionTests {
var buffer = fb.sizedBuffer
let movie: Movie = getRoot(byteBuffer: &buffer)
#expect(movie.charactersType.count == characterType.count)
#expect(movie.characters.count == characters.count)
XCTAssertEqual(movie.charactersType.count, characterType.count)
XCTAssertEqual(movie.characters.count, characters.count)
let bufferCharactersType = movie.charactersType
for (index, element) in bufferCharactersType.enumerated() {
#expect(element == characterType[index])
XCTAssertEqual(element, characterType[index])
}
#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)
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)
var objc: MovieT? = movie.unpack()
#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)
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)
fb.clear()
let newMovie = Movie.pack(&fb, obj: &objc)
fb.finish(offset: newMovie)
@@ -185,18 +180,17 @@ struct FlatBuffersUnionTests {
var _buffer = fb.sizedBuffer
let packedMovie: Movie = getRoot(byteBuffer: &_buffer)
#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)
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)
}
@Test
func testStringUnion() {
let string = "Awesome \\\\t\t\nstring!"
var fb = FlatBufferBuilder()
@@ -220,31 +214,30 @@ struct FlatBuffersUnionTests {
var buffer = fb.sizedBuffer
let movie: Movie = getRoot(byteBuffer: &buffer)
#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)
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)
var objc: MovieT? = movie.unpack()
#expect(objc?.mainCharacter?.value as? String == string)
#expect((objc?.characters[0]?.value as? BookReader)?.booksRead == 7)
#expect(objc?.characters[1]?.value as? String == string)
XCTAssertEqual(objc?.mainCharacter?.value as? String, string)
XCTAssertEqual((objc?.characters[0]?.value as? BookReader)?.booksRead, 7)
XCTAssertEqual(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)
#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)
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)
}
@Test
func testEncoding() throws {
func testEncoding() {
let string = "Awesome \\\\t\t\nstring!"
var fb = FlatBufferBuilder()
@@ -272,12 +265,16 @@ struct FlatBuffersUnionTests {
Movie.finish(&fb, end: end)
var sizedBuffer = fb.sizedBuffer
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)
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)
}
}
var jsonData: String {
tests/swift/Tests/Flatbuffers/FlatBuffersVectorsTests.swift
+22 -31
View File
@@ -14,13 +14,12 @@
* limitations under the License.
*/
import Testing
import XCTest
@testable import FlatBuffers
struct FlatBuffersVectors {
final class FlatBuffersVectors: XCTestCase {
@Test
func testCreatingTwoCountries() {
let norway = "Norway"
let denmark = "Denmark"
@@ -41,8 +40,8 @@ struct FlatBuffersVectors {
let vectorOffset = b.createVector(ofOffsets: vector)
b.finish(offset: vectorOffset)
// swiftformat:disable all
#expect(
b.sizedByteArray ==
XCTAssertEqual(
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,
@@ -52,20 +51,18 @@ struct FlatBuffersVectors {
// 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
#expect(
b.sizedByteArray ==
XCTAssertEqual(
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
@@ -79,8 +76,8 @@ struct FlatBuffersVectors {
let o = b.createVector(ofStructs: vector)
b.finish(offset: o)
// swiftformat:disable all
#expect(
b.sizedByteArray ==
XCTAssertEqual(
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,
@@ -88,31 +85,28 @@ struct FlatBuffersVectors {
// 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)
#expect(b.sizedByteArray == [4, 0, 0, 0, 0, 0, 0, 0])
XCTAssertEqual(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
#expect(
b.sizedByteArray ==
XCTAssertEqual(
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"
@@ -125,8 +119,8 @@ struct FlatBuffersVectors {
let end = b.createVector(ofOffsets: v)
b.finish(offset: end)
// swiftformat:disable all
#expect(
b.sizedByteArray ==
XCTAssertEqual(
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,
@@ -134,7 +128,6 @@ struct FlatBuffersVectors {
// swiftformat:enable all
}
@Test
func testReadInt32Array() {
let data: [Int32] = [1, 2, 3, 4, 5]
var b = FlatBufferBuilder(initialSize: 20)
@@ -143,11 +136,10 @@ struct FlatBuffersVectors {
b.finish(offset: end)
let number = Numbers.getRootAsNumbers(ByteBuffer(bytes: b.sizedByteArray))
for (index, num) in number.vArrayInt32.enumerated() {
#expect(num == data[index])
XCTAssertEqual(num, data[index])
}
}
@Test
func testReadDoubleArray() {
let data: [Double] = [1, 2, 3, 4, 5]
var b = FlatBufferBuilder(initialSize: 20)
@@ -156,11 +148,10 @@ struct FlatBuffersVectors {
b.finish(offset: end)
let number = Numbers.getRootAsNumbers(ByteBuffer(bytes: b.sizedByteArray))
for (index, num) in number.vArrayDouble.enumerated() {
#expect(num == data[index])
XCTAssertEqual(num, data[index])
}
}
@Test
func testHasForArray() {
var builder = FlatBufferBuilder(initialSize: 20)
let emptyVector = [UInt8]()
@@ -175,14 +166,14 @@ struct FlatBuffersVectors {
var byteBuffer = ByteBuffer(bytes: builder.sizedByteArray)
let msg: Swift_Tests_Vectors = getRoot(byteBuffer: &byteBuffer)
#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)
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)
for i in msg.array.startIndex..<msg.array.endIndex {
#expect(msg.array[i] == 1 + UInt64(i))
XCTAssertEqual(msg.array[i], 1 + UInt64(i))
}
let array = msg.withUnsafePointerToArray { ptr, count in
@@ -194,7 +185,7 @@ struct FlatBuffersVectors {
return Array(ptr)
}
#expect(array == [1, 2, 3])
XCTAssertEqual(array, [1, 2, 3])
}
}
tests/swift/Tests/Flatbuffers/FlatbuffersDoubleTests.swift
+4 -6
View File
@@ -14,15 +14,14 @@
* limitations under the License.
*/
import Testing
import XCTest
@testable import FlatBuffers
struct FlatBuffersDoubleTests {
final class FlatBuffersDoubleTests: XCTestCase {
let country = "Norway"
@Test
func testCreateFinish() {
var b = FlatBufferBuilder(initialSize: 16)
let countryOff = CountryDouble.createCountry(
@@ -39,10 +38,9 @@ struct FlatBuffersDoubleTests {
97, 121, 0, 0,
]
// swiftformat:enable all
#expect(b.sizedByteArray == v)
XCTAssertEqual(b.sizedByteArray, v)
}
@Test
func testCreateFinishWithPrefix() {
var b = FlatBufferBuilder(initialSize: 16)
let countryOff = CountryDouble.createCountry(
@@ -59,7 +57,7 @@ struct FlatBuffersDoubleTests {
0, 6, 0, 0, 0, 78, 111, 114, 119, 97, 121, 0, 0,
]
// swiftformat:enable all
#expect(b.sizedByteArray == v)
XCTAssertEqual(b.sizedByteArray, v)
}
}
tests/swift/Tests/Flatbuffers/FlatbuffersMoreDefaults.swift
+42 -39
View File
@@ -15,11 +15,11 @@
*/
import Foundation
import Testing
import XCTest
@testable import FlatBuffers
struct FlatBuffersMoreDefaults {
class FlatBuffersMoreDefaults: XCTestCase {
func testFlatbuffersObject() {
var fbb = FlatBufferBuilder()
@@ -27,58 +27,61 @@ struct FlatBuffersMoreDefaults {
fbb.finish(offset: root)
var byteBuffer = fbb.sizedBuffer
let defaults: MoreDefaults = getRoot(byteBuffer: &byteBuffer)
#expect(defaults.emptyString == "")
#expect(defaults.someString == "some")
#expect(defaults.ints.isEmpty == true)
#expect(defaults.floats.isEmpty == true)
#expect(defaults.bools.isEmpty == true)
#expect(defaults.ints.count == 0)
#expect(defaults.floats.count == 0)
#expect(defaults.abcs.count == 0)
#expect(defaults.bools.count == 0)
XCTAssertEqual(defaults.emptyString, "")
XCTAssertEqual(defaults.someString, "some")
XCTAssertEqual(defaults.ints.isEmpty, true)
XCTAssertEqual(defaults.floats.isEmpty, true)
XCTAssertEqual(defaults.bools.isEmpty, true)
XCTAssertEqual(defaults.ints.count, 0)
XCTAssertEqual(defaults.floats.count, 0)
XCTAssertEqual(defaults.abcs.count, 0)
XCTAssertEqual(defaults.bools.count, 0)
}
func testFlatbuffersObjectAPI() {
var fbb = FlatBufferBuilder()
let defaults = MoreDefaultsT()
#expect(defaults.emptyString == "")
#expect(defaults.someString == "some")
#expect(defaults.ints == [])
#expect(defaults.floats == [])
#expect(defaults.abcs == [])
#expect(defaults.bools == [])
XCTAssertEqual(defaults.emptyString, "")
XCTAssertEqual(defaults.someString, "some")
XCTAssertEqual(defaults.ints, [])
XCTAssertEqual(defaults.floats, [])
XCTAssertEqual(defaults.abcs, [])
XCTAssertEqual(defaults.bools, [])
var buffer = defaults.serialize(builder: &fbb, type: MoreDefaults.self)
let fDefaults: MoreDefaults = getRoot(byteBuffer: &buffer)
#expect(fDefaults.emptyString == "")
#expect(fDefaults.someString == "some")
#expect(fDefaults.ints.isEmpty == true)
#expect(fDefaults.floats.isEmpty == true)
#expect(fDefaults.ints.count == 0)
#expect(fDefaults.floats.count == 0)
#expect(fDefaults.abcs.count == 0)
#expect(fDefaults.bools.count == 0)
XCTAssertEqual(fDefaults.emptyString, "")
XCTAssertEqual(fDefaults.someString, "some")
XCTAssertEqual(fDefaults.ints.isEmpty, true)
XCTAssertEqual(fDefaults.floats.isEmpty, true)
XCTAssertEqual(fDefaults.ints.count, 0)
XCTAssertEqual(fDefaults.floats.count, 0)
XCTAssertEqual(fDefaults.abcs.count, 0)
XCTAssertEqual(fDefaults.bools.count, 0)
}
@Test
func testEncoding() throws {
func testEncoding() {
var fbb = FlatBufferBuilder()
let root = MoreDefaults.createMoreDefaults(&fbb)
fbb.finish(offset: root)
var sizedBuffer = fbb.sizedBuffer
struct Test: Decodable {
var emptyString: String
var someString: String
do {
struct Test: Decodable {
var emptyString: String
var someString: String
}
let reader: MoreDefaults = 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.someString, "some")
XCTAssertEqual(value.emptyString, "")
} catch {
XCTFail(error.localizedDescription)
}
let reader: MoreDefaults = 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.someString == "some")
#expect(value.emptyString == "")
}
}
tests/swift/Tests/Flatbuffers/FlatbuffersVerifierTests.swift
+154 -303
View File
@@ -14,20 +14,25 @@
* limitations under the License.
*/
import Testing
import XCTest
@testable import FlatBuffers
final class FlatbuffersVerifierTests {
final class FlatbuffersVerifierTests: XCTestCase {
private var buffer: ByteBuffer
private var validFlatbuffersObject: ByteBuffer
private var invalidFlatbuffersObject: ByteBuffer
private var invalidFlatbuffersObject2: ByteBuffer
private var invalidFlatbuffersObject3: ByteBuffer
var buffer: ByteBuffer!
var validFlatbuffersObject: ByteBuffer!
var invalidFlatbuffersObject: ByteBuffer!
var invalidFlatbuffersObject2: ByteBuffer!
var invalidFlatbuffersObject3: ByteBuffer!
init() {
override func setUp() {
// 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,
@@ -89,250 +94,186 @@ final class FlatbuffersVerifierTests {
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
}
@Test
func testVeriferInitPassing() throws {
func testVeriferInitPassing() {
let memory = UnsafeMutableRawPointer.allocate(byteCount: 8, alignment: 1)
var buffer = ByteBuffer(
assumingMemoryBound: memory,
capacity: Int(FlatBufferMaxSize) - 1)
_ = try Verifier(buffer: &buffer)
XCTAssertNoThrow(try Verifier(buffer: &buffer))
}
@Test
func testVeriferInitFailing() {
let memory = UnsafeMutableRawPointer.allocate(byteCount: 8, alignment: 1)
var buffer = ByteBuffer(
assumingMemoryBound: memory,
capacity: Int(FlatBufferMaxSize) + 1)
#expect(throws: FlatbuffersErrors.exceedsMaxSizeAllowed) {
try Verifier(buffer: &buffer)
}
XCTAssertThrowsError(try Verifier(buffer: &buffer))
}
@Test
func testFailingID() {
let dutData: [UInt8] = [1, 2, 3, 4, 5, 6, 7]
var buff = ByteBuffer(bytes: dutData)
#expect(throws: FlatbuffersErrors.bufferDoesntContainID) {
do {
let _: Monster = try getCheckedRoot(byteBuffer: &buff, fileId: "ABCD")
XCTFail("This should always fail")
} catch {
XCTAssertEqual(error as? FlatbuffersErrors, .bufferDoesntContainID)
}
}
@Test
func testVerifierCheckAlignment() throws {
func testVerifierCheckAlignment() {
let verifier = try! Verifier(buffer: &buffer)
#expect(throws: FlatbuffersErrors.missAlignedPointer(
position: 20,
type: "Int"))
{
do {
try verifier.isAligned(position: 20, type: Int.self)
} catch {
XCTAssertEqual(
error as? FlatbuffersErrors,
.missAlignedPointer(position: 20, type: "Int"))
}
try verifier.isAligned(position: 16, type: Int.self)
XCTAssertNoThrow(try verifier.isAligned(position: 16, type: Int.self))
let newVerifer = try! Verifier(buffer: &buffer, checkAlignment: false)
try newVerifer.isAligned(position: 16, type: Int.self)
XCTAssertNoThrow(try newVerifer.isAligned(position: 16, type: Int.self))
}
@Test
func testRangeInBuffer() throws {
func testRangeInBuffer() {
var verifier = try! Verifier(buffer: &buffer)
let size = MemoryLayout<Int64>.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)
}
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))
verifier = try! Verifier(
buffer: &buffer,
options: .init(maxDepth: 0, maxTableCount: 0, maxApparentSize: 4))
#expect(throws: FlatbuffersErrors.apparentSizeTooLarge) {
do {
try verifier.rangeInBuffer(position: 24, size: size)
} catch {
XCTAssertEqual(
error as! FlatbuffersErrors,
.apparentSizeTooLarge)
}
}
@Test
func testPositionInBuffer() throws {
func testPositionInBuffer() {
let verifier = try! Verifier(buffer: &buffer)
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)
}
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))
}
@Test
func testVisitTable() throws {
func testVisitTable() {
var verifier = try! Verifier(buffer: &validFlatbuffersObject)
_ = try verifier.visitTable(at: 48)
XCTAssertNoThrow(try verifier.visitTable(at: 48))
verifier.reset()
}
@Test
func testTableVerifier() throws {
func testTableVerifier() {
var verifier = try! Verifier(buffer: &validFlatbuffersObject)
var tableVerifer = try! verifier.visitTable(at: 48)
#expect(verifier.depth == 1)
#expect(verifier.tableCount == 1)
XCTAssertEqual(verifier.depth, 1)
XCTAssertEqual(verifier.tableCount, 1)
try tableVerifer.visit(
field: 4,
fieldName: "Vec",
required: false,
type: Vec3.self)
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: 8,
fieldName: "hp",
required: false,
type: Int16.self)
XCTAssertNoThrow(
try tableVerifer.visit(
field: 10,
fieldName: "name",
required: true,
type: ForwardOffset<String>.self))
try tableVerifer.visit(
field: 10,
fieldName: "name",
required: true,
type: ForwardOffset<String>.self)
XCTAssertNoThrow(
try tableVerifer.visit(
field: 14,
fieldName: "inventory",
required: false,
type: ForwardOffset<Vector<UInt8, UInt8>>.self))
try tableVerifer.visit(
field: 14,
fieldName: "inventory",
required: false,
type: ForwardOffset<Vector<UInt8, UInt8>>.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: 22,
fieldName: "test4",
required: false,
type: ForwardOffset<Vector<MyGame_Example_Test, MyGame_Example_Test>>
.self)
XCTAssertNoThrow(
try tableVerifer.visit(
field: 24,
fieldName: "Vector of strings",
required: false,
type: ForwardOffset<Vector<ForwardOffset<String>, String>>.self))
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"))
{
do {
try tableVerifer.visit(
field: 13,
fieldName: "notvalid",
required: false,
type: Int16.self)
} 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<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)
}
})
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)
case .testsimpletablewithenum:
break
case .mygameExample2Monster:
break
}
})
} catch {
XCTAssertEqual(
error as! FlatbuffersErrors,
.missAlignedPointer(position: 25, type: "UInt16"))
}
tableVerifer.finish()
#expect(verifier.depth == 0)
XCTAssertEqual(verifier.depth, 0)
}
@Test
func testVerifyUnionVectors() throws {
func testVerifyUnionVectors() {
// 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,
@@ -340,11 +281,10 @@ final class FlatbuffersVerifierTests {
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
_ = try getCheckedRoot(byteBuffer: &byteBuffer) as Movie
XCTAssertNoThrow(try getCheckedRoot(byteBuffer: &byteBuffer) as Movie)
}
@Test
func testErrorWrongFileId() throws{
func testErrorWrongFileId() {
// 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,
@@ -352,14 +292,12 @@ final class FlatbuffersVerifierTests {
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
#expect(throws: FlatbuffersErrors.bufferIdDidntMatchPassedId) {
XCTAssertThrowsError(
try getCheckedRoot(
byteBuffer: &byteBuffer,
fileId: "FLEX") as Movie
}
fileId: "FLEX") as Movie)
}
@Test
func testVerifyPrefixedBuffer() {
// swiftformat:disable all
var byteBuffer = ByteBuffer(bytes: [
@@ -368,123 +306,41 @@ final class FlatbuffersVerifierTests {
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
#expect(throws: FlatbuffersErrors.prefixedSizeNotEqualToBufferSize) {
try getCheckedPrefixedSizeRoot(byteBuffer: &byteBuffer) as Movie
}
XCTAssertThrowsError(
try getCheckedPrefixedSizeRoot(byteBuffer: &byteBuffer) as Movie)
}
@Test
func testSizePrefixedVerifierUsesPostPrefixRoot() throws {
// The size prefix points to a valid empty decoy table at byte 44. The real
// root at byte 4 points to a truncated UInt64 vector that must be rejected.
let bytes: [UInt8] = [
44, 0, 0, 0,
16, 0, 0, 0,
6, 0, 8, 0, 4, 0,
0, 0, 0, 0, 0, 0,
12, 0, 0, 0,
8, 0, 0, 0, 0, 0, 0, 0,
2, 0, 0, 0, 65, 66,
0, 0,
4, 0, 4, 0,
4, 0, 0, 0,
]
var strictBuffer = ByteBuffer(bytes: bytes)
#expect(throws: FlatbuffersErrors.self) {
try getCheckedPrefixedSizeRoot(
byteBuffer: &strictBuffer) as Swift_Tests_Vectors
}
var prefixedBuffer = ByteBuffer(bytes: bytes)
#expect(throws: FlatbuffersErrors.self) {
try getPrefixedSizeCheckedRoot(
byteBuffer: &prefixedBuffer) as Swift_Tests_Vectors
}
var builder = FlatBufferBuilder()
let movie = Movie.createMovie(&builder)
Movie.finish(&builder, end: movie, prefix: true)
var validBuffer = builder.sizedBuffer
let _: Movie = try getCheckedPrefixedSizeRoot(
byteBuffer: &validBuffer,
fileId: Movie.id)
var shortBuffer = ByteBuffer(bytes: [0, 0, 0, 0])
#expect(throws: FlatbuffersErrors.bufferDoesntContainID) {
func testFullVerifier() {
XCTAssertNoThrow(
try getCheckedRoot(
byteBuffer: &shortBuffer,
fileId: Movie.id) as Movie
}
var oversizedPrefix = ByteBuffer(bytes: [5, 0, 0, 0, 0, 0, 0, 0])
#expect(throws: FlatbuffersErrors.outOfBounds(position: 9, end: 8)) {
try getPrefixedSizeCheckedRoot(
byteBuffer: &oversizedPrefix) as Movie
}
#expect(oversizedPrefix.reader == 0)
byteBuffer: &validFlatbuffersObject) as MyGame_Example_Monster)
}
@Test
func testFullVerifier() throws {
_ =
func testFullVerifierWithFileId() {
XCTAssertNoThrow(
try getCheckedRoot(
byteBuffer: &validFlatbuffersObject) as MyGame_Example_Monster
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() {
#expect(throws: FlatbuffersErrors.self) {
XCTAssertThrowsError(
try getCheckedRoot(
byteBuffer: &self.invalidFlatbuffersObject) as MyGame_Example_Monster
}
byteBuffer: &invalidFlatbuffersObject) as MyGame_Example_Monster)
}
@Test
func testInvalidBuffer2() {
#expect(throws: FlatbuffersErrors.self) {
XCTAssertThrowsError(
try getCheckedRoot(
byteBuffer: &self.invalidFlatbuffersObject2) as MyGame_Example_Monster
}
byteBuffer: &invalidFlatbuffersObject2) as MyGame_Example_Monster)
}
@Test
func testInvalidBuffer3() {
#expect(throws: FlatbuffersErrors.self) {
XCTAssertThrowsError(
try getCheckedRoot(
byteBuffer: &self.invalidFlatbuffersObject3) as MyGame_Example_Monster
}
byteBuffer: &invalidFlatbuffersObject3) as MyGame_Example_Monster)
}
@Test(.bug("https://github.com/google/flatbuffers/issues/9082"))
func testRejectsTruncatedScalarVector() {
// swiftformat:disable all
var byteBuffer = ByteBuffer(bytes: [
16, 0, 0, 0,
6, 0, 8, 0,
4, 0, 0, 0,
0, 0, 0, 0,
12, 0, 0, 0,
8, 0, 0, 0,
0, 0, 0, 0,
2, 0, 0, 0,
65, 66,
])
// swiftformat:enable all
#expect(throws: FlatbuffersErrors.self) {
try getCheckedRoot(byteBuffer: &byteBuffer) as Swift_Tests_Vectors
}
}
@Test
func testValidUnionBuffer() {
let string = "Awesome \\\\t\t\nstring!"
var fb = FlatBufferBuilder()
@@ -506,14 +362,9 @@ final class FlatbuffersVerifierTests {
charactersVectorOffset: characterVector)
Movie.finish(&fb, end: end)
var buf = fb.sizedBuffer
do {
_ = try getCheckedRoot(byteBuffer: &buf) as Movie
} catch {
Issue.record(error)
}
XCTAssertNoThrow(try getCheckedRoot(byteBuffer: &buf) as Movie)
}
@Test
func testNestedTables() throws {
var builder = FlatBufferBuilder()
let name = builder.create(string: "Monster")
@@ -532,22 +383,22 @@ final class FlatbuffersVerifierTests {
var verifier = try! Verifier(buffer: &sizedBuffer)
var tableVerifer = try! verifier.visitTable(
at: try getOffset(at: 0, within: verifier))
#expect(verifier.depth == 1)
#expect(verifier.tableCount == 1)
XCTAssertEqual(verifier.depth, 1)
XCTAssertEqual(verifier.tableCount, 1)
let position = try tableVerifer.dereference(28)!
var nestedTable = try verifier.visitTable(
at: try getOffset(at: position, within: verifier))
#expect(verifier.depth == 2)
#expect(verifier.tableCount == 2)
XCTAssertEqual(verifier.depth, 2)
XCTAssertEqual(verifier.tableCount, 2)
nestedTable.finish()
#expect(verifier.depth == 1)
#expect(verifier.tableCount == 2)
XCTAssertEqual(verifier.depth, 1)
XCTAssertEqual(verifier.tableCount, 2)
tableVerifer.finish()
#expect(verifier.depth == 0)
#expect(verifier.tableCount == 2)
XCTAssertEqual(verifier.depth, 0)
XCTAssertEqual(verifier.tableCount, 2)
}
func add(buffer: inout ByteBuffer, v: Int32, p: Int) {
tests/swift/Tests/Flatbuffers/MutatingBool_generated.swift
+11 -9
View File
@@ -38,10 +38,10 @@ public struct Property: NativeStruct, FlatbuffersVectorInitializable, Verifiable
}
extension Property: Encodable {
enum CodingKeys: String, CodingKey {
case property = "property"
}
public func encode(to encoder: Encoder) throws {
var container = encoder.container(keyedBy: CodingKeys.self)
if property != false {
@@ -74,7 +74,7 @@ public struct Property_Mutable: FlatBufferStruct, FlatbuffersVectorInitializable
}
}
public struct TestMutatingBool: FlatBufferVerifiableTable, FlatbuffersVectorInitializable, ObjectAPIPacker {
public struct TestMutatingBool: FlatBufferTable, FlatbuffersVectorInitializable, Verifiable, ObjectAPIPacker {
static func validateVersion() { FlatBuffersVersion_25_12_19() }
public var __buffer: ByteBuffer! { return _accessor.bb }
@@ -83,14 +83,16 @@ public struct TestMutatingBool: FlatBufferVerifiableTable, FlatbuffersVectorInit
private init(_ t: Table) { _accessor = t }
public init(_ bb: ByteBuffer, o: Int32) { _accessor = Table(bb: bb, position: o) }
private struct VT {
static let b: VOffset = 4
private enum VTOFFSET: VOffset {
case b = 4
var v: Int32 { Int32(self.rawValue) }
var p: VOffset { self.rawValue }
}
public var b: Property? { let o = _accessor.offset(VT.b); return o == 0 ? nil : _accessor.readBuffer(of: Property.self, at: o) }
public var mutableB: Property_Mutable? { let o = _accessor.offset(VT.b); return o == 0 ? nil : Property_Mutable(_accessor.bb, o: o + _accessor.position) }
public var b: Property? { let o = _accessor.offset(VTOFFSET.b.v); return o == 0 ? nil : _accessor.readBuffer(of: Property.self, at: o) }
public var mutableB: Property_Mutable? { let o = _accessor.offset(VTOFFSET.b.v); return o == 0 ? nil : Property_Mutable(_accessor.bb, o: o + _accessor.position) }
public static func startTestMutatingBool(_ fbb: inout FlatBufferBuilder) -> UOffset { fbb.startTable(with: 1) }
public static func add(b: Property?, _ fbb: inout FlatBufferBuilder) { guard let b = b else { return }; fbb.create(struct: b, position: VT.b) }
public static func add(b: Property?, _ fbb: inout FlatBufferBuilder) { guard let b = b else { return }; fbb.create(struct: b, position: VTOFFSET.b.p) }
public static func endTestMutatingBool(_ fbb: inout FlatBufferBuilder, start: UOffset) -> Offset { let end = Offset(offset: fbb.endTable(at: start)); return end }
public static func createTestMutatingBool(
_ fbb: inout FlatBufferBuilder,
@@ -117,16 +119,16 @@ public struct TestMutatingBool: FlatBufferVerifiableTable, FlatbuffersVectorInit
public static func verify<T>(_ verifier: inout Verifier, at position: Int, of type: T.Type) throws where T: Verifiable {
var _v = try verifier.visitTable(at: position)
try _v.visit(field: VT.b, fieldName: "b", required: false, type: Property.self)
try _v.visit(field: VTOFFSET.b.p, fieldName: "b", required: false, type: Property.self)
_v.finish()
}
}
extension TestMutatingBool: Encodable {
enum CodingKeys: String, CodingKey {
case b = "b"
}
public func encode(to encoder: Encoder) throws {
var container = encoder.container(keyedBy: CodingKeys.self)
try container.encodeIfPresent(b, forKey: .b)
tests/swift/Tests/Flatbuffers/arrays_test_generated.swift
+12 -132
View File
@@ -84,13 +84,13 @@ public struct MyGame_Example_NestedStruct: NativeStruct, FlatbuffersVectorInitia
@available(macOS 26.0, iOS 26.0, watchOS 26.0, tvOS 26.0, *)
extension MyGame_Example_NestedStruct: Encodable {
enum CodingKeys: String, CodingKey {
case a = "a"
case b = "b"
case c = "c"
case d = "d"
}
public func encode(to encoder: Encoder) throws {
var container = encoder.container(keyedBy: CodingKeys.self)
var aContainer = container.nestedUnkeyedContainer(forKey: .a)
@@ -206,6 +206,7 @@ public struct MyGame_Example_ArrayStruct: NativeStruct, FlatbuffersVectorInitial
@available(macOS 26.0, iOS 26.0, watchOS 26.0, tvOS 26.0, *)
extension MyGame_Example_ArrayStruct: Encodable {
enum CodingKeys: String, CodingKey {
case a = "a"
case b = "b"
@@ -214,7 +215,6 @@ extension MyGame_Example_ArrayStruct: Encodable {
case e = "e"
case f = "f"
}
public func encode(to encoder: Encoder) throws {
var container = encoder.container(keyedBy: CodingKeys.self)
if a != 0.0 {
@@ -276,129 +276,7 @@ public struct MyGame_Example_ArrayStruct_Mutable: FlatBufferStruct, FlatbuffersV
}
@available(macOS 26.0, iOS 26.0, watchOS 26.0, tvOS 26.0, *)
public struct MyGame_Example_LargeArrayStruct: NativeStruct, FlatbuffersVectorInitializable, Verifiable, FlatbuffersInitializable, NativeObject {
static func validateVersion() { FlatBuffersVersion_25_12_19() }
private var _d: InlineArray<64, UInt8>
private var _e: InlineArray<64, Float32>
private var _f: InlineArray<64, Bool>
private var _g: InlineArray<64, MyGame_Example_NestedStruct>
private var _h: InlineArray<64, Int8>
public init(_ bb: ByteBuffer, o: Int32) {
self = bb.read(def: Self.self, position: Int(o))
}
public init(d: InlineArray<64, UInt8>, e: InlineArray<64, Float32>, f: InlineArray<64, Bool>, g: InlineArray<64, MyGame_Example_NestedStruct>, h: InlineArray<64, Int8>) {
_d = d
_e = e
_f = f
_g = g
_h = h
}
public init() {
_d = InlineArray(repeating: 0)
_e = InlineArray(repeating: 0.0)
_f = InlineArray(repeating: false)
_g = InlineArray(repeating: MyGame_Example_NestedStruct())
_h = InlineArray(repeating: 0)
}
public init(_ _t: borrowing MyGame_Example_LargeArrayStruct_Mutable) {
let _vd = _t.d
_d = InlineArray { _vd[$0] }
let _ve = _t.e
_e = InlineArray { _ve[$0] }
let _vf = _t.f
_f = InlineArray { _vf[$0] }
let _vg = _t.g
_g = InlineArray { _vg[$0].unpack() }
let _vh = _t.h
_h = InlineArray { _vh[$0].rawValue }
}
public var d: InlineArray<64, UInt8> { _d }
public var e: InlineArray<64, Float32> { _e }
public var f: InlineArray<64, Bool> { _f }
public var g: InlineArray<64, MyGame_Example_NestedStruct> { _g }
public var h: InlineArray<64, MyGame_Example_TestEnum> { InlineArray { MyGame_Example_TestEnum(rawValue: _h[$0])! } }
public static func verify<T>(_ verifier: inout Verifier, at position: Int, of type: T.Type) throws where T: Verifiable {
try verifier.inBuffer(position: position, of: MyGame_Example_LargeArrayStruct.self)
}
}
@available(macOS 26.0, iOS 26.0, watchOS 26.0, tvOS 26.0, *)
extension MyGame_Example_LargeArrayStruct: Encodable {
enum CodingKeys: String, CodingKey {
case d = "d"
case e = "e"
case f = "f"
case g = "g"
case h = "h"
}
public func encode(to encoder: Encoder) throws {
var container = encoder.container(keyedBy: CodingKeys.self)
var dContainer = container.nestedUnkeyedContainer(forKey: .d)
for index in d.startIndex..<d.endIndex {
try dContainer.encode(d[index])
}
var eContainer = container.nestedUnkeyedContainer(forKey: .e)
for index in e.startIndex..<e.endIndex {
try eContainer.encode(e[index])
}
var fContainer = container.nestedUnkeyedContainer(forKey: .f)
for index in f.startIndex..<f.endIndex {
try fContainer.encode(f[index])
}
var gContainer = container.nestedUnkeyedContainer(forKey: .g)
for index in g.startIndex..<g.endIndex {
try gContainer.encode(g[index])
}
var hContainer = container.nestedUnkeyedContainer(forKey: .h)
for index in h.startIndex..<h.endIndex {
try hContainer.encode(h[index])
}
}
}
@available(macOS 26.0, iOS 26.0, watchOS 26.0, tvOS 26.0, *)
public struct MyGame_Example_LargeArrayStruct_Mutable: FlatBufferStruct, FlatbuffersVectorInitializable {
static func validateVersion() { FlatBuffersVersion_25_12_19() }
public var __buffer: ByteBuffer! { return _accessor.bb }
private var _accessor: Struct
public init(_ bb: ByteBuffer, o: Int32) { _accessor = Struct(bb: bb, position: o) }
public var d: FlatbufferVector<UInt8> { return _accessor.vector(at: 0, count: 64, size: 1) }
@discardableResult public func mutate(d: UInt8, at index: Int32) -> Bool { return _accessor.mutate(d, index: 0 + (index * 1)) }
public var e: FlatbufferVector<Float32> { return _accessor.vector(at: 64, count: 64, size: 4) }
@discardableResult public func mutate(e: Float32, at index: Int32) -> Bool { return _accessor.mutate(e, index: 64 + (index * 4)) }
public var f: FlatbufferVector<Bool> { return _accessor.vector(at: 320, count: 64, size: 1) }
@discardableResult public func mutate(f: Bool, at index: Int32) -> Bool { return _accessor.mutate(f, index: 320 + (index * 1)) }
public var g: FlatbufferVector<MyGame_Example_NestedStruct_Mutable> { return _accessor.vector(at: 384, count: 64, size: 32) }
public var h: FlatbufferVector<MyGame_Example_TestEnum> { return _accessor.vector(at: 2432, count: 64, size: 1) }
@discardableResult public func mutate(h: MyGame_Example_TestEnum, at index: Int32) -> Bool { return _accessor.mutate(h.rawValue, index: 2432 + (index * 1)) }
public func unpack() -> MyGame_Example_LargeArrayStruct {
return MyGame_Example_LargeArrayStruct(self)
}
public static func pack(_ builder: inout FlatBufferBuilder, obj: inout MyGame_Example_LargeArrayStruct?) -> Offset {
guard var obj = obj else { return Offset() }
return pack(&builder, obj: &obj)
}
public static func pack(_ builder: inout FlatBufferBuilder, obj: inout MyGame_Example_LargeArrayStruct) -> Offset {
return builder.create(struct: obj)
}
}
@available(macOS 26.0, iOS 26.0, watchOS 26.0, tvOS 26.0, *)
public struct MyGame_Example_ArrayTable: FlatBufferVerifiableTable, FlatbuffersVectorInitializable, ObjectAPIPacker {
public struct MyGame_Example_ArrayTable: FlatBufferTable, FlatbuffersVectorInitializable, Verifiable, ObjectAPIPacker {
static func validateVersion() { FlatBuffersVersion_25_12_19() }
public var __buffer: ByteBuffer! { return _accessor.bb }
@@ -409,14 +287,16 @@ public struct MyGame_Example_ArrayTable: FlatBufferVerifiableTable, FlatbuffersV
private init(_ t: Table) { _accessor = t }
public init(_ bb: ByteBuffer, o: Int32) { _accessor = Table(bb: bb, position: o) }
private struct VT {
static let a: VOffset = 4
private enum VTOFFSET: VOffset {
case a = 4
var v: Int32 { Int32(self.rawValue) }
var p: VOffset { self.rawValue }
}
public var a: MyGame_Example_ArrayStruct? { let o = _accessor.offset(VT.a); return o == 0 ? nil : _accessor.readBuffer(of: MyGame_Example_ArrayStruct.self, at: o) }
public var mutableA: MyGame_Example_ArrayStruct_Mutable? { let o = _accessor.offset(VT.a); return o == 0 ? nil : MyGame_Example_ArrayStruct_Mutable(_accessor.bb, o: o + _accessor.position) }
public var a: MyGame_Example_ArrayStruct? { let o = _accessor.offset(VTOFFSET.a.v); return o == 0 ? nil : _accessor.readBuffer(of: MyGame_Example_ArrayStruct.self, at: o) }
public var mutableA: MyGame_Example_ArrayStruct_Mutable? { let o = _accessor.offset(VTOFFSET.a.v); return o == 0 ? nil : MyGame_Example_ArrayStruct_Mutable(_accessor.bb, o: o + _accessor.position) }
public static func startArrayTable(_ fbb: inout FlatBufferBuilder) -> UOffset { fbb.startTable(with: 1) }
public static func add(a: MyGame_Example_ArrayStruct?, _ fbb: inout FlatBufferBuilder) { guard let a = a else { return }; fbb.create(struct: a, position: VT.a) }
public static func add(a: MyGame_Example_ArrayStruct?, _ fbb: inout FlatBufferBuilder) { guard let a = a else { return }; fbb.create(struct: a, position: VTOFFSET.a.p) }
public static func endArrayTable(_ fbb: inout FlatBufferBuilder, start: UOffset) -> Offset { let end = Offset(offset: fbb.endTable(at: start)); return end }
public static func createArrayTable(
_ fbb: inout FlatBufferBuilder,
@@ -443,17 +323,17 @@ public struct MyGame_Example_ArrayTable: FlatBufferVerifiableTable, FlatbuffersV
public static func verify<T>(_ verifier: inout Verifier, at position: Int, of type: T.Type) throws where T: Verifiable {
var _v = try verifier.visitTable(at: position)
try _v.visit(field: VT.a, fieldName: "a", required: false, type: MyGame_Example_ArrayStruct.self)
try _v.visit(field: VTOFFSET.a.p, fieldName: "a", required: false, type: MyGame_Example_ArrayStruct.self)
_v.finish()
}
}
@available(macOS 26.0, iOS 26.0, watchOS 26.0, tvOS 26.0, *)
extension MyGame_Example_ArrayTable: Encodable {
enum CodingKeys: String, CodingKey {
case a = "a"
}
public func encode(to encoder: Encoder) throws {
var container = encoder.container(keyedBy: CodingKeys.self)
try container.encodeIfPresent(a, forKey: .a)
tests/swift/Tests/Flatbuffers/monster_test.grpc.swift
+165 -527
View File
@@ -5,568 +5,206 @@
// swiftlint:disable all
// swiftformat:disable all
#if !os(Windows) && compiler(>=6.0)
import FlatBuffers
#if !os(Windows)
import Foundation
import GRPCCore
import GRPCNIOTransportCore
import GRPC
import NIO
import NIOHTTP1
import FlatBuffers
/// Usage: instantiate MyGame.Example.MonsterStorageServiceClient, then call methods of this protocol to make API calls.
@available(macOS 15.0, iOS 18.0, watchOS 11.0, tvOS 18.0, visionOS 2.0, *)
extension FlatBuffersMessageSerializer: MessageSerializer {
public func serialize<Bytes>(_ message: Message) throws -> Bytes where Bytes : GRPCCore.GRPCContiguousBytes {
do {
return try self.serialize(message: message) { GRPCNIOTransportBytes($0) } as! Bytes
} catch let error {
throw RPCError(
code: .invalidArgument,
message: "Can't serialize message",
cause: error
)
}
public protocol GRPCFlatBufPayload: GRPCPayload, FlatBufferGRPCMessage {}
public extension GRPCFlatBufPayload {
init(serializedByteBuffer: inout NIO.ByteBuffer) throws {
self.init(byteBuffer: FlatBuffers.ByteBuffer(contiguousBytes: serializedByteBuffer.readableBytesView, count: serializedByteBuffer.readableBytes))
}
func serialize(into buffer: inout NIO.ByteBuffer) throws {
withUnsafeReadableBytes { buffer.writeBytes($0) }
}
}
extension Message: GRPCFlatBufPayload {}
/// Usage: instantiate MyGame_Example_MonsterStorageServiceClient, then call methods of this protocol to make API calls.
public protocol MyGame_Example_MonsterStorageClientProtocol: GRPCClient {
var serviceName: String { get }
var interceptors: MyGame_Example_MonsterStorageClientInterceptorFactoryProtocol? { get }
func Store(
_ request: Message<MyGame_Example_Monster>
, callOptions: CallOptions?
) -> UnaryCall<Message<MyGame_Example_Monster>, Message<MyGame_Example_Stat>>
func Retrieve(
_ request: Message<MyGame_Example_Stat>
, callOptions: CallOptions?,
handler: @escaping (Message<MyGame_Example_Monster>) -> Void
) -> ServerStreamingCall<Message<MyGame_Example_Stat>, Message<MyGame_Example_Monster>>
func GetMaxHitPoint(
callOptions: CallOptions?
) -> ClientStreamingCall<Message<MyGame_Example_Monster>, Message<MyGame_Example_Stat>>
func GetMinMaxHitPoints(
callOptions: CallOptions?,
handler: @escaping (Message<MyGame_Example_Stat> ) -> Void
) -> BidirectionalStreamingCall<Message<MyGame_Example_Monster>, Message<MyGame_Example_Stat>>
@available(macOS 15.0, iOS 18.0, watchOS 11.0, tvOS 18.0, visionOS 2.0, *)
extension FlatBuffersMessageDeserializer: MessageDeserializer {
public func deserialize<Bytes>(_ serializedMessageBytes: Bytes) throws -> Message where Bytes : GRPCCore.GRPCContiguousBytes {
do {
return try serializedMessageBytes.withUnsafeBytes {
try self.deserialize(pointer: $0)
}
} catch let error {
throw RPCError(
code: .invalidArgument,
message: "Can't Decode message of type \(Message.self)",
cause: error
)
}
}
}
@available(macOS 15.0, iOS 18.0, watchOS 11.0, tvOS 18.0, visionOS 2.0, *)
public enum MyGame_Example_MonsterStorage: Sendable {
public static let descriptor = GRPCCore.ServiceDescriptor(fullyQualifiedService: "MyGame.Example.MonsterStorage")
public enum Method: Sendable {
public enum Store: Sendable {
public typealias Input = FlatBufferBuilder
public typealias Output = MyGame_Example_Stat
public static let descriptor = GRPCCore.MethodDescriptor(
service: GRPCCore.ServiceDescriptor(fullyQualifiedService: "MyGame.Example.MonsterStorage"),
method: "Store"
)
}
public enum Retrieve: Sendable {
public typealias Input = FlatBufferBuilder
public typealias Output = MyGame_Example_Monster
public static let descriptor = GRPCCore.MethodDescriptor(
service: GRPCCore.ServiceDescriptor(fullyQualifiedService: "MyGame.Example.MonsterStorage"),
method: "Retrieve"
)
}
public enum GetMaxHitPoint: Sendable {
public typealias Input = FlatBufferBuilder
public typealias Output = MyGame_Example_Stat
public static let descriptor = GRPCCore.MethodDescriptor(
service: GRPCCore.ServiceDescriptor(fullyQualifiedService: "MyGame.Example.MonsterStorage"),
method: "GetMaxHitPoint"
)
}
public enum GetMinMaxHitPoints: Sendable {
public typealias Input = FlatBufferBuilder
public typealias Output = MyGame_Example_Stat
public static let descriptor = GRPCCore.MethodDescriptor(
service: GRPCCore.ServiceDescriptor(fullyQualifiedService: "MyGame.Example.MonsterStorage"),
method: "GetMinMaxHitPoints"
)
}
public static let descriptors: [GRPCCore.MethodDescriptor] = [
Store.descriptor,
Retrieve.descriptor,
GetMaxHitPoint.descriptor,
GetMinMaxHitPoints.descriptor,
]
}
}
extension MyGame_Example_MonsterStorageClientProtocol {
@available(macOS 15.0, iOS 18.0, watchOS 11.0, tvOS 18.0, visionOS 2.0, *)
extension GRPCCore.ServiceDescriptor {
public static let MyGame_Example_MonsterStorage = GRPCCore.ServiceDescriptor(fullyQualifiedService: "MyGame.Example.MonsterStorage")
}
public var serviceName: String { "MyGame.Example.MonsterStorage" }
// MARK: MyGame.Example.MonsterStorage Server
@available(macOS 15.0, iOS 18.0, watchOS 11.0, tvOS 18.0, visionOS 2.0, *)
extension MyGame_Example_MonsterStorage {
public protocol StreamingServiceProtocol: GRPCCore.RegistrableRPCService {
func Store(
request: GRPCCore.StreamingServerRequest<GRPCMessage<MyGame_Example_Stat>>,
context: GRPCCore.ServerContext
) async throws -> GRPCCore.StreamingServerResponse<GRPCMessage<MyGame_Example_Stat>>
func Retrieve(
request: GRPCCore.StreamingServerRequest<GRPCMessage<MyGame_Example_Monster>>,
context: GRPCCore.ServerContext
) async throws -> GRPCCore.StreamingServerResponse<GRPCMessage<MyGame_Example_Monster>>
func GetMaxHitPoint(
request: GRPCCore.StreamingServerRequest<GRPCMessage<MyGame_Example_Stat>>,
context: GRPCCore.ServerContext
) async throws -> GRPCCore.StreamingServerResponse<GRPCMessage<MyGame_Example_Stat>>
func GetMinMaxHitPoints(
request: GRPCCore.StreamingServerRequest<GRPCMessage<MyGame_Example_Stat>>,
context: GRPCCore.ServerContext
) async throws -> GRPCCore.StreamingServerResponse<GRPCMessage<MyGame_Example_Stat>>
}
public protocol ServiceProtocol: MyGame_Example_MonsterStorage.StreamingServiceProtocol {
func Store(
request: GRPCCore.ServerRequest<GRPCMessage<MyGame_Example_Stat>>,
context: GRPCCore.ServerContext
) async throws -> GRPCCore.ServerResponse<GRPCMessage<MyGame_Example_Stat>>
func Retrieve(
request: GRPCCore.ServerRequest<GRPCMessage<MyGame_Example_Monster>>,
context: GRPCCore.ServerContext
) async throws -> GRPCCore.StreamingServerResponse<GRPCMessage<MyGame_Example_Monster>>
func GetMaxHitPoint(
request: GRPCCore.StreamingServerRequest<GRPCMessage<MyGame_Example_Stat>>,
context: GRPCCore.ServerContext
) async throws -> GRPCCore.ServerResponse<GRPCMessage<MyGame_Example_Stat>>
func GetMinMaxHitPoints(
request: GRPCCore.StreamingServerRequest<GRPCMessage<MyGame_Example_Stat>>,
context: GRPCCore.ServerContext
) async throws -> GRPCCore.StreamingServerResponse<GRPCMessage<MyGame_Example_Stat>>
}
public protocol SimpleServiceProtocol: MyGame_Example_MonsterStorage.ServiceProtocol {
func Store(
request: GRPCMessage<MyGame_Example_Stat>,
context: GRPCCore.ServerContext
) async throws -> GRPCMessage<MyGame_Example_Stat>
func Retrieve(
request: GRPCMessage<MyGame_Example_Monster>,
response: GRPCCore.RPCWriter<GRPCMessage<MyGame_Example_Monster>>,
context: GRPCCore.ServerContext
) async throws
func GetMaxHitPoint(
request: GRPCCore.RPCAsyncSequence<GRPCMessage<MyGame_Example_Stat>, any Swift.Error>,
context: GRPCCore.ServerContext
) async throws -> GRPCMessage<MyGame_Example_Stat>
func GetMinMaxHitPoints(
request: GRPCCore.RPCAsyncSequence<GRPCMessage<MyGame_Example_Stat>, any Swift.Error>,
response: GRPCCore.RPCWriter<GRPCMessage<MyGame_Example_Stat>>,
context: GRPCCore.ServerContext
) async throws
}
}
@available(macOS 15.0, iOS 18.0, watchOS 11.0, tvOS 18.0, visionOS 2.0, *)
extension MyGame_Example_MonsterStorage.StreamingServiceProtocol {
public func registerMethods<Transport>(with router: inout GRPCCore.RPCRouter<Transport>) where Transport: GRPCCore.ServerTransport {
router.registerHandler(
forMethod: MyGame_Example_MonsterStorage.Method.Store.descriptor,
deserializer: FlatBuffersMessageDeserializer<GRPCMessage<MyGame_Example_Stat>>(),
serializer: FlatBuffersMessageSerializer<GRPCMessage<MyGame_Example_Stat>>(),
handler: { request, context in
try await self.Store(
request: request,
context: context
)
}
)
router.registerHandler(
forMethod: MyGame_Example_MonsterStorage.Method.Retrieve.descriptor,
deserializer: FlatBuffersMessageDeserializer<GRPCMessage<MyGame_Example_Monster>>(),
serializer: FlatBuffersMessageSerializer<GRPCMessage<MyGame_Example_Monster>>(),
handler: { request, context in
try await self.Retrieve(
request: request,
context: context
)
}
)
router.registerHandler(
forMethod: MyGame_Example_MonsterStorage.Method.GetMaxHitPoint.descriptor,
deserializer: FlatBuffersMessageDeserializer<GRPCMessage<MyGame_Example_Stat>>(),
serializer: FlatBuffersMessageSerializer<GRPCMessage<MyGame_Example_Stat>>(),
handler: { request, context in
try await self.GetMaxHitPoint(
request: request,
context: context
)
}
)
router.registerHandler(
forMethod: MyGame_Example_MonsterStorage.Method.GetMinMaxHitPoints.descriptor,
deserializer: FlatBuffersMessageDeserializer<GRPCMessage<MyGame_Example_Stat>>(),
serializer: FlatBuffersMessageSerializer<GRPCMessage<MyGame_Example_Stat>>(),
handler: { request, context in
try await self.GetMinMaxHitPoints(
request: request,
context: context
)
}
)
}
}
@available(macOS 15.0, iOS 18.0, watchOS 11.0, tvOS 18.0, visionOS 2.0, *)
extension MyGame_Example_MonsterStorage.ServiceProtocol {
public func Store(
request: GRPCCore.StreamingServerRequest<GRPCMessage<MyGame_Example_Stat>>,
context: GRPCCore.ServerContext
) async throws -> GRPCCore.StreamingServerResponse<GRPCMessage<MyGame_Example_Stat>> {
let response = try await self.Store(
request: GRPCCore.ServerRequest(stream: request),
context: context
)
return GRPCCore.StreamingServerResponse(single: response)
}
public func Retrieve(
request: GRPCCore.StreamingServerRequest<GRPCMessage<MyGame_Example_Monster>>,
context: GRPCCore.ServerContext
) async throws -> GRPCCore.StreamingServerResponse<GRPCMessage<MyGame_Example_Monster>> {
let response = try await self.Retrieve(
request: GRPCCore.ServerRequest(stream: request),
context: context
)
return response
}
public func GetMaxHitPoint(
request: GRPCCore.StreamingServerRequest<GRPCMessage<MyGame_Example_Stat>>,
context: GRPCCore.ServerContext
) async throws -> GRPCCore.StreamingServerResponse<GRPCMessage<MyGame_Example_Stat>> {
let response = try await self.GetMaxHitPoint(
_ request: Message<MyGame_Example_Monster>
, callOptions: CallOptions? = nil
) -> UnaryCall<Message<MyGame_Example_Monster>, Message<MyGame_Example_Stat>> {
return self.makeUnaryCall(
path: "/MyGame.Example.MonsterStorage/Store",
request: request,
context: context
callOptions: callOptions ?? self.defaultCallOptions,
interceptors: self.interceptors?.makeStoreInterceptors() ?? []
)
return GRPCCore.StreamingServerResponse(single: response)
}
}
@available(macOS 15.0, iOS 18.0, watchOS 11.0, tvOS 18.0, visionOS 2.0, *)
extension MyGame_Example_MonsterStorage.SimpleServiceProtocol {
public func Store(
request: GRPCCore.ServerRequest<GRPCMessage<MyGame_Example_Stat>>,
context: GRPCCore.ServerContext
) async throws -> GRPCCore.ServerResponse<GRPCMessage<MyGame_Example_Stat>> {
return GRPCCore.ServerResponse<GRPCMessage<MyGame_Example_Stat>>(
message: try await self.Store(
request: request.message,
context: context
),
metadata: [:]
)
}
public func Retrieve(
request: GRPCCore.ServerRequest<GRPCMessage<MyGame_Example_Monster>>,
context: GRPCCore.ServerContext
) async throws -> GRPCCore.StreamingServerResponse<GRPCMessage<MyGame_Example_Monster>> {
return GRPCCore.StreamingServerResponse<GRPCMessage<MyGame_Example_Monster>>(
metadata: [:],
producer: { writer in
try await self.Retrieve(
request: request.message,
response: writer,
context: context
)
return [:]
}
_ request: Message<MyGame_Example_Stat>
, callOptions: CallOptions? = nil,
handler: @escaping (Message<MyGame_Example_Monster>) -> Void
) -> ServerStreamingCall<Message<MyGame_Example_Stat>, Message<MyGame_Example_Monster>> {
return self.makeServerStreamingCall(
path: "/MyGame.Example.MonsterStorage/Retrieve",
request: request,
callOptions: callOptions ?? self.defaultCallOptions,
interceptors: self.interceptors?.makeRetrieveInterceptors() ?? [],
handler: handler
)
}
public func GetMaxHitPoint(
request: GRPCCore.StreamingServerRequest<GRPCMessage<MyGame_Example_Stat>>,
context: GRPCCore.ServerContext
) async throws -> GRPCCore.ServerResponse<GRPCMessage<MyGame_Example_Stat>> {
return GRPCCore.ServerResponse<GRPCMessage<MyGame_Example_Stat>>(
message: try await self.GetMaxHitPoint(
request: request.messages,
context: context
),
metadata: [:]
callOptions: CallOptions? = nil
) -> ClientStreamingCall<Message<MyGame_Example_Monster>, Message<MyGame_Example_Stat>> {
return self.makeClientStreamingCall(
path: "/MyGame.Example.MonsterStorage/GetMaxHitPoint",
callOptions: callOptions ?? self.defaultCallOptions,
interceptors: self.interceptors?.makeGetMaxHitPointInterceptors() ?? []
)
}
public func GetMinMaxHitPoints(
request: GRPCCore.StreamingServerRequest<GRPCMessage<MyGame_Example_Stat>>,
context: GRPCCore.ServerContext
) async throws -> GRPCCore.StreamingServerResponse<GRPCMessage<MyGame_Example_Stat>> {
return GRPCCore.StreamingServerResponse<GRPCMessage<MyGame_Example_Stat>>(
metadata: [:],
producer: { writer in
try await self.GetMinMaxHitPoints(
request: request.messages,
response: writer,
context: context
)
return [:]
}
callOptions: CallOptions? = nil,
handler: @escaping (Message<MyGame_Example_Stat> ) -> Void
) -> BidirectionalStreamingCall<Message<MyGame_Example_Monster>, Message<MyGame_Example_Stat>> {
return self.makeBidirectionalStreamingCall(
path: "/MyGame.Example.MonsterStorage/GetMinMaxHitPoints",
callOptions: callOptions ?? self.defaultCallOptions,
interceptors: self.interceptors?.makeGetMinMaxHitPointsInterceptors() ?? [],
handler: handler
)
}
}
public protocol MyGame_Example_MonsterStorageClientInterceptorFactoryProtocol {
/// - Returns: Interceptors to use when invoking 'Store'.
func makeStoreInterceptors() -> [ClientInterceptor<Message<MyGame_Example_Monster>, Message<MyGame_Example_Stat>>]
// MARK: MyGame.Example.MonsterStorage Client
/// - Returns: Interceptors to use when invoking 'Retrieve'.
func makeRetrieveInterceptors() -> [ClientInterceptor<Message<MyGame_Example_Stat>, Message<MyGame_Example_Monster>>]
@available(macOS 15.0, iOS 18.0, watchOS 11.0, tvOS 18.0, visionOS 2.0, *)
extension MyGame_Example_MonsterStorage {
public protocol ClientProtocol: Sendable {
func Store<Result>(
request: GRPCCore.ClientRequest<GRPCMessage<MyGame_Example_Stat>>,
serializer: some GRPCCore.MessageSerializer<GRPCMessage<MyGame_Example_Stat>>,
deserializer: some GRPCCore.MessageDeserializer<GRPCMessage<MyGame_Example_Stat>>,
options: GRPCCore.CallOptions,
onResponse handleResponse: @Sendable @escaping (GRPCCore.ClientResponse<GRPCMessage<MyGame_Example_Stat>>) async throws -> Result
) async throws -> Result where Result: Sendable
func Retrieve<Result>(
request: GRPCCore.ClientRequest<GRPCMessage<MyGame_Example_Monster>>,
serializer: some GRPCCore.MessageSerializer<GRPCMessage<MyGame_Example_Monster>>,
deserializer: some GRPCCore.MessageDeserializer<GRPCMessage<MyGame_Example_Monster>>,
options: GRPCCore.CallOptions,
onResponse handleResponse: @Sendable @escaping (GRPCCore.StreamingClientResponse<GRPCMessage<MyGame_Example_Monster>>) async throws -> Result
) async throws -> Result where Result: Sendable
func GetMaxHitPoint<Result>(
request: GRPCCore.StreamingClientRequest<GRPCMessage<MyGame_Example_Stat>>,
serializer: some GRPCCore.MessageSerializer<GRPCMessage<MyGame_Example_Stat>>,
deserializer: some GRPCCore.MessageDeserializer<GRPCMessage<MyGame_Example_Stat>>,
options: GRPCCore.CallOptions,
onResponse handleResponse: @Sendable @escaping (GRPCCore.ClientResponse<GRPCMessage<MyGame_Example_Stat>>) async throws -> Result
) async throws -> Result where Result: Sendable
func GetMinMaxHitPoints<Result>(
request: GRPCCore.StreamingClientRequest<GRPCMessage<MyGame_Example_Stat>>,
serializer: some GRPCCore.MessageSerializer<GRPCMessage<MyGame_Example_Stat>>,
deserializer: some GRPCCore.MessageDeserializer<GRPCMessage<MyGame_Example_Stat>>,
options: GRPCCore.CallOptions,
onResponse handleResponse: @Sendable @escaping (GRPCCore.StreamingClientResponse<GRPCMessage<MyGame_Example_Stat>>) async throws -> Result
) async throws -> Result where Result: Sendable
/// - Returns: Interceptors to use when invoking 'GetMaxHitPoint'.
func makeGetMaxHitPointInterceptors() -> [ClientInterceptor<Message<MyGame_Example_Monster>, Message<MyGame_Example_Stat>>]
/// - Returns: Interceptors to use when invoking 'GetMinMaxHitPoints'.
func makeGetMinMaxHitPointsInterceptors() -> [ClientInterceptor<Message<MyGame_Example_Monster>, Message<MyGame_Example_Stat>>]
}
public final class MyGame_Example_MonsterStorageServiceClient: MyGame_Example_MonsterStorageClientProtocol {
public let channel: GRPCChannel
public var defaultCallOptions: CallOptions
public var interceptors: MyGame_Example_MonsterStorageClientInterceptorFactoryProtocol?
public init(
channel: GRPCChannel,
defaultCallOptions: CallOptions = CallOptions(),
interceptors: MyGame_Example_MonsterStorageClientInterceptorFactoryProtocol? = nil
) {
self.channel = channel
self.defaultCallOptions = defaultCallOptions
self.interceptors = interceptors
}
}
@available(macOS 15.0, iOS 18.0, watchOS 11.0, tvOS 18.0, visionOS 2.0, *)
extension MyGame_Example_MonsterStorage {
public struct Client<Transport>: ClientProtocol where Transport: GRPCCore.ClientTransport {
private let client: GRPCCore.GRPCClient<Transport>
public init(wrapping client: GRPCCore.GRPCClient<Transport>) {
self.client = client
}
public func Store<Result>(
request: GRPCCore.ClientRequest<GRPCMessage<MyGame_Example_Stat>>,
serializer: some GRPCCore.MessageSerializer<GRPCMessage<MyGame_Example_Stat>>,
deserializer: some GRPCCore.MessageDeserializer<GRPCMessage<MyGame_Example_Stat>>,
options: GRPCCore.CallOptions = .defaults,
onResponse handleResponse: @Sendable @escaping (GRPCCore.ClientResponse<GRPCMessage<MyGame_Example_Stat>>) async throws -> Result = { response in try response.message }
) async throws -> Result where Result: Sendable {
try await self.client.unary(
request: request,
descriptor: MyGame_Example_MonsterStorage.Method.Store.descriptor,
serializer: serializer,
deserializer: deserializer,
options: options,
onResponse: handleResponse
)
}
public func Retrieve<Result>(
request: GRPCCore.ClientRequest<GRPCMessage<MyGame_Example_Monster>>,
serializer: some GRPCCore.MessageSerializer<GRPCMessage<MyGame_Example_Monster>>,
deserializer: some GRPCCore.MessageDeserializer<GRPCMessage<MyGame_Example_Monster>>,
options: GRPCCore.CallOptions = .defaults,
onResponse handleResponse: @Sendable @escaping (GRPCCore.StreamingClientResponse<GRPCMessage<MyGame_Example_Monster>>) async throws -> Result
) async throws -> Result where Result: Sendable {
try await self.client.serverStreaming(
request: request,
descriptor: MyGame_Example_MonsterStorage.Method.Retrieve.descriptor,
serializer: serializer,
deserializer: deserializer,
options: options,
onResponse: handleResponse
)
}
public func GetMaxHitPoint<Result>(
request: GRPCCore.StreamingClientRequest<GRPCMessage<MyGame_Example_Stat>>,
serializer: some GRPCCore.MessageSerializer<GRPCMessage<MyGame_Example_Stat>>,
deserializer: some GRPCCore.MessageDeserializer<GRPCMessage<MyGame_Example_Stat>>,
options: GRPCCore.CallOptions = .defaults,
onResponse handleResponse: @Sendable @escaping (GRPCCore.ClientResponse<GRPCMessage<MyGame_Example_Stat>>) async throws -> Result = { response in try response.message }
) async throws -> Result where Result: Sendable {
try await self.client.clientStreaming(
request: request,
descriptor: MyGame_Example_MonsterStorage.Method.GetMaxHitPoint.descriptor,
serializer: serializer,
deserializer: deserializer,
options: options,
onResponse: handleResponse
)
}
public func GetMinMaxHitPoints<Result>(
request: GRPCCore.StreamingClientRequest<GRPCMessage<MyGame_Example_Stat>>,
serializer: some GRPCCore.MessageSerializer<GRPCMessage<MyGame_Example_Stat>>,
deserializer: some GRPCCore.MessageDeserializer<GRPCMessage<MyGame_Example_Stat>>,
options: GRPCCore.CallOptions = .defaults,
onResponse handleResponse: @Sendable @escaping (GRPCCore.StreamingClientResponse<GRPCMessage<MyGame_Example_Stat>>) async throws -> Result
) async throws -> Result where Result: Sendable {
try await self.client.bidirectionalStreaming(
request: request,
descriptor: MyGame_Example_MonsterStorage.Method.GetMinMaxHitPoints.descriptor,
serializer: serializer,
deserializer: deserializer,
options: options,
onResponse: handleResponse
)
}
}
public protocol MyGame_Example_MonsterStorageProvider: CallHandlerProvider {
var interceptors: MyGame_Example_MonsterStorageServerInterceptorFactoryProtocol? { get }
func Store(request: Message<MyGame_Example_Monster>, context: StatusOnlyCallContext) -> EventLoopFuture<Message<MyGame_Example_Stat>>
func Retrieve(request: Message<MyGame_Example_Stat>, context: StreamingResponseCallContext<Message<MyGame_Example_Monster>>) -> EventLoopFuture<GRPCStatus>
func GetMaxHitPoint(context: UnaryResponseCallContext<Message<MyGame_Example_Stat>>) -> EventLoopFuture<(StreamEvent<Message<MyGame_Example_Monster>>) -> Void>
func GetMinMaxHitPoints(context: StreamingResponseCallContext<Message<MyGame_Example_Stat>>) -> EventLoopFuture<(StreamEvent<Message<MyGame_Example_Monster>>) -> Void>
}
@available(macOS 15.0, iOS 18.0, watchOS 11.0, tvOS 18.0, visionOS 2.0, *)
extension MyGame_Example_MonsterStorage.ClientProtocol {
public func Store<Result>(
request: GRPCCore.ClientRequest<GRPCMessage<MyGame_Example_Stat>>,
options: GRPCCore.CallOptions = .defaults,
onResponse handleResponse: @Sendable @escaping (GRPCCore.ClientResponse<GRPCMessage<MyGame_Example_Stat>>) async throws -> Result = { response in try response.message }
) async throws -> Result where Result: Sendable {
try await self.Store(
request: request,
serializer: FlatBuffersMessageSerializer<GRPCMessage<MyGame_Example_Stat>>(),
deserializer: FlatBuffersMessageDeserializer<GRPCMessage<MyGame_Example_Stat>>(),
options: options,
onResponse: handleResponse
)
public extension MyGame_Example_MonsterStorageProvider {
var serviceName: Substring { return "MyGame.Example.MonsterStorage" }
func handle(method name: Substring, context: CallHandlerContext) -> GRPCServerHandlerProtocol? {
switch name {
case "Store":
return UnaryServerHandler(
context: context,
requestDeserializer: GRPCPayloadDeserializer<Message<MyGame_Example_Monster>>(),
responseSerializer: GRPCPayloadSerializer<Message<MyGame_Example_Stat>>(),
interceptors: self.interceptors?.makeStoreInterceptors() ?? [],
userFunction: self.Store(request:context:))
case "Retrieve":
return ServerStreamingServerHandler(
context: context,
requestDeserializer: GRPCPayloadDeserializer<Message<MyGame_Example_Stat>>(),
responseSerializer: GRPCPayloadSerializer<Message<MyGame_Example_Monster>>(),
interceptors: self.interceptors?.makeRetrieveInterceptors() ?? [],
userFunction: self.Retrieve(request:context:))
case "GetMaxHitPoint":
return ClientStreamingServerHandler(
context: context,
requestDeserializer: GRPCPayloadDeserializer<Message<MyGame_Example_Monster>>(),
responseSerializer: GRPCPayloadSerializer<Message<MyGame_Example_Stat>>(),
interceptors: self.interceptors?.makeGetMaxHitPointInterceptors() ?? [],
observerFactory: self.GetMaxHitPoint(context:))
case "GetMinMaxHitPoints":
return BidirectionalStreamingServerHandler(
context: context,
requestDeserializer: GRPCPayloadDeserializer<Message<MyGame_Example_Monster>>(),
responseSerializer: GRPCPayloadSerializer<Message<MyGame_Example_Stat>>(),
interceptors: self.interceptors?.makeGetMinMaxHitPointsInterceptors() ?? [],
observerFactory: self.GetMinMaxHitPoints(context:))
default: return nil;
}
}
public func Retrieve<Result>(
request: GRPCCore.ClientRequest<GRPCMessage<MyGame_Example_Monster>>,
options: GRPCCore.CallOptions = .defaults,
onResponse handleResponse: @Sendable @escaping (GRPCCore.StreamingClientResponse<GRPCMessage<MyGame_Example_Monster>>) async throws -> Result
) async throws -> Result where Result: Sendable {
try await self.Retrieve(
request: request,
serializer: FlatBuffersMessageSerializer<GRPCMessage<MyGame_Example_Monster>>(),
deserializer: FlatBuffersMessageDeserializer<GRPCMessage<MyGame_Example_Monster>>(),
options: options,
onResponse: handleResponse
)
}
public func GetMaxHitPoint<Result>(
request: GRPCCore.StreamingClientRequest<GRPCMessage<MyGame_Example_Stat>>,
options: GRPCCore.CallOptions = .defaults,
onResponse handleResponse: @Sendable @escaping (GRPCCore.ClientResponse<GRPCMessage<MyGame_Example_Stat>>) async throws -> Result = { response in try response.message }
) async throws -> Result where Result: Sendable {
try await self.GetMaxHitPoint(
request: request,
serializer: FlatBuffersMessageSerializer<GRPCMessage<MyGame_Example_Stat>>(),
deserializer: FlatBuffersMessageDeserializer<GRPCMessage<MyGame_Example_Stat>>(),
options: options,
onResponse: handleResponse
)
}
public func GetMinMaxHitPoints<Result>(
request: GRPCCore.StreamingClientRequest<GRPCMessage<MyGame_Example_Stat>>,
options: GRPCCore.CallOptions = .defaults,
onResponse handleResponse: @Sendable @escaping (GRPCCore.StreamingClientResponse<GRPCMessage<MyGame_Example_Stat>>) async throws -> Result
) async throws -> Result where Result: Sendable {
try await self.GetMinMaxHitPoints(
request: request,
serializer: FlatBuffersMessageSerializer<GRPCMessage<MyGame_Example_Stat>>(),
deserializer: FlatBuffersMessageDeserializer<GRPCMessage<MyGame_Example_Stat>>(),
options: options,
onResponse: handleResponse
)
}
}
@available(macOS 15.0, iOS 18.0, watchOS 11.0, tvOS 18.0, visionOS 2.0, *)
extension MyGame_Example_MonsterStorage.ClientProtocol {
public func Store<Result>(
_ message: GRPCMessage<MyGame_Example_Stat>,
metadata: GRPCCore.Metadata = [:],
options: GRPCCore.CallOptions = .defaults,
onResponse handleResponse: @Sendable @escaping (GRPCCore.ClientResponse<GRPCMessage<MyGame_Example_Stat>>) async throws -> Result = { try $0.message }
) async throws -> Result where Result: Sendable {
let request = GRPCCore.ClientRequest<GRPCMessage<MyGame_Example_Stat>>(
message: message,
metadata: metadata
)
return try await self.Store(
request: request,
options: options,
onResponse: handleResponse
)
}
public func Retrieve<Result>(
_ message: GRPCMessage<MyGame_Example_Monster>,
metadata: GRPCCore.Metadata = [:],
options: GRPCCore.CallOptions = .defaults,
onResponse handleResponse: @Sendable @escaping (GRPCCore.StreamingClientResponse<GRPCMessage<MyGame_Example_Monster>>) async throws -> Result
) async throws -> Result where Result: Sendable {
let request = GRPCCore.ClientRequest<GRPCMessage<MyGame_Example_Monster>>(
message: message,
metadata: metadata
)
return try await self.Retrieve(
request: request,
options: options,
onResponse: handleResponse
)
}
public func GetMaxHitPoint<Result>(
metadata: GRPCCore.Metadata = [:],
options: GRPCCore.CallOptions = .defaults,
requestProducer producer: @Sendable @escaping (GRPCCore.RPCWriter<GRPCMessage<MyGame_Example_Stat>>) async throws -> Void,
onResponse handleResponse: @Sendable @escaping (GRPCCore.ClientResponse<GRPCMessage<MyGame_Example_Stat>>) async throws -> Result = { try $0.message }
) async throws -> Result where Result: Sendable {
let request = GRPCCore.StreamingClientRequest<GRPCMessage<MyGame_Example_Stat>>(
metadata: metadata,
producer: producer
)
return try await self.GetMaxHitPoint(
request: request,
options: options,
onResponse: handleResponse
)
}
public func GetMinMaxHitPoints<Result>(
metadata: GRPCCore.Metadata = [:],
options: GRPCCore.CallOptions = .defaults,
requestProducer producer: @Sendable @escaping (GRPCCore.RPCWriter<GRPCMessage<MyGame_Example_Stat>>) async throws -> Void,
onResponse handleResponse: @Sendable @escaping (GRPCCore.StreamingClientResponse<GRPCMessage<MyGame_Example_Stat>>) async throws -> Result
) async throws -> Result where Result: Sendable {
let request = GRPCCore.StreamingClientRequest<GRPCMessage<MyGame_Example_Stat>>(
metadata: metadata,
producer: producer
)
return try await self.GetMinMaxHitPoints(
request: request,
options: options,
onResponse: handleResponse
)
}
}
public protocol MyGame_Example_MonsterStorageServerInterceptorFactoryProtocol {
/// - Returns: Interceptors to use when handling 'Store'.
/// Defaults to calling `self.makeInterceptors()`.
func makeStoreInterceptors() -> [ServerInterceptor<Message<MyGame_Example_Monster>, Message<MyGame_Example_Stat>>]
/// - Returns: Interceptors to use when handling 'Retrieve'.
/// Defaults to calling `self.makeInterceptors()`.
func makeRetrieveInterceptors() -> [ServerInterceptor<Message<MyGame_Example_Stat>, Message<MyGame_Example_Monster>>]
/// - Returns: Interceptors to use when handling 'GetMaxHitPoint'.
/// Defaults to calling `self.makeInterceptors()`.
func makeGetMaxHitPointInterceptors() -> [ServerInterceptor<Message<MyGame_Example_Monster>, Message<MyGame_Example_Stat>>]
/// - Returns: Interceptors to use when handling 'GetMinMaxHitPoints'.
/// Defaults to calling `self.makeInterceptors()`.
func makeGetMinMaxHitPointsInterceptors() -> [ServerInterceptor<Message<MyGame_Example_Monster>, Message<MyGame_Example_Stat>>]
}
#endif
tests/swift/Tests/Flatbuffers/monster_test_generated.swift
+424 -412
View File
File diff suppressed because it is too large Load Diff
tests/swift/Tests/Flatbuffers/more_defaults_generated.swift
+34 -32
View File
@@ -31,7 +31,7 @@ extension ABC: Encodable {
}
}
public struct MoreDefaults: FlatBufferVerifiableTable, FlatbuffersVectorInitializable, ObjectAPIPacker {
public struct MoreDefaults: FlatBufferTable, FlatbuffersVectorInitializable, Verifiable, ObjectAPIPacker {
static func validateVersion() { FlatBuffersVersion_25_12_19() }
public var __buffer: ByteBuffer! { return _accessor.bb }
@@ -40,33 +40,35 @@ public struct MoreDefaults: FlatBufferVerifiableTable, FlatbuffersVectorInitiali
private init(_ t: Table) { _accessor = t }
public init(_ bb: ByteBuffer, o: Int32) { _accessor = Table(bb: bb, position: o) }
private struct VT {
static let ints: VOffset = 4
static let floats: VOffset = 6
static let emptyString: VOffset = 8
static let someString: VOffset = 10
static let abcs: VOffset = 12
static let bools: VOffset = 14
private enum VTOFFSET: VOffset {
case ints = 4
case floats = 6
case emptyString = 8
case someString = 10
case abcs = 12
case bools = 14
var v: Int32 { Int32(self.rawValue) }
var p: VOffset { self.rawValue }
}
public var ints: FlatbufferVector<Int32> { return _accessor.vector(at: VT.ints, byteSize: 4) }
public func withUnsafePointerToInts<T>(_ body: (UnsafeRawBufferPointer, Int) throws -> T) rethrows -> T? { return try _accessor.withUnsafePointerToSlice(at: VT.ints, body: body) }
public var floats: FlatbufferVector<Float32> { return _accessor.vector(at: VT.floats, byteSize: 4) }
public func withUnsafePointerToFloats<T>(_ body: (UnsafeRawBufferPointer, Int) throws -> T) rethrows -> T? { return try _accessor.withUnsafePointerToSlice(at: VT.floats, body: body) }
public var emptyString: String? { let o = _accessor.offset(VT.emptyString); return o == 0 ? "" : _accessor.string(at: o) }
public var emptyStringSegmentArray: [UInt8]? { return _accessor.getVector(at: VT.emptyString) }
public var someString: String? { let o = _accessor.offset(VT.someString); return o == 0 ? "some" : _accessor.string(at: o) }
public var someStringSegmentArray: [UInt8]? { return _accessor.getVector(at: VT.someString) }
public var abcs: FlatbufferVector<ABC> { return _accessor.vector(at: VT.abcs, byteSize: 4) }
public var bools: FlatbufferVector<Bool> { return _accessor.vector(at: VT.bools, byteSize: 1) }
public func withUnsafePointerToBools<T>(_ body: (UnsafeRawBufferPointer, Int) throws -> T) rethrows -> T? { return try _accessor.withUnsafePointerToSlice(at: VT.bools, body: body) }
public var ints: FlatbufferVector<Int32> { return _accessor.vector(at: VTOFFSET.ints.v, byteSize: 4) }
public func withUnsafePointerToInts<T>(_ body: (UnsafeRawBufferPointer, Int) throws -> T) rethrows -> T? { return try _accessor.withUnsafePointerToSlice(at: VTOFFSET.ints.v, body: body) }
public var floats: FlatbufferVector<Float32> { return _accessor.vector(at: VTOFFSET.floats.v, byteSize: 4) }
public func withUnsafePointerToFloats<T>(_ body: (UnsafeRawBufferPointer, Int) throws -> T) rethrows -> T? { return try _accessor.withUnsafePointerToSlice(at: VTOFFSET.floats.v, body: body) }
public var emptyString: String? { let o = _accessor.offset(VTOFFSET.emptyString.v); return o == 0 ? "" : _accessor.string(at: o) }
public var emptyStringSegmentArray: [UInt8]? { return _accessor.getVector(at: VTOFFSET.emptyString.v) }
public var someString: String? { let o = _accessor.offset(VTOFFSET.someString.v); return o == 0 ? "some" : _accessor.string(at: o) }
public var someStringSegmentArray: [UInt8]? { return _accessor.getVector(at: VTOFFSET.someString.v) }
public var abcs: FlatbufferVector<ABC> { return _accessor.vector(at: VTOFFSET.abcs.v, byteSize: 4) }
public var bools: FlatbufferVector<Bool> { return _accessor.vector(at: VTOFFSET.bools.v, byteSize: 1) }
public func withUnsafePointerToBools<T>(_ body: (UnsafeRawBufferPointer, Int) throws -> T) rethrows -> T? { return try _accessor.withUnsafePointerToSlice(at: VTOFFSET.bools.v, body: body) }
public static func startMoreDefaults(_ fbb: inout FlatBufferBuilder) -> UOffset { fbb.startTable(with: 6) }
public static func addVectorOf(ints: Offset, _ fbb: inout FlatBufferBuilder) { fbb.add(offset: ints, at: VT.ints) }
public static func addVectorOf(floats: Offset, _ fbb: inout FlatBufferBuilder) { fbb.add(offset: floats, at: VT.floats) }
public static func add(emptyString: Offset, _ fbb: inout FlatBufferBuilder) { fbb.add(offset: emptyString, at: VT.emptyString) }
public static func add(someString: Offset, _ fbb: inout FlatBufferBuilder) { fbb.add(offset: someString, at: VT.someString) }
public static func addVectorOf(abcs: Offset, _ fbb: inout FlatBufferBuilder) { fbb.add(offset: abcs, at: VT.abcs) }
public static func addVectorOf(bools: Offset, _ fbb: inout FlatBufferBuilder) { fbb.add(offset: bools, at: VT.bools) }
public static func addVectorOf(ints: Offset, _ fbb: inout FlatBufferBuilder) { fbb.add(offset: ints, at: VTOFFSET.ints.p) }
public static func addVectorOf(floats: Offset, _ fbb: inout FlatBufferBuilder) { fbb.add(offset: floats, at: VTOFFSET.floats.p) }
public static func add(emptyString: Offset, _ fbb: inout FlatBufferBuilder) { fbb.add(offset: emptyString, at: VTOFFSET.emptyString.p) }
public static func add(someString: Offset, _ fbb: inout FlatBufferBuilder) { fbb.add(offset: someString, at: VTOFFSET.someString.p) }
public static func addVectorOf(abcs: Offset, _ fbb: inout FlatBufferBuilder) { fbb.add(offset: abcs, at: VTOFFSET.abcs.p) }
public static func addVectorOf(bools: Offset, _ fbb: inout FlatBufferBuilder) { fbb.add(offset: bools, at: VTOFFSET.bools.p) }
public static func endMoreDefaults(_ fbb: inout FlatBufferBuilder, start: UOffset) -> Offset { let end = Offset(offset: fbb.endTable(at: start)); return end }
public static func createMoreDefaults(
_ fbb: inout FlatBufferBuilder,
@@ -126,17 +128,18 @@ public struct MoreDefaults: FlatBufferVerifiableTable, FlatbuffersVectorInitiali
public static func verify<T>(_ verifier: inout Verifier, at position: Int, of type: T.Type) throws where T: Verifiable {
var _v = try verifier.visitTable(at: position)
try _v.visit(field: VT.ints, fieldName: "ints", required: false, type: ForwardOffset<Vector<Int32, Int32>>.self)
try _v.visit(field: VT.floats, fieldName: "floats", required: false, type: ForwardOffset<Vector<Float32, Float32>>.self)
try _v.visit(field: VT.emptyString, fieldName: "emptyString", required: false, type: ForwardOffset<String>.self)
try _v.visit(field: VT.someString, fieldName: "someString", required: false, type: ForwardOffset<String>.self)
try _v.visit(field: VT.abcs, fieldName: "abcs", required: false, type: ForwardOffset<Vector<ABC, ABC>>.self)
try _v.visit(field: VT.bools, fieldName: "bools", required: false, type: ForwardOffset<Vector<Bool, Bool>>.self)
try _v.visit(field: VTOFFSET.ints.p, fieldName: "ints", required: false, type: ForwardOffset<Vector<Int32, Int32>>.self)
try _v.visit(field: VTOFFSET.floats.p, fieldName: "floats", required: false, type: ForwardOffset<Vector<Float32, Float32>>.self)
try _v.visit(field: VTOFFSET.emptyString.p, fieldName: "emptyString", required: false, type: ForwardOffset<String>.self)
try _v.visit(field: VTOFFSET.someString.p, fieldName: "someString", required: false, type: ForwardOffset<String>.self)
try _v.visit(field: VTOFFSET.abcs.p, fieldName: "abcs", required: false, type: ForwardOffset<Vector<ABC, ABC>>.self)
try _v.visit(field: VTOFFSET.bools.p, fieldName: "bools", required: false, type: ForwardOffset<Vector<Bool, Bool>>.self)
_v.finish()
}
}
extension MoreDefaults: Encodable {
enum CodingKeys: String, CodingKey {
case ints = "ints"
case floats = "floats"
@@ -145,7 +148,6 @@ extension MoreDefaults: Encodable {
case abcs = "abcs"
case bools = "bools"
}
public func encode(to encoder: Encoder) throws {
var container = encoder.container(keyedBy: CodingKeys.self)
try container.encodeIfPresent(ints, forKey: .ints)
tests/swift/Tests/Flatbuffers/nan_inf_test_generated.swift
+33 -31
View File
@@ -8,7 +8,7 @@ import Common
import FlatBuffers
public struct Swift_Tests_NanInfTable: FlatBufferVerifiableTable, FlatbuffersVectorInitializable {
public struct Swift_Tests_NanInfTable: FlatBufferTable, FlatbuffersVectorInitializable, Verifiable {
static func validateVersion() { FlatBuffersVersion_25_12_19() }
public var __buffer: ByteBuffer! { return _accessor.bb }
@@ -17,31 +17,33 @@ public struct Swift_Tests_NanInfTable: FlatBufferVerifiableTable, FlatbuffersVec
private init(_ t: Table) { _accessor = t }
public init(_ bb: ByteBuffer, o: Int32) { _accessor = Table(bb: bb, position: o) }
private struct VT {
static let defaultNan: VOffset = 4
static let defaultInf: VOffset = 6
static let defaultNinf: VOffset = 8
static let valueNan: VOffset = 10
static let valueInf: VOffset = 12
static let valueNinf: VOffset = 14
static let value: VOffset = 16
private enum VTOFFSET: VOffset {
case defaultNan = 4
case defaultInf = 6
case defaultNinf = 8
case valueNan = 10
case valueInf = 12
case valueNinf = 14
case value = 16
var v: Int32 { Int32(self.rawValue) }
var p: VOffset { self.rawValue }
}
public var defaultNan: Double { let o = _accessor.offset(VT.defaultNan); return o == 0 ? .nan : _accessor.readBuffer(of: Double.self, at: o) }
public var defaultInf: Double { let o = _accessor.offset(VT.defaultInf); return o == 0 ? .infinity : _accessor.readBuffer(of: Double.self, at: o) }
public var defaultNinf: Double { let o = _accessor.offset(VT.defaultNinf); return o == 0 ? -.infinity : _accessor.readBuffer(of: Double.self, at: o) }
public var valueNan: Double { let o = _accessor.offset(VT.valueNan); return o == 0 ? 0.0 : _accessor.readBuffer(of: Double.self, at: o) }
public var valueInf: Double { let o = _accessor.offset(VT.valueInf); return o == 0 ? 0.0 : _accessor.readBuffer(of: Double.self, at: o) }
public var valueNinf: Double { let o = _accessor.offset(VT.valueNinf); return o == 0 ? 0.0 : _accessor.readBuffer(of: Double.self, at: o) }
public var value: Double { let o = _accessor.offset(VT.value); return o == 0 ? 0.0 : _accessor.readBuffer(of: Double.self, at: o) }
public var defaultNan: Double { let o = _accessor.offset(VTOFFSET.defaultNan.v); return o == 0 ? .nan : _accessor.readBuffer(of: Double.self, at: o) }
public var defaultInf: Double { let o = _accessor.offset(VTOFFSET.defaultInf.v); return o == 0 ? .infinity : _accessor.readBuffer(of: Double.self, at: o) }
public var defaultNinf: Double { let o = _accessor.offset(VTOFFSET.defaultNinf.v); return o == 0 ? -.infinity : _accessor.readBuffer(of: Double.self, at: o) }
public var valueNan: Double { let o = _accessor.offset(VTOFFSET.valueNan.v); return o == 0 ? 0.0 : _accessor.readBuffer(of: Double.self, at: o) }
public var valueInf: Double { let o = _accessor.offset(VTOFFSET.valueInf.v); return o == 0 ? 0.0 : _accessor.readBuffer(of: Double.self, at: o) }
public var valueNinf: Double { let o = _accessor.offset(VTOFFSET.valueNinf.v); return o == 0 ? 0.0 : _accessor.readBuffer(of: Double.self, at: o) }
public var value: Double { let o = _accessor.offset(VTOFFSET.value.v); return o == 0 ? 0.0 : _accessor.readBuffer(of: Double.self, at: o) }
public static func startNanInfTable(_ fbb: inout FlatBufferBuilder) -> UOffset { fbb.startTable(with: 7) }
public static func add(defaultNan: Double, _ fbb: inout FlatBufferBuilder) { fbb.add(element: defaultNan, def: .nan, at: VT.defaultNan) }
public static func add(defaultInf: Double, _ fbb: inout FlatBufferBuilder) { fbb.add(element: defaultInf, def: .infinity, at: VT.defaultInf) }
public static func add(defaultNinf: Double, _ fbb: inout FlatBufferBuilder) { fbb.add(element: defaultNinf, def: -.infinity, at: VT.defaultNinf) }
public static func add(valueNan: Double, _ fbb: inout FlatBufferBuilder) { fbb.add(element: valueNan, def: 0.0, at: VT.valueNan) }
public static func add(valueInf: Double, _ fbb: inout FlatBufferBuilder) { fbb.add(element: valueInf, def: 0.0, at: VT.valueInf) }
public static func add(valueNinf: Double, _ fbb: inout FlatBufferBuilder) { fbb.add(element: valueNinf, def: 0.0, at: VT.valueNinf) }
public static func add(value: Double, _ fbb: inout FlatBufferBuilder) { fbb.add(element: value, def: 0.0, at: VT.value) }
public static func add(defaultNan: Double, _ fbb: inout FlatBufferBuilder) { fbb.add(element: defaultNan, def: .nan, at: VTOFFSET.defaultNan.p) }
public static func add(defaultInf: Double, _ fbb: inout FlatBufferBuilder) { fbb.add(element: defaultInf, def: .infinity, at: VTOFFSET.defaultInf.p) }
public static func add(defaultNinf: Double, _ fbb: inout FlatBufferBuilder) { fbb.add(element: defaultNinf, def: -.infinity, at: VTOFFSET.defaultNinf.p) }
public static func add(valueNan: Double, _ fbb: inout FlatBufferBuilder) { fbb.add(element: valueNan, def: 0.0, at: VTOFFSET.valueNan.p) }
public static func add(valueInf: Double, _ fbb: inout FlatBufferBuilder) { fbb.add(element: valueInf, def: 0.0, at: VTOFFSET.valueInf.p) }
public static func add(valueNinf: Double, _ fbb: inout FlatBufferBuilder) { fbb.add(element: valueNinf, def: 0.0, at: VTOFFSET.valueNinf.p) }
public static func add(value: Double, _ fbb: inout FlatBufferBuilder) { fbb.add(element: value, def: 0.0, at: VTOFFSET.value.p) }
public static func endNanInfTable(_ fbb: inout FlatBufferBuilder, start: UOffset) -> Offset { let end = Offset(offset: fbb.endTable(at: start)); return end }
public static func createNanInfTable(
_ fbb: inout FlatBufferBuilder,
@@ -66,18 +68,19 @@ public struct Swift_Tests_NanInfTable: FlatBufferVerifiableTable, FlatbuffersVec
public static func verify<T>(_ verifier: inout Verifier, at position: Int, of type: T.Type) throws where T: Verifiable {
var _v = try verifier.visitTable(at: position)
try _v.visit(field: VT.defaultNan, fieldName: "defaultNan", required: false, type: Double.self)
try _v.visit(field: VT.defaultInf, fieldName: "defaultInf", required: false, type: Double.self)
try _v.visit(field: VT.defaultNinf, fieldName: "defaultNinf", required: false, type: Double.self)
try _v.visit(field: VT.valueNan, fieldName: "valueNan", required: false, type: Double.self)
try _v.visit(field: VT.valueInf, fieldName: "valueInf", required: false, type: Double.self)
try _v.visit(field: VT.valueNinf, fieldName: "valueNinf", required: false, type: Double.self)
try _v.visit(field: VT.value, fieldName: "value", required: false, type: Double.self)
try _v.visit(field: VTOFFSET.defaultNan.p, fieldName: "defaultNan", required: false, type: Double.self)
try _v.visit(field: VTOFFSET.defaultInf.p, fieldName: "defaultInf", required: false, type: Double.self)
try _v.visit(field: VTOFFSET.defaultNinf.p, fieldName: "defaultNinf", required: false, type: Double.self)
try _v.visit(field: VTOFFSET.valueNan.p, fieldName: "valueNan", required: false, type: Double.self)
try _v.visit(field: VTOFFSET.valueInf.p, fieldName: "valueInf", required: false, type: Double.self)
try _v.visit(field: VTOFFSET.valueNinf.p, fieldName: "valueNinf", required: false, type: Double.self)
try _v.visit(field: VTOFFSET.value.p, fieldName: "value", required: false, type: Double.self)
_v.finish()
}
}
extension Swift_Tests_NanInfTable: Encodable {
enum CodingKeys: String, CodingKey {
case defaultNan = "default_nan"
case defaultInf = "default_inf"
@@ -87,7 +90,6 @@ extension Swift_Tests_NanInfTable: Encodable {
case valueNinf = "value_ninf"
case value = "value"
}
public func encode(to encoder: Encoder) throws {
var container = encoder.container(keyedBy: CodingKeys.self)
if !defaultNan.isNaN {
tests/swift/Tests/Flatbuffers/optional_scalars_generated.swift
+149 -147
View File
@@ -31,7 +31,7 @@ extension optional_scalars_OptionalByte: Encodable {
}
}
public struct optional_scalars_ScalarStuff: FlatBufferVerifiableTable, FlatbuffersVectorInitializable {
public struct optional_scalars_ScalarStuff: FlatBufferTable, FlatbuffersVectorInitializable, Verifiable {
static func validateVersion() { FlatBuffersVersion_25_12_19() }
public var __buffer: ByteBuffer! { return _accessor.bb }
@@ -42,120 +42,122 @@ public struct optional_scalars_ScalarStuff: FlatBufferVerifiableTable, Flatbuffe
private init(_ t: Table) { _accessor = t }
public init(_ bb: ByteBuffer, o: Int32) { _accessor = Table(bb: bb, position: o) }
private struct VT {
static let justI8: VOffset = 4
static let maybeI8: VOffset = 6
static let defaultI8: VOffset = 8
static let justU8: VOffset = 10
static let maybeU8: VOffset = 12
static let defaultU8: VOffset = 14
static let justI16: VOffset = 16
static let maybeI16: VOffset = 18
static let defaultI16: VOffset = 20
static let justU16: VOffset = 22
static let maybeU16: VOffset = 24
static let defaultU16: VOffset = 26
static let justI32: VOffset = 28
static let maybeI32: VOffset = 30
static let defaultI32: VOffset = 32
static let justU32: VOffset = 34
static let maybeU32: VOffset = 36
static let defaultU32: VOffset = 38
static let justI64: VOffset = 40
static let maybeI64: VOffset = 42
static let defaultI64: VOffset = 44
static let justU64: VOffset = 46
static let maybeU64: VOffset = 48
static let defaultU64: VOffset = 50
static let justF32: VOffset = 52
static let maybeF32: VOffset = 54
static let defaultF32: VOffset = 56
static let justF64: VOffset = 58
static let maybeF64: VOffset = 60
static let defaultF64: VOffset = 62
static let justBool: VOffset = 64
static let maybeBool: VOffset = 66
static let defaultBool: VOffset = 68
static let justEnum: VOffset = 70
static let maybeEnum: VOffset = 72
static let defaultEnum: VOffset = 74
private enum VTOFFSET: VOffset {
case justI8 = 4
case maybeI8 = 6
case defaultI8 = 8
case justU8 = 10
case maybeU8 = 12
case defaultU8 = 14
case justI16 = 16
case maybeI16 = 18
case defaultI16 = 20
case justU16 = 22
case maybeU16 = 24
case defaultU16 = 26
case justI32 = 28
case maybeI32 = 30
case defaultI32 = 32
case justU32 = 34
case maybeU32 = 36
case defaultU32 = 38
case justI64 = 40
case maybeI64 = 42
case defaultI64 = 44
case justU64 = 46
case maybeU64 = 48
case defaultU64 = 50
case justF32 = 52
case maybeF32 = 54
case defaultF32 = 56
case justF64 = 58
case maybeF64 = 60
case defaultF64 = 62
case justBool = 64
case maybeBool = 66
case defaultBool = 68
case justEnum = 70
case maybeEnum = 72
case defaultEnum = 74
var v: Int32 { Int32(self.rawValue) }
var p: VOffset { self.rawValue }
}
public var justI8: Int8 { let o = _accessor.offset(VT.justI8); return o == 0 ? 0 : _accessor.readBuffer(of: Int8.self, at: o) }
public var maybeI8: Int8? { let o = _accessor.offset(VT.maybeI8); return o == 0 ? nil : _accessor.readBuffer(of: Int8.self, at: o) }
public var defaultI8: Int8 { let o = _accessor.offset(VT.defaultI8); return o == 0 ? 42 : _accessor.readBuffer(of: Int8.self, at: o) }
public var justU8: UInt8 { let o = _accessor.offset(VT.justU8); return o == 0 ? 0 : _accessor.readBuffer(of: UInt8.self, at: o) }
public var maybeU8: UInt8? { let o = _accessor.offset(VT.maybeU8); return o == 0 ? nil : _accessor.readBuffer(of: UInt8.self, at: o) }
public var defaultU8: UInt8 { let o = _accessor.offset(VT.defaultU8); return o == 0 ? 42 : _accessor.readBuffer(of: UInt8.self, at: o) }
public var justI16: Int16 { let o = _accessor.offset(VT.justI16); return o == 0 ? 0 : _accessor.readBuffer(of: Int16.self, at: o) }
public var maybeI16: Int16? { let o = _accessor.offset(VT.maybeI16); return o == 0 ? nil : _accessor.readBuffer(of: Int16.self, at: o) }
public var defaultI16: Int16 { let o = _accessor.offset(VT.defaultI16); return o == 0 ? 42 : _accessor.readBuffer(of: Int16.self, at: o) }
public var justU16: UInt16 { let o = _accessor.offset(VT.justU16); return o == 0 ? 0 : _accessor.readBuffer(of: UInt16.self, at: o) }
public var maybeU16: UInt16? { let o = _accessor.offset(VT.maybeU16); return o == 0 ? nil : _accessor.readBuffer(of: UInt16.self, at: o) }
public var defaultU16: UInt16 { let o = _accessor.offset(VT.defaultU16); return o == 0 ? 42 : _accessor.readBuffer(of: UInt16.self, at: o) }
public var justI32: Int32 { let o = _accessor.offset(VT.justI32); return o == 0 ? 0 : _accessor.readBuffer(of: Int32.self, at: o) }
public var maybeI32: Int32? { let o = _accessor.offset(VT.maybeI32); return o == 0 ? nil : _accessor.readBuffer(of: Int32.self, at: o) }
public var defaultI32: Int32 { let o = _accessor.offset(VT.defaultI32); return o == 0 ? 42 : _accessor.readBuffer(of: Int32.self, at: o) }
public var justU32: UInt32 { let o = _accessor.offset(VT.justU32); return o == 0 ? 0 : _accessor.readBuffer(of: UInt32.self, at: o) }
public var maybeU32: UInt32? { let o = _accessor.offset(VT.maybeU32); return o == 0 ? nil : _accessor.readBuffer(of: UInt32.self, at: o) }
public var defaultU32: UInt32 { let o = _accessor.offset(VT.defaultU32); return o == 0 ? 42 : _accessor.readBuffer(of: UInt32.self, at: o) }
public var justI64: Int64 { let o = _accessor.offset(VT.justI64); return o == 0 ? 0 : _accessor.readBuffer(of: Int64.self, at: o) }
public var maybeI64: Int64? { let o = _accessor.offset(VT.maybeI64); return o == 0 ? nil : _accessor.readBuffer(of: Int64.self, at: o) }
public var defaultI64: Int64 { let o = _accessor.offset(VT.defaultI64); return o == 0 ? 42 : _accessor.readBuffer(of: Int64.self, at: o) }
public var justU64: UInt64 { let o = _accessor.offset(VT.justU64); return o == 0 ? 0 : _accessor.readBuffer(of: UInt64.self, at: o) }
public var maybeU64: UInt64? { let o = _accessor.offset(VT.maybeU64); return o == 0 ? nil : _accessor.readBuffer(of: UInt64.self, at: o) }
public var defaultU64: UInt64 { let o = _accessor.offset(VT.defaultU64); return o == 0 ? 42 : _accessor.readBuffer(of: UInt64.self, at: o) }
public var justF32: Float32 { let o = _accessor.offset(VT.justF32); return o == 0 ? 0.0 : _accessor.readBuffer(of: Float32.self, at: o) }
public var maybeF32: Float32? { let o = _accessor.offset(VT.maybeF32); return o == 0 ? nil : _accessor.readBuffer(of: Float32.self, at: o) }
public var defaultF32: Float32 { let o = _accessor.offset(VT.defaultF32); return o == 0 ? 42.0 : _accessor.readBuffer(of: Float32.self, at: o) }
public var justF64: Double { let o = _accessor.offset(VT.justF64); return o == 0 ? 0.0 : _accessor.readBuffer(of: Double.self, at: o) }
public var maybeF64: Double? { let o = _accessor.offset(VT.maybeF64); return o == 0 ? nil : _accessor.readBuffer(of: Double.self, at: o) }
public var defaultF64: Double { let o = _accessor.offset(VT.defaultF64); return o == 0 ? 42.0 : _accessor.readBuffer(of: Double.self, at: o) }
public var justBool: Bool { let o = _accessor.offset(VT.justBool); return o == 0 ? false : _accessor.readBuffer(of: Bool.self, at: o) }
public var maybeBool: Bool? { let o = _accessor.offset(VT.maybeBool); return o == 0 ? nil : _accessor.readBuffer(of: Bool.self, at: o) }
public var defaultBool: Bool { let o = _accessor.offset(VT.defaultBool); return o == 0 ? true : _accessor.readBuffer(of: Bool.self, at: o) }
public var justEnum: optional_scalars_OptionalByte { let o = _accessor.offset(VT.justEnum); return o == 0 ? .none_ : optional_scalars_OptionalByte(rawValue: _accessor.readBuffer(of: Int8.self, at: o)) ?? .none_ }
public var maybeEnum: optional_scalars_OptionalByte? { let o = _accessor.offset(VT.maybeEnum); return o == 0 ? nil : optional_scalars_OptionalByte(rawValue: _accessor.readBuffer(of: Int8.self, at: o)) ?? nil }
public var defaultEnum: optional_scalars_OptionalByte { let o = _accessor.offset(VT.defaultEnum); return o == 0 ? .one : optional_scalars_OptionalByte(rawValue: _accessor.readBuffer(of: Int8.self, at: o)) ?? .one }
public var justI8: Int8 { let o = _accessor.offset(VTOFFSET.justI8.v); return o == 0 ? 0 : _accessor.readBuffer(of: Int8.self, at: o) }
public var maybeI8: Int8? { let o = _accessor.offset(VTOFFSET.maybeI8.v); return o == 0 ? nil : _accessor.readBuffer(of: Int8.self, at: o) }
public var defaultI8: Int8 { let o = _accessor.offset(VTOFFSET.defaultI8.v); return o == 0 ? 42 : _accessor.readBuffer(of: Int8.self, at: o) }
public var justU8: UInt8 { let o = _accessor.offset(VTOFFSET.justU8.v); return o == 0 ? 0 : _accessor.readBuffer(of: UInt8.self, at: o) }
public var maybeU8: UInt8? { let o = _accessor.offset(VTOFFSET.maybeU8.v); return o == 0 ? nil : _accessor.readBuffer(of: UInt8.self, at: o) }
public var defaultU8: UInt8 { let o = _accessor.offset(VTOFFSET.defaultU8.v); return o == 0 ? 42 : _accessor.readBuffer(of: UInt8.self, at: o) }
public var justI16: Int16 { let o = _accessor.offset(VTOFFSET.justI16.v); return o == 0 ? 0 : _accessor.readBuffer(of: Int16.self, at: o) }
public var maybeI16: Int16? { let o = _accessor.offset(VTOFFSET.maybeI16.v); return o == 0 ? nil : _accessor.readBuffer(of: Int16.self, at: o) }
public var defaultI16: Int16 { let o = _accessor.offset(VTOFFSET.defaultI16.v); return o == 0 ? 42 : _accessor.readBuffer(of: Int16.self, at: o) }
public var justU16: UInt16 { let o = _accessor.offset(VTOFFSET.justU16.v); return o == 0 ? 0 : _accessor.readBuffer(of: UInt16.self, at: o) }
public var maybeU16: UInt16? { let o = _accessor.offset(VTOFFSET.maybeU16.v); return o == 0 ? nil : _accessor.readBuffer(of: UInt16.self, at: o) }
public var defaultU16: UInt16 { let o = _accessor.offset(VTOFFSET.defaultU16.v); return o == 0 ? 42 : _accessor.readBuffer(of: UInt16.self, at: o) }
public var justI32: Int32 { let o = _accessor.offset(VTOFFSET.justI32.v); return o == 0 ? 0 : _accessor.readBuffer(of: Int32.self, at: o) }
public var maybeI32: Int32? { let o = _accessor.offset(VTOFFSET.maybeI32.v); return o == 0 ? nil : _accessor.readBuffer(of: Int32.self, at: o) }
public var defaultI32: Int32 { let o = _accessor.offset(VTOFFSET.defaultI32.v); return o == 0 ? 42 : _accessor.readBuffer(of: Int32.self, at: o) }
public var justU32: UInt32 { let o = _accessor.offset(VTOFFSET.justU32.v); return o == 0 ? 0 : _accessor.readBuffer(of: UInt32.self, at: o) }
public var maybeU32: UInt32? { let o = _accessor.offset(VTOFFSET.maybeU32.v); return o == 0 ? nil : _accessor.readBuffer(of: UInt32.self, at: o) }
public var defaultU32: UInt32 { let o = _accessor.offset(VTOFFSET.defaultU32.v); return o == 0 ? 42 : _accessor.readBuffer(of: UInt32.self, at: o) }
public var justI64: Int64 { let o = _accessor.offset(VTOFFSET.justI64.v); return o == 0 ? 0 : _accessor.readBuffer(of: Int64.self, at: o) }
public var maybeI64: Int64? { let o = _accessor.offset(VTOFFSET.maybeI64.v); return o == 0 ? nil : _accessor.readBuffer(of: Int64.self, at: o) }
public var defaultI64: Int64 { let o = _accessor.offset(VTOFFSET.defaultI64.v); return o == 0 ? 42 : _accessor.readBuffer(of: Int64.self, at: o) }
public var justU64: UInt64 { let o = _accessor.offset(VTOFFSET.justU64.v); return o == 0 ? 0 : _accessor.readBuffer(of: UInt64.self, at: o) }
public var maybeU64: UInt64? { let o = _accessor.offset(VTOFFSET.maybeU64.v); return o == 0 ? nil : _accessor.readBuffer(of: UInt64.self, at: o) }
public var defaultU64: UInt64 { let o = _accessor.offset(VTOFFSET.defaultU64.v); return o == 0 ? 42 : _accessor.readBuffer(of: UInt64.self, at: o) }
public var justF32: Float32 { let o = _accessor.offset(VTOFFSET.justF32.v); return o == 0 ? 0.0 : _accessor.readBuffer(of: Float32.self, at: o) }
public var maybeF32: Float32? { let o = _accessor.offset(VTOFFSET.maybeF32.v); return o == 0 ? nil : _accessor.readBuffer(of: Float32.self, at: o) }
public var defaultF32: Float32 { let o = _accessor.offset(VTOFFSET.defaultF32.v); return o == 0 ? 42.0 : _accessor.readBuffer(of: Float32.self, at: o) }
public var justF64: Double { let o = _accessor.offset(VTOFFSET.justF64.v); return o == 0 ? 0.0 : _accessor.readBuffer(of: Double.self, at: o) }
public var maybeF64: Double? { let o = _accessor.offset(VTOFFSET.maybeF64.v); return o == 0 ? nil : _accessor.readBuffer(of: Double.self, at: o) }
public var defaultF64: Double { let o = _accessor.offset(VTOFFSET.defaultF64.v); return o == 0 ? 42.0 : _accessor.readBuffer(of: Double.self, at: o) }
public var justBool: Bool { let o = _accessor.offset(VTOFFSET.justBool.v); return o == 0 ? false : _accessor.readBuffer(of: Bool.self, at: o) }
public var maybeBool: Bool? { let o = _accessor.offset(VTOFFSET.maybeBool.v); return o == 0 ? nil : _accessor.readBuffer(of: Bool.self, at: o) }
public var defaultBool: Bool { let o = _accessor.offset(VTOFFSET.defaultBool.v); return o == 0 ? true : _accessor.readBuffer(of: Bool.self, at: o) }
public var justEnum: optional_scalars_OptionalByte { let o = _accessor.offset(VTOFFSET.justEnum.v); return o == 0 ? .none_ : optional_scalars_OptionalByte(rawValue: _accessor.readBuffer(of: Int8.self, at: o)) ?? .none_ }
public var maybeEnum: optional_scalars_OptionalByte? { let o = _accessor.offset(VTOFFSET.maybeEnum.v); return o == 0 ? nil : optional_scalars_OptionalByte(rawValue: _accessor.readBuffer(of: Int8.self, at: o)) ?? nil }
public var defaultEnum: optional_scalars_OptionalByte { let o = _accessor.offset(VTOFFSET.defaultEnum.v); return o == 0 ? .one : optional_scalars_OptionalByte(rawValue: _accessor.readBuffer(of: Int8.self, at: o)) ?? .one }
public static func startScalarStuff(_ fbb: inout FlatBufferBuilder) -> UOffset { fbb.startTable(with: 36) }
public static func add(justI8: Int8, _ fbb: inout FlatBufferBuilder) { fbb.add(element: justI8, def: 0, at: VT.justI8) }
public static func add(maybeI8: Int8?, _ fbb: inout FlatBufferBuilder) { fbb.add(element: maybeI8, at: VT.maybeI8) }
public static func add(defaultI8: Int8, _ fbb: inout FlatBufferBuilder) { fbb.add(element: defaultI8, def: 42, at: VT.defaultI8) }
public static func add(justU8: UInt8, _ fbb: inout FlatBufferBuilder) { fbb.add(element: justU8, def: 0, at: VT.justU8) }
public static func add(maybeU8: UInt8?, _ fbb: inout FlatBufferBuilder) { fbb.add(element: maybeU8, at: VT.maybeU8) }
public static func add(defaultU8: UInt8, _ fbb: inout FlatBufferBuilder) { fbb.add(element: defaultU8, def: 42, at: VT.defaultU8) }
public static func add(justI16: Int16, _ fbb: inout FlatBufferBuilder) { fbb.add(element: justI16, def: 0, at: VT.justI16) }
public static func add(maybeI16: Int16?, _ fbb: inout FlatBufferBuilder) { fbb.add(element: maybeI16, at: VT.maybeI16) }
public static func add(defaultI16: Int16, _ fbb: inout FlatBufferBuilder) { fbb.add(element: defaultI16, def: 42, at: VT.defaultI16) }
public static func add(justU16: UInt16, _ fbb: inout FlatBufferBuilder) { fbb.add(element: justU16, def: 0, at: VT.justU16) }
public static func add(maybeU16: UInt16?, _ fbb: inout FlatBufferBuilder) { fbb.add(element: maybeU16, at: VT.maybeU16) }
public static func add(defaultU16: UInt16, _ fbb: inout FlatBufferBuilder) { fbb.add(element: defaultU16, def: 42, at: VT.defaultU16) }
public static func add(justI32: Int32, _ fbb: inout FlatBufferBuilder) { fbb.add(element: justI32, def: 0, at: VT.justI32) }
public static func add(maybeI32: Int32?, _ fbb: inout FlatBufferBuilder) { fbb.add(element: maybeI32, at: VT.maybeI32) }
public static func add(defaultI32: Int32, _ fbb: inout FlatBufferBuilder) { fbb.add(element: defaultI32, def: 42, at: VT.defaultI32) }
public static func add(justU32: UInt32, _ fbb: inout FlatBufferBuilder) { fbb.add(element: justU32, def: 0, at: VT.justU32) }
public static func add(maybeU32: UInt32?, _ fbb: inout FlatBufferBuilder) { fbb.add(element: maybeU32, at: VT.maybeU32) }
public static func add(defaultU32: UInt32, _ fbb: inout FlatBufferBuilder) { fbb.add(element: defaultU32, def: 42, at: VT.defaultU32) }
public static func add(justI64: Int64, _ fbb: inout FlatBufferBuilder) { fbb.add(element: justI64, def: 0, at: VT.justI64) }
public static func add(maybeI64: Int64?, _ fbb: inout FlatBufferBuilder) { fbb.add(element: maybeI64, at: VT.maybeI64) }
public static func add(defaultI64: Int64, _ fbb: inout FlatBufferBuilder) { fbb.add(element: defaultI64, def: 42, at: VT.defaultI64) }
public static func add(justU64: UInt64, _ fbb: inout FlatBufferBuilder) { fbb.add(element: justU64, def: 0, at: VT.justU64) }
public static func add(maybeU64: UInt64?, _ fbb: inout FlatBufferBuilder) { fbb.add(element: maybeU64, at: VT.maybeU64) }
public static func add(defaultU64: UInt64, _ fbb: inout FlatBufferBuilder) { fbb.add(element: defaultU64, def: 42, at: VT.defaultU64) }
public static func add(justF32: Float32, _ fbb: inout FlatBufferBuilder) { fbb.add(element: justF32, def: 0.0, at: VT.justF32) }
public static func add(maybeF32: Float32?, _ fbb: inout FlatBufferBuilder) { fbb.add(element: maybeF32, at: VT.maybeF32) }
public static func add(defaultF32: Float32, _ fbb: inout FlatBufferBuilder) { fbb.add(element: defaultF32, def: 42.0, at: VT.defaultF32) }
public static func add(justF64: Double, _ fbb: inout FlatBufferBuilder) { fbb.add(element: justF64, def: 0.0, at: VT.justF64) }
public static func add(maybeF64: Double?, _ fbb: inout FlatBufferBuilder) { fbb.add(element: maybeF64, at: VT.maybeF64) }
public static func add(defaultF64: Double, _ fbb: inout FlatBufferBuilder) { fbb.add(element: defaultF64, def: 42.0, at: VT.defaultF64) }
public static func add(justI8: Int8, _ fbb: inout FlatBufferBuilder) { fbb.add(element: justI8, def: 0, at: VTOFFSET.justI8.p) }
public static func add(maybeI8: Int8?, _ fbb: inout FlatBufferBuilder) { fbb.add(element: maybeI8, at: VTOFFSET.maybeI8.p) }
public static func add(defaultI8: Int8, _ fbb: inout FlatBufferBuilder) { fbb.add(element: defaultI8, def: 42, at: VTOFFSET.defaultI8.p) }
public static func add(justU8: UInt8, _ fbb: inout FlatBufferBuilder) { fbb.add(element: justU8, def: 0, at: VTOFFSET.justU8.p) }
public static func add(maybeU8: UInt8?, _ fbb: inout FlatBufferBuilder) { fbb.add(element: maybeU8, at: VTOFFSET.maybeU8.p) }
public static func add(defaultU8: UInt8, _ fbb: inout FlatBufferBuilder) { fbb.add(element: defaultU8, def: 42, at: VTOFFSET.defaultU8.p) }
public static func add(justI16: Int16, _ fbb: inout FlatBufferBuilder) { fbb.add(element: justI16, def: 0, at: VTOFFSET.justI16.p) }
public static func add(maybeI16: Int16?, _ fbb: inout FlatBufferBuilder) { fbb.add(element: maybeI16, at: VTOFFSET.maybeI16.p) }
public static func add(defaultI16: Int16, _ fbb: inout FlatBufferBuilder) { fbb.add(element: defaultI16, def: 42, at: VTOFFSET.defaultI16.p) }
public static func add(justU16: UInt16, _ fbb: inout FlatBufferBuilder) { fbb.add(element: justU16, def: 0, at: VTOFFSET.justU16.p) }
public static func add(maybeU16: UInt16?, _ fbb: inout FlatBufferBuilder) { fbb.add(element: maybeU16, at: VTOFFSET.maybeU16.p) }
public static func add(defaultU16: UInt16, _ fbb: inout FlatBufferBuilder) { fbb.add(element: defaultU16, def: 42, at: VTOFFSET.defaultU16.p) }
public static func add(justI32: Int32, _ fbb: inout FlatBufferBuilder) { fbb.add(element: justI32, def: 0, at: VTOFFSET.justI32.p) }
public static func add(maybeI32: Int32?, _ fbb: inout FlatBufferBuilder) { fbb.add(element: maybeI32, at: VTOFFSET.maybeI32.p) }
public static func add(defaultI32: Int32, _ fbb: inout FlatBufferBuilder) { fbb.add(element: defaultI32, def: 42, at: VTOFFSET.defaultI32.p) }
public static func add(justU32: UInt32, _ fbb: inout FlatBufferBuilder) { fbb.add(element: justU32, def: 0, at: VTOFFSET.justU32.p) }
public static func add(maybeU32: UInt32?, _ fbb: inout FlatBufferBuilder) { fbb.add(element: maybeU32, at: VTOFFSET.maybeU32.p) }
public static func add(defaultU32: UInt32, _ fbb: inout FlatBufferBuilder) { fbb.add(element: defaultU32, def: 42, at: VTOFFSET.defaultU32.p) }
public static func add(justI64: Int64, _ fbb: inout FlatBufferBuilder) { fbb.add(element: justI64, def: 0, at: VTOFFSET.justI64.p) }
public static func add(maybeI64: Int64?, _ fbb: inout FlatBufferBuilder) { fbb.add(element: maybeI64, at: VTOFFSET.maybeI64.p) }
public static func add(defaultI64: Int64, _ fbb: inout FlatBufferBuilder) { fbb.add(element: defaultI64, def: 42, at: VTOFFSET.defaultI64.p) }
public static func add(justU64: UInt64, _ fbb: inout FlatBufferBuilder) { fbb.add(element: justU64, def: 0, at: VTOFFSET.justU64.p) }
public static func add(maybeU64: UInt64?, _ fbb: inout FlatBufferBuilder) { fbb.add(element: maybeU64, at: VTOFFSET.maybeU64.p) }
public static func add(defaultU64: UInt64, _ fbb: inout FlatBufferBuilder) { fbb.add(element: defaultU64, def: 42, at: VTOFFSET.defaultU64.p) }
public static func add(justF32: Float32, _ fbb: inout FlatBufferBuilder) { fbb.add(element: justF32, def: 0.0, at: VTOFFSET.justF32.p) }
public static func add(maybeF32: Float32?, _ fbb: inout FlatBufferBuilder) { fbb.add(element: maybeF32, at: VTOFFSET.maybeF32.p) }
public static func add(defaultF32: Float32, _ fbb: inout FlatBufferBuilder) { fbb.add(element: defaultF32, def: 42.0, at: VTOFFSET.defaultF32.p) }
public static func add(justF64: Double, _ fbb: inout FlatBufferBuilder) { fbb.add(element: justF64, def: 0.0, at: VTOFFSET.justF64.p) }
public static func add(maybeF64: Double?, _ fbb: inout FlatBufferBuilder) { fbb.add(element: maybeF64, at: VTOFFSET.maybeF64.p) }
public static func add(defaultF64: Double, _ fbb: inout FlatBufferBuilder) { fbb.add(element: defaultF64, def: 42.0, at: VTOFFSET.defaultF64.p) }
public static func add(justBool: Bool, _ fbb: inout FlatBufferBuilder) { fbb.add(element: justBool, def: false,
at: VT.justBool) }
public static func add(maybeBool: Bool?, _ fbb: inout FlatBufferBuilder) { fbb.add(element: maybeBool, at: VT.maybeBool) }
at: VTOFFSET.justBool.p) }
public static func add(maybeBool: Bool?, _ fbb: inout FlatBufferBuilder) { fbb.add(element: maybeBool, at: VTOFFSET.maybeBool.p) }
public static func add(defaultBool: Bool, _ fbb: inout FlatBufferBuilder) { fbb.add(element: defaultBool, def: true,
at: VT.defaultBool) }
public static func add(justEnum: optional_scalars_OptionalByte, _ fbb: inout FlatBufferBuilder) { fbb.add(element: justEnum.rawValue, def: 0, at: VT.justEnum) }
public static func add(maybeEnum: optional_scalars_OptionalByte?, _ fbb: inout FlatBufferBuilder) { fbb.add(element: maybeEnum?.rawValue, at: VT.maybeEnum) }
public static func add(defaultEnum: optional_scalars_OptionalByte, _ fbb: inout FlatBufferBuilder) { fbb.add(element: defaultEnum.rawValue, def: 1, at: VT.defaultEnum) }
at: VTOFFSET.defaultBool.p) }
public static func add(justEnum: optional_scalars_OptionalByte, _ fbb: inout FlatBufferBuilder) { fbb.add(element: justEnum.rawValue, def: 0, at: VTOFFSET.justEnum.p) }
public static func add(maybeEnum: optional_scalars_OptionalByte?, _ fbb: inout FlatBufferBuilder) { fbb.add(element: maybeEnum?.rawValue, at: VTOFFSET.maybeEnum.p) }
public static func add(defaultEnum: optional_scalars_OptionalByte, _ fbb: inout FlatBufferBuilder) { fbb.add(element: defaultEnum.rawValue, def: 1, at: VTOFFSET.defaultEnum.p) }
public static func endScalarStuff(_ fbb: inout FlatBufferBuilder, start: UOffset) -> Offset { let end = Offset(offset: fbb.endTable(at: start)); return end }
public static func createScalarStuff(
_ fbb: inout FlatBufferBuilder,
@@ -238,47 +240,48 @@ public struct optional_scalars_ScalarStuff: FlatBufferVerifiableTable, Flatbuffe
public static func verify<T>(_ verifier: inout Verifier, at position: Int, of type: T.Type) throws where T: Verifiable {
var _v = try verifier.visitTable(at: position)
try _v.visit(field: VT.justI8, fieldName: "justI8", required: false, type: Int8.self)
try _v.visit(field: VT.maybeI8, fieldName: "maybeI8", required: false, type: Int8.self)
try _v.visit(field: VT.defaultI8, fieldName: "defaultI8", required: false, type: Int8.self)
try _v.visit(field: VT.justU8, fieldName: "justU8", required: false, type: UInt8.self)
try _v.visit(field: VT.maybeU8, fieldName: "maybeU8", required: false, type: UInt8.self)
try _v.visit(field: VT.defaultU8, fieldName: "defaultU8", required: false, type: UInt8.self)
try _v.visit(field: VT.justI16, fieldName: "justI16", required: false, type: Int16.self)
try _v.visit(field: VT.maybeI16, fieldName: "maybeI16", required: false, type: Int16.self)
try _v.visit(field: VT.defaultI16, fieldName: "defaultI16", required: false, type: Int16.self)
try _v.visit(field: VT.justU16, fieldName: "justU16", required: false, type: UInt16.self)
try _v.visit(field: VT.maybeU16, fieldName: "maybeU16", required: false, type: UInt16.self)
try _v.visit(field: VT.defaultU16, fieldName: "defaultU16", required: false, type: UInt16.self)
try _v.visit(field: VT.justI32, fieldName: "justI32", required: false, type: Int32.self)
try _v.visit(field: VT.maybeI32, fieldName: "maybeI32", required: false, type: Int32.self)
try _v.visit(field: VT.defaultI32, fieldName: "defaultI32", required: false, type: Int32.self)
try _v.visit(field: VT.justU32, fieldName: "justU32", required: false, type: UInt32.self)
try _v.visit(field: VT.maybeU32, fieldName: "maybeU32", required: false, type: UInt32.self)
try _v.visit(field: VT.defaultU32, fieldName: "defaultU32", required: false, type: UInt32.self)
try _v.visit(field: VT.justI64, fieldName: "justI64", required: false, type: Int64.self)
try _v.visit(field: VT.maybeI64, fieldName: "maybeI64", required: false, type: Int64.self)
try _v.visit(field: VT.defaultI64, fieldName: "defaultI64", required: false, type: Int64.self)
try _v.visit(field: VT.justU64, fieldName: "justU64", required: false, type: UInt64.self)
try _v.visit(field: VT.maybeU64, fieldName: "maybeU64", required: false, type: UInt64.self)
try _v.visit(field: VT.defaultU64, fieldName: "defaultU64", required: false, type: UInt64.self)
try _v.visit(field: VT.justF32, fieldName: "justF32", required: false, type: Float32.self)
try _v.visit(field: VT.maybeF32, fieldName: "maybeF32", required: false, type: Float32.self)
try _v.visit(field: VT.defaultF32, fieldName: "defaultF32", required: false, type: Float32.self)
try _v.visit(field: VT.justF64, fieldName: "justF64", required: false, type: Double.self)
try _v.visit(field: VT.maybeF64, fieldName: "maybeF64", required: false, type: Double.self)
try _v.visit(field: VT.defaultF64, fieldName: "defaultF64", required: false, type: Double.self)
try _v.visit(field: VT.justBool, fieldName: "justBool", required: false, type: Bool.self)
try _v.visit(field: VT.maybeBool, fieldName: "maybeBool", required: false, type: Bool.self)
try _v.visit(field: VT.defaultBool, fieldName: "defaultBool", required: false, type: Bool.self)
try _v.visit(field: VT.justEnum, fieldName: "justEnum", required: false, type: optional_scalars_OptionalByte.self)
try _v.visit(field: VT.maybeEnum, fieldName: "maybeEnum", required: false, type: optional_scalars_OptionalByte.self)
try _v.visit(field: VT.defaultEnum, fieldName: "defaultEnum", required: false, type: optional_scalars_OptionalByte.self)
try _v.visit(field: VTOFFSET.justI8.p, fieldName: "justI8", required: false, type: Int8.self)
try _v.visit(field: VTOFFSET.maybeI8.p, fieldName: "maybeI8", required: false, type: Int8.self)
try _v.visit(field: VTOFFSET.defaultI8.p, fieldName: "defaultI8", required: false, type: Int8.self)
try _v.visit(field: VTOFFSET.justU8.p, fieldName: "justU8", required: false, type: UInt8.self)
try _v.visit(field: VTOFFSET.maybeU8.p, fieldName: "maybeU8", required: false, type: UInt8.self)
try _v.visit(field: VTOFFSET.defaultU8.p, fieldName: "defaultU8", required: false, type: UInt8.self)
try _v.visit(field: VTOFFSET.justI16.p, fieldName: "justI16", required: false, type: Int16.self)
try _v.visit(field: VTOFFSET.maybeI16.p, fieldName: "maybeI16", required: false, type: Int16.self)
try _v.visit(field: VTOFFSET.defaultI16.p, fieldName: "defaultI16", required: false, type: Int16.self)
try _v.visit(field: VTOFFSET.justU16.p, fieldName: "justU16", required: false, type: UInt16.self)
try _v.visit(field: VTOFFSET.maybeU16.p, fieldName: "maybeU16", required: false, type: UInt16.self)
try _v.visit(field: VTOFFSET.defaultU16.p, fieldName: "defaultU16", required: false, type: UInt16.self)
try _v.visit(field: VTOFFSET.justI32.p, fieldName: "justI32", required: false, type: Int32.self)
try _v.visit(field: VTOFFSET.maybeI32.p, fieldName: "maybeI32", required: false, type: Int32.self)
try _v.visit(field: VTOFFSET.defaultI32.p, fieldName: "defaultI32", required: false, type: Int32.self)
try _v.visit(field: VTOFFSET.justU32.p, fieldName: "justU32", required: false, type: UInt32.self)
try _v.visit(field: VTOFFSET.maybeU32.p, fieldName: "maybeU32", required: false, type: UInt32.self)
try _v.visit(field: VTOFFSET.defaultU32.p, fieldName: "defaultU32", required: false, type: UInt32.self)
try _v.visit(field: VTOFFSET.justI64.p, fieldName: "justI64", required: false, type: Int64.self)
try _v.visit(field: VTOFFSET.maybeI64.p, fieldName: "maybeI64", required: false, type: Int64.self)
try _v.visit(field: VTOFFSET.defaultI64.p, fieldName: "defaultI64", required: false, type: Int64.self)
try _v.visit(field: VTOFFSET.justU64.p, fieldName: "justU64", required: false, type: UInt64.self)
try _v.visit(field: VTOFFSET.maybeU64.p, fieldName: "maybeU64", required: false, type: UInt64.self)
try _v.visit(field: VTOFFSET.defaultU64.p, fieldName: "defaultU64", required: false, type: UInt64.self)
try _v.visit(field: VTOFFSET.justF32.p, fieldName: "justF32", required: false, type: Float32.self)
try _v.visit(field: VTOFFSET.maybeF32.p, fieldName: "maybeF32", required: false, type: Float32.self)
try _v.visit(field: VTOFFSET.defaultF32.p, fieldName: "defaultF32", required: false, type: Float32.self)
try _v.visit(field: VTOFFSET.justF64.p, fieldName: "justF64", required: false, type: Double.self)
try _v.visit(field: VTOFFSET.maybeF64.p, fieldName: "maybeF64", required: false, type: Double.self)
try _v.visit(field: VTOFFSET.defaultF64.p, fieldName: "defaultF64", required: false, type: Double.self)
try _v.visit(field: VTOFFSET.justBool.p, fieldName: "justBool", required: false, type: Bool.self)
try _v.visit(field: VTOFFSET.maybeBool.p, fieldName: "maybeBool", required: false, type: Bool.self)
try _v.visit(field: VTOFFSET.defaultBool.p, fieldName: "defaultBool", required: false, type: Bool.self)
try _v.visit(field: VTOFFSET.justEnum.p, fieldName: "justEnum", required: false, type: optional_scalars_OptionalByte.self)
try _v.visit(field: VTOFFSET.maybeEnum.p, fieldName: "maybeEnum", required: false, type: optional_scalars_OptionalByte.self)
try _v.visit(field: VTOFFSET.defaultEnum.p, fieldName: "defaultEnum", required: false, type: optional_scalars_OptionalByte.self)
_v.finish()
}
}
extension optional_scalars_ScalarStuff: Encodable {
enum CodingKeys: String, CodingKey {
case justI8 = "just_i8"
case maybeI8 = "maybe_i8"
@@ -317,7 +320,6 @@ extension optional_scalars_ScalarStuff: Encodable {
case maybeEnum = "maybe_enum"
case defaultEnum = "default_enum"
}
public func encode(to encoder: Encoder) throws {
var container = encoder.container(keyedBy: CodingKeys.self)
if justI8 != 0 {
tests/swift/Tests/Flatbuffers/union_vector_generated.swift
+43 -37
View File
@@ -152,10 +152,10 @@ public struct Rapunzel: NativeStruct, FlatbuffersVectorInitializable, Verifiable
}
extension Rapunzel: Encodable {
enum CodingKeys: String, CodingKey {
case hairLength = "hair_length"
}
public func encode(to encoder: Encoder) throws {
var container = encoder.container(keyedBy: CodingKeys.self)
if hairLength != 0 {
@@ -218,10 +218,10 @@ public struct BookReader: NativeStruct, FlatbuffersVectorInitializable, Verifiab
}
extension BookReader: Encodable {
enum CodingKeys: String, CodingKey {
case booksRead = "books_read"
}
public func encode(to encoder: Encoder) throws {
var container = encoder.container(keyedBy: CodingKeys.self)
if booksRead != 0 {
@@ -284,10 +284,10 @@ public struct FallingTub: NativeStruct, FlatbuffersVectorInitializable, Verifiab
}
extension FallingTub: Encodable {
enum CodingKeys: String, CodingKey {
case weight = "weight"
}
public func encode(to encoder: Encoder) throws {
var container = encoder.container(keyedBy: CodingKeys.self)
if weight != 0 {
@@ -320,7 +320,7 @@ public struct FallingTub_Mutable: FlatBufferStruct, FlatbuffersVectorInitializab
}
}
public struct Attacker: FlatBufferVerifiableTable, FlatbuffersVectorInitializable, ObjectAPIPacker {
public struct Attacker: FlatBufferTable, FlatbuffersVectorInitializable, Verifiable, ObjectAPIPacker {
static func validateVersion() { FlatBuffersVersion_25_12_19() }
public var __buffer: ByteBuffer! { return _accessor.bb }
@@ -331,14 +331,16 @@ public struct Attacker: FlatBufferVerifiableTable, FlatbuffersVectorInitializabl
private init(_ t: Table) { _accessor = t }
public init(_ bb: ByteBuffer, o: Int32) { _accessor = Table(bb: bb, position: o) }
private struct VT {
static let swordAttackDamage: VOffset = 4
private enum VTOFFSET: VOffset {
case swordAttackDamage = 4
var v: Int32 { Int32(self.rawValue) }
var p: VOffset { self.rawValue }
}
public var swordAttackDamage: Int32 { let o = _accessor.offset(VT.swordAttackDamage); return o == 0 ? 0 : _accessor.readBuffer(of: Int32.self, at: o) }
@discardableResult public func mutate(swordAttackDamage: Int32) -> Bool {let o = _accessor.offset(VT.swordAttackDamage); return _accessor.mutate(swordAttackDamage, index: o) }
public var swordAttackDamage: Int32 { let o = _accessor.offset(VTOFFSET.swordAttackDamage.v); return o == 0 ? 0 : _accessor.readBuffer(of: Int32.self, at: o) }
@discardableResult public func mutate(swordAttackDamage: Int32) -> Bool {let o = _accessor.offset(VTOFFSET.swordAttackDamage.v); return _accessor.mutate(swordAttackDamage, index: o) }
public static func startAttacker(_ fbb: inout FlatBufferBuilder) -> UOffset { fbb.startTable(with: 1) }
public static func add(swordAttackDamage: Int32, _ fbb: inout FlatBufferBuilder) { fbb.add(element: swordAttackDamage, def: 0, at: VT.swordAttackDamage) }
public static func add(swordAttackDamage: Int32, _ fbb: inout FlatBufferBuilder) { fbb.add(element: swordAttackDamage, def: 0, at: VTOFFSET.swordAttackDamage.p) }
public static func endAttacker(_ fbb: inout FlatBufferBuilder, start: UOffset) -> Offset { let end = Offset(offset: fbb.endTable(at: start)); return end }
public static func createAttacker(
_ fbb: inout FlatBufferBuilder,
@@ -365,16 +367,16 @@ public struct Attacker: FlatBufferVerifiableTable, FlatbuffersVectorInitializabl
public static func verify<T>(_ verifier: inout Verifier, at position: Int, of type: T.Type) throws where T: Verifiable {
var _v = try verifier.visitTable(at: position)
try _v.visit(field: VT.swordAttackDamage, fieldName: "swordAttackDamage", required: false, type: Int32.self)
try _v.visit(field: VTOFFSET.swordAttackDamage.p, fieldName: "swordAttackDamage", required: false, type: Int32.self)
_v.finish()
}
}
extension Attacker: Encodable {
enum CodingKeys: String, CodingKey {
case swordAttackDamage = "sword_attack_damage"
}
public func encode(to encoder: Encoder) throws {
var container = encoder.container(keyedBy: CodingKeys.self)
if swordAttackDamage != 0 {
@@ -398,7 +400,7 @@ public class AttackerT: NativeObject {
public func serialize() -> ByteBuffer { return serialize(type: Attacker.self) }
}
public struct HandFan: FlatBufferVerifiableTable, FlatbuffersVectorInitializable, ObjectAPIPacker {
public struct HandFan: FlatBufferTable, FlatbuffersVectorInitializable, Verifiable, ObjectAPIPacker {
static func validateVersion() { FlatBuffersVersion_25_12_19() }
public var __buffer: ByteBuffer! { return _accessor.bb }
@@ -409,14 +411,16 @@ public struct HandFan: FlatBufferVerifiableTable, FlatbuffersVectorInitializable
private init(_ t: Table) { _accessor = t }
public init(_ bb: ByteBuffer, o: Int32) { _accessor = Table(bb: bb, position: o) }
private struct VT {
static let length: VOffset = 4
private enum VTOFFSET: VOffset {
case length = 4
var v: Int32 { Int32(self.rawValue) }
var p: VOffset { self.rawValue }
}
public var length: Int32 { let o = _accessor.offset(VT.length); return o == 0 ? 0 : _accessor.readBuffer(of: Int32.self, at: o) }
@discardableResult public func mutate(length: Int32) -> Bool {let o = _accessor.offset(VT.length); return _accessor.mutate(length, index: o) }
public var length: Int32 { let o = _accessor.offset(VTOFFSET.length.v); return o == 0 ? 0 : _accessor.readBuffer(of: Int32.self, at: o) }
@discardableResult public func mutate(length: Int32) -> Bool {let o = _accessor.offset(VTOFFSET.length.v); return _accessor.mutate(length, index: o) }
public static func startHandFan(_ fbb: inout FlatBufferBuilder) -> UOffset { fbb.startTable(with: 1) }
public static func add(length: Int32, _ fbb: inout FlatBufferBuilder) { fbb.add(element: length, def: 0, at: VT.length) }
public static func add(length: Int32, _ fbb: inout FlatBufferBuilder) { fbb.add(element: length, def: 0, at: VTOFFSET.length.p) }
public static func endHandFan(_ fbb: inout FlatBufferBuilder, start: UOffset) -> Offset { let end = Offset(offset: fbb.endTable(at: start)); return end }
public static func createHandFan(
_ fbb: inout FlatBufferBuilder,
@@ -443,16 +447,16 @@ public struct HandFan: FlatBufferVerifiableTable, FlatbuffersVectorInitializable
public static func verify<T>(_ verifier: inout Verifier, at position: Int, of type: T.Type) throws where T: Verifiable {
var _v = try verifier.visitTable(at: position)
try _v.visit(field: VT.length, fieldName: "length", required: false, type: Int32.self)
try _v.visit(field: VTOFFSET.length.p, fieldName: "length", required: false, type: Int32.self)
_v.finish()
}
}
extension HandFan: Encodable {
enum CodingKeys: String, CodingKey {
case length = "length"
}
public func encode(to encoder: Encoder) throws {
var container = encoder.container(keyedBy: CodingKeys.self)
if length != 0 {
@@ -476,7 +480,7 @@ public class HandFanT: NativeObject {
public func serialize() -> ByteBuffer { return serialize(type: HandFan.self) }
}
public struct Movie: FlatBufferVerifiableTable, FlatbuffersVectorInitializable, ObjectAPIPacker {
public struct Movie: FlatBufferTable, FlatbuffersVectorInitializable, Verifiable, ObjectAPIPacker {
static func validateVersion() { FlatBuffersVersion_25_12_19() }
public var __buffer: ByteBuffer! { return _accessor.bb }
@@ -487,23 +491,25 @@ public struct Movie: FlatBufferVerifiableTable, FlatbuffersVectorInitializable,
private init(_ t: Table) { _accessor = t }
public init(_ bb: ByteBuffer, o: Int32) { _accessor = Table(bb: bb, position: o) }
private struct VT {
static let mainCharacterType: VOffset = 4
static let mainCharacter: VOffset = 6
static let charactersType: VOffset = 8
static let characters: VOffset = 10
private enum VTOFFSET: VOffset {
case mainCharacterType = 4
case mainCharacter = 6
case charactersType = 8
case characters = 10
var v: Int32 { Int32(self.rawValue) }
var p: VOffset { self.rawValue }
}
public var mainCharacterType: Character { let o = _accessor.offset(VT.mainCharacterType); return o == 0 ? .none_ : Character(rawValue: _accessor.readBuffer(of: UInt8.self, at: o)) ?? .none_ }
public func mainCharacter<T: FlatbuffersInitializable>(type: T.Type) -> T? { let o = _accessor.offset(VT.mainCharacter); return o == 0 ? nil : _accessor.union(o) }
public var charactersType: FlatbufferVector<Character> { return _accessor.vector(at: VT.charactersType, byteSize: 1) }
public var characters: UnionFlatbufferVector { return _accessor.unionVector(at: VT.characters, byteSize: 4) }
public func characters<T: FlatbuffersInitializable>(at index: Int32, type: T.Type) -> T? { let o = _accessor.offset(VT.characters); return o == 0 ? nil : _accessor.directUnion(_accessor.vector(at: o) + index * 4) }
public var mainCharacterType: Character { let o = _accessor.offset(VTOFFSET.mainCharacterType.v); return o == 0 ? .none_ : Character(rawValue: _accessor.readBuffer(of: UInt8.self, at: o)) ?? .none_ }
public func mainCharacter<T: FlatbuffersInitializable>(type: T.Type) -> T? { let o = _accessor.offset(VTOFFSET.mainCharacter.v); return o == 0 ? nil : _accessor.union(o) }
public var charactersType: FlatbufferVector<Character> { return _accessor.vector(at: VTOFFSET.charactersType.v, byteSize: 1) }
public var characters: UnionFlatbufferVector { return _accessor.unionVector(at: VTOFFSET.characters.v, byteSize: 4) }
public func characters<T: FlatbuffersInitializable>(at index: Int32, type: T.Type) -> T? { let o = _accessor.offset(VTOFFSET.characters.v); return o == 0 ? nil : _accessor.directUnion(_accessor.vector(at: o) + index * 4) }
public static func startMovie(_ fbb: inout FlatBufferBuilder) -> UOffset { fbb.startTable(with: 4) }
public static func add(mainCharacterType: Character, _ fbb: inout FlatBufferBuilder) { fbb.add(element: mainCharacterType.rawValue, def: 0, at: VT.mainCharacterType) }
public static func add(mainCharacter: Offset, _ fbb: inout FlatBufferBuilder) { fbb.add(offset: mainCharacter, at: VT.mainCharacter) }
public static func addVectorOf(charactersType: Offset, _ fbb: inout FlatBufferBuilder) { fbb.add(offset: charactersType, at: VT.charactersType) }
public static func addVectorOf(characters: Offset, _ fbb: inout FlatBufferBuilder) { fbb.add(offset: characters, at: VT.characters) }
public static func add(mainCharacterType: Character, _ fbb: inout FlatBufferBuilder) { fbb.add(element: mainCharacterType.rawValue, def: 0, at: VTOFFSET.mainCharacterType.p) }
public static func add(mainCharacter: Offset, _ fbb: inout FlatBufferBuilder) { fbb.add(offset: mainCharacter, at: VTOFFSET.mainCharacter.p) }
public static func addVectorOf(charactersType: Offset, _ fbb: inout FlatBufferBuilder) { fbb.add(offset: charactersType, at: VTOFFSET.charactersType.p) }
public static func addVectorOf(characters: Offset, _ fbb: inout FlatBufferBuilder) { fbb.add(offset: characters, at: VTOFFSET.characters.p) }
public static func endMovie(_ fbb: inout FlatBufferBuilder, start: UOffset) -> Offset { let end = Offset(offset: fbb.endTable(at: start)); return end }
public static func createMovie(
_ fbb: inout FlatBufferBuilder,
@@ -550,7 +556,7 @@ public struct Movie: FlatBufferVerifiableTable, FlatbuffersVectorInitializable,
public static func verify<T>(_ verifier: inout Verifier, at position: Int, of type: T.Type) throws where T: Verifiable {
var _v = try verifier.visitTable(at: position)
try _v.visit(unionKey: VT.mainCharacterType, unionField: VT.mainCharacter, unionKeyName: "mainCharacterType", fieldName: "mainCharacter", required: false, completion: { (verifier, key: Character, pos) in
try _v.visit(unionKey: VTOFFSET.mainCharacterType.p, unionField: VTOFFSET.mainCharacter.p, unionKeyName: "mainCharacterType", fieldName: "mainCharacter", required: false, completion: { (verifier, key: Character, pos) in
switch key {
case .none_:
break // NOTE - SWIFT doesnt support none
@@ -568,7 +574,7 @@ public struct Movie: FlatBufferVerifiableTable, FlatbuffersVectorInitializable,
try ForwardOffset<String>.verify(&verifier, at: pos, of: String.self)
}
})
try _v.visitUnionVector(unionKey: VT.charactersType, unionField: VT.characters, unionKeyName: "charactersType", fieldName: "characters", required: false, completion: { (verifier, key: Character, pos) in
try _v.visitUnionVector(unionKey: VTOFFSET.charactersType.p, unionField: VTOFFSET.characters.p, unionKeyName: "charactersType", fieldName: "characters", required: false, completion: { (verifier, key: Character, pos) in
switch key {
case .none_:
break // NOTE - SWIFT doesnt support none
@@ -591,13 +597,13 @@ public struct Movie: FlatBufferVerifiableTable, FlatbuffersVectorInitializable,
}
extension Movie: Encodable {
enum CodingKeys: String, CodingKey {
case mainCharacterType = "main_character_type"
case mainCharacter = "main_character"
case charactersType = "characters_type"
case characters = "characters"
}
public func encode(to encoder: Encoder) throws {
var container = encoder.container(keyedBy: CodingKeys.self)
if mainCharacterType != .none_ {
tests/swift/Tests/Flatbuffers/vector_has_test_generated.swift
+20 -18
View File
@@ -8,7 +8,7 @@ import Common
import FlatBuffers
public struct Swift_Tests_Vectors: FlatBufferVerifiableTable, FlatbuffersVectorInitializable {
public struct Swift_Tests_Vectors: FlatBufferTable, FlatbuffersVectorInitializable, Verifiable {
static func validateVersion() { FlatBuffersVersion_25_12_19() }
public var __buffer: ByteBuffer! { return _accessor.bb }
@@ -17,22 +17,24 @@ public struct Swift_Tests_Vectors: FlatBufferVerifiableTable, FlatbuffersVectorI
private init(_ t: Table) { _accessor = t }
public init(_ bb: ByteBuffer, o: Int32) { _accessor = Table(bb: bb, position: o) }
private struct VT {
static let none_: VOffset = 4
static let empty: VOffset = 6
static let array: VOffset = 8
private enum VTOFFSET: VOffset {
case none_ = 4
case empty = 6
case array = 8
var v: Int32 { Int32(self.rawValue) }
var p: VOffset { self.rawValue }
}
public var none_: FlatbufferVector<UInt64> { return _accessor.vector(at: VT.none_, byteSize: 8) }
public func withUnsafePointerToNone<T>(_ body: (UnsafeRawBufferPointer, Int) throws -> T) rethrows -> T? { return try _accessor.withUnsafePointerToSlice(at: VT.none_, body: body) }
public var empty: FlatbufferVector<UInt64> { return _accessor.vector(at: VT.empty, byteSize: 8) }
public func withUnsafePointerToEmpty<T>(_ body: (UnsafeRawBufferPointer, Int) throws -> T) rethrows -> T? { return try _accessor.withUnsafePointerToSlice(at: VT.empty, body: body) }
public var array: FlatbufferVector<UInt64> { return _accessor.vector(at: VT.array, byteSize: 8) }
public func withUnsafePointerToArray<T>(_ body: (UnsafeRawBufferPointer, Int) throws -> T) rethrows -> T? { return try _accessor.withUnsafePointerToSlice(at: VT.array, body: body) }
public var none_: FlatbufferVector<UInt64> { return _accessor.vector(at: VTOFFSET.none_.v, byteSize: 8) }
public func withUnsafePointerToNone<T>(_ body: (UnsafeRawBufferPointer, Int) throws -> T) rethrows -> T? { return try _accessor.withUnsafePointerToSlice(at: VTOFFSET.none_.v, body: body) }
public var empty: FlatbufferVector<UInt64> { return _accessor.vector(at: VTOFFSET.empty.v, byteSize: 8) }
public func withUnsafePointerToEmpty<T>(_ body: (UnsafeRawBufferPointer, Int) throws -> T) rethrows -> T? { return try _accessor.withUnsafePointerToSlice(at: VTOFFSET.empty.v, body: body) }
public var array: FlatbufferVector<UInt64> { return _accessor.vector(at: VTOFFSET.array.v, byteSize: 8) }
public func withUnsafePointerToArray<T>(_ body: (UnsafeRawBufferPointer, Int) throws -> T) rethrows -> T? { return try _accessor.withUnsafePointerToSlice(at: VTOFFSET.array.v, body: body) }
public static func startVectors(_ fbb: inout FlatBufferBuilder) -> UOffset { fbb.startTable(with: 3) }
public static func addVectorOf(none_: Offset, _ fbb: inout FlatBufferBuilder) { fbb.add(offset: none_, at: VT.none_) }
public static func addVectorOf(empty: Offset, _ fbb: inout FlatBufferBuilder) { fbb.add(offset: empty, at: VT.empty) }
public static func addVectorOf(array: Offset, _ fbb: inout FlatBufferBuilder) { fbb.add(offset: array, at: VT.array) }
public static func addVectorOf(none_: Offset, _ fbb: inout FlatBufferBuilder) { fbb.add(offset: none_, at: VTOFFSET.none_.p) }
public static func addVectorOf(empty: Offset, _ fbb: inout FlatBufferBuilder) { fbb.add(offset: empty, at: VTOFFSET.empty.p) }
public static func addVectorOf(array: Offset, _ fbb: inout FlatBufferBuilder) { fbb.add(offset: array, at: VTOFFSET.array.p) }
public static func endVectors(_ fbb: inout FlatBufferBuilder, start: UOffset) -> Offset { let end = Offset(offset: fbb.endTable(at: start)); return end }
public static func createVectors(
_ fbb: inout FlatBufferBuilder,
@@ -49,20 +51,20 @@ public struct Swift_Tests_Vectors: FlatBufferVerifiableTable, FlatbuffersVectorI
public static func verify<T>(_ verifier: inout Verifier, at position: Int, of type: T.Type) throws where T: Verifiable {
var _v = try verifier.visitTable(at: position)
try _v.visit(field: VT.none_, fieldName: "none_", required: false, type: ForwardOffset<Vector<UInt64, UInt64>>.self)
try _v.visit(field: VT.empty, fieldName: "empty", required: false, type: ForwardOffset<Vector<UInt64, UInt64>>.self)
try _v.visit(field: VT.array, fieldName: "array", required: false, type: ForwardOffset<Vector<UInt64, UInt64>>.self)
try _v.visit(field: VTOFFSET.none_.p, fieldName: "none_", required: false, type: ForwardOffset<Vector<UInt64, UInt64>>.self)
try _v.visit(field: VTOFFSET.empty.p, fieldName: "empty", required: false, type: ForwardOffset<Vector<UInt64, UInt64>>.self)
try _v.visit(field: VTOFFSET.array.p, fieldName: "array", required: false, type: ForwardOffset<Vector<UInt64, UInt64>>.self)
_v.finish()
}
}
extension Swift_Tests_Vectors: Encodable {
enum CodingKeys: String, CodingKey {
case none_ = "none"
case empty = "empty"
case array = "array"
}
public func encode(to encoder: Encoder) throws {
var container = encoder.container(keyedBy: CodingKeys.self)
try container.encodeIfPresent(none_, forKey: .none_)
tests/swift/Tests/Flexbuffers/FlexBuffersJSONTests.swift
+12 -14
View File
@@ -16,19 +16,17 @@
import Common
import FlexBuffers
import Foundation
import Testing
import XCTest
struct FlexBuffersJSONTests {
@Test
final class FlexBuffersJSONTests: XCTestCase {
func testEncodingJSON() throws {
let buf: ByteBuffer = createProperBuffer().sizedByteBuffer
let reference = try getRoot(buffer: buf)!
let json = reference.jsonString()
// swiftformat:disable all
#expect(
json ==
XCTAssertEqual(
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
@@ -39,15 +37,15 @@ struct FlexBuffersJSONTests {
with: data,
options: []) as! [String: Any]
#expect(decodedData["bar"] as! [Int] == [1, 2, 3])
#expect(decodedData["bar3"] as! [Int] == [1, 2, 3])
XCTAssertEqual(decodedData["bar"] as! [Int], [1, 2, 3])
XCTAssertEqual(decodedData["bar3"] as! [Int], [1, 2, 3])
let vec: [Any] = decodedData["vec"] as! [Any]
#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)
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)
}
}
tests/swift/Tests/Flexbuffers/FlexBuffersReaderTests.swift
+43 -46
View File
@@ -15,26 +15,22 @@
*/
import Common
import Foundation
import Testing
import XCTest
@testable import FlexBuffers
struct FlexBuffersReaderTests {
final class FlexBuffersReaderTests: XCTestCase {
@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,
@@ -42,87 +38,87 @@ struct FlexBuffersReaderTests {
write(fbx: &fbx)
try validate(buffer: ByteBuffer(data: fbx.data))
#expect(fbx.capacity == 512)
XCTAssertEqual(fbx.capacity, 512)
fbx.reset()
#expect(fbx.writerIndex == 0)
#expect(fbx.capacity == 8)
XCTAssertEqual(fbx.writerIndex, 0)
XCTAssertEqual(fbx.capacity, 8)
write(fbx: &fbx)
try validate(buffer: ByteBuffer(data: fbx.data))
fbx.reset(keepingCapacity: true)
#expect(fbx.writerIndex == 0)
#expect(fbx.capacity == 512)
XCTAssertEqual(fbx.writerIndex, 0)
XCTAssertEqual(fbx.capacity, 512)
write(fbx: &fbx)
try validate(buffer: ByteBuffer(data: fbx.data))
#expect(fbx.capacity == 512)
XCTAssertEqual(fbx.capacity, 512)
}
private func validate(buffer buf: ByteBuffer) throws {
let reference = try getRoot(buffer: buf)!
#expect(reference.type == .map)
XCTAssertEqual(reference.type, .map)
let map = reference.map!
#expect(map.count == 7)
XCTAssertEqual(map.count, 7)
let vecRef = map["vec"]!
#expect(vecRef.type == .vector)
XCTAssertEqual(vecRef.type, .vector)
let vec = vecRef.vector!
#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)
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)
let blob = vec[3]!.blob { pointer in
Array(pointer)
}
#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]
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]
let barVec = map["bar"]!.typedVector!
#expect(barVec.count == 3)
#expect(barVec[2]?.int == 3)
#expect(barVec[2]?.asInt() == UInt8(3))
XCTAssertEqual(barVec.count, 3)
XCTAssertEqual(barVec[2]?.int, 3)
XCTAssertEqual(barVec[2]?.asInt(), UInt8(3))
let fixedVec = map["bar3"]!.fixedTypedVector!
#expect(fixedVec.count == 3)
#expect(fixedVec[2]?.int == 3)
#expect(fixedVec[2]?.asInt() == UInt8(3))
#expect(map["bool"]?.bool == true)
XCTAssertEqual(fixedVec.count, 3)
XCTAssertEqual(fixedVec[2]?.int, 3)
XCTAssertEqual(fixedVec[2]?.asInt(), UInt8(3))
XCTAssertEqual(map["bool"]?.bool, true)
let boolsVector = map["bools"]!.typedVector!
#expect(boolsVector.type == .bool)
#expect(boolsVector[0]?.bool == true)
#expect(boolsVector[1]?.bool == false)
XCTAssertEqual(boolsVector.type, .bool)
XCTAssertEqual(boolsVector[0]?.bool, true)
XCTAssertEqual(boolsVector[1]?.bool, false)
let bools = [true, false, true, false]
boolsVector.withUnsafeRawBufferPointer { buff in
for i in 0..<boolsVector.count {
#expect(buff.load(fromByteOffset: i, as: Bool.self) == bools[i])
XCTAssertEqual(buff.load(fromByteOffset: i, as: Bool.self), bools[i])
}
}
#expect(map["foo"]?.double == 100)
#expect(map["unknown"] == nil)
XCTAssertEqual(map["foo"]?.double, 100)
XCTAssertNil(map["unknown"])
let mymap = map["mymap"]?.map
// Check if both addresses used are the same for keys and strings
#expect(mymap?.keys[0]?.cString == map.keys[4]?.cString)
XCTAssertEqual(mymap?.keys[0]?.cString, map.keys[4]?.cString)
map.keys[4]?.withUnsafeRawPointer { pointer in
mymap?.keys[0]?.withUnsafeRawPointer { mymapPointer in
#expect(pointer == mymapPointer)
XCTAssertEqual(pointer, mymapPointer)
}
}
#expect(mymap?.values[0]?.cString == vec[1]?.cString)
XCTAssertEqual(mymap?.values[0]?.cString, vec[1]?.cString)
vec[1]?.withUnsafeRawPointer { pointer in
mymap?.values[0]?.withUnsafeRawPointer { mymapPointer in
#expect(pointer == mymapPointer)
XCTAssertEqual(pointer, mymapPointer)
}
}
}
@@ -131,7 +127,7 @@ struct FlexBuffersReaderTests {
#if os(macOS)
// Gets the current path of this test file then
// strips out the nested directories.
let filePath = URL(filePath: #filePath)
let filePath = URL(filePath: #file)
.deletingLastPathComponent()
.deletingLastPathComponent()
.deletingLastPathComponent()
@@ -140,4 +136,5 @@ struct FlexBuffersReaderTests {
return FileManager.default.currentDirectoryPath
#endif
}
}
tests/swift/Tests/Flexbuffers/FlexBuffersStringTests.swift
+3 -5
View File
@@ -16,12 +16,10 @@
import Common
import FlexBuffers
import Foundation
import Testing
import XCTest
struct FlexBuffersStringTests {
final class FlexBuffersStringTests: XCTestCase {
@Test
func testEncodingUnicodeString() {
let text = "プ画をみて✋"
@@ -40,6 +38,6 @@ struct FlexBuffersStringTests {
return String(data: data, encoding: .unicode)
}
#expect(builtString == text)
XCTAssertEqual(builtString, text)
}
}
tests/swift/Tests/Flexbuffers/FlexBuffersWriterTests.swift
+23 -33
View File
@@ -16,10 +16,9 @@
import Common
import FlexBuffers
import Testing
import XCTest
struct FlexBuffersWriterTests {
@Test
final class FlexBuffersWriterTests: XCTestCase {
func testDeallocation() {
let buf: ByteBuffer = {
var fbx = FlexBuffersWriter()
@@ -29,13 +28,12 @@ struct FlexBuffersWriterTests {
}()
buf.withUnsafeBytes {
#expect(
Array($0) ==
[5, 72, 101, 108, 108, 111, 0, 6, 20, 1])
XCTAssertEqual(
Array($0),
[5, 72, 101, 108, 108, 111, 0, 6, 20, 1])
}
}
@Test
func testAddingVectorOfScalars() {
var fbx = FlexBuffersWriter()
fbx.vector {
@@ -47,8 +45,8 @@ struct FlexBuffersWriterTests {
buf.withUnsafeBytes {
// swiftformat:disable all
#expect(
Array($0) ==
XCTAssertEqual(
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,
@@ -57,7 +55,6 @@ struct FlexBuffersWriterTests {
}
}
@Test
func testAddingVectorOfUnsignedScalars() {
var fbx = FlexBuffersWriter()
fbx.vector {
@@ -69,8 +66,8 @@ struct FlexBuffersWriterTests {
buf.withUnsafeBytes {
// swiftformat:disable all
#expect(
Array($0) ==
XCTAssertEqual(
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,
@@ -81,7 +78,6 @@ struct FlexBuffersWriterTests {
}
}
@Test
func testAddingVectorOfBools() {
var fbx = FlexBuffersWriter()
fbx.vector {
@@ -93,14 +89,13 @@ struct FlexBuffersWriterTests {
buf.withUnsafeBytes {
// swiftformat:disable all
#expect(
Array($0) ==
XCTAssertEqual(
Array($0),
[4, 1, 0, 1, 0, 1, 5, 144, 2, 40, 1])
// swiftformat:enable all
}
}
@Test
func testSortingWithinMap() {
var fbx = FlexBuffersWriter()
fbx.map {
@@ -111,8 +106,8 @@ struct FlexBuffersWriterTests {
let buf: ByteBuffer = fbx.sizedByteBuffer
buf.withUnsafeBytes {
// swiftformat:disable all
#expect(
Array($0) ==
XCTAssertEqual(
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,
@@ -122,7 +117,6 @@ struct FlexBuffersWriterTests {
}
}
@Test
func testSharingKeyWithinMap() {
var fbx = FlexBuffersWriter(initialSize: 1000, flags: .shareKeysAndStrings)
fbx.map {
@@ -134,8 +128,8 @@ struct FlexBuffersWriterTests {
let buf: ByteBuffer = fbx.sizedByteBuffer
buf.withUnsafeBytes {
// swiftformat:disable all
#expect(
Array($0) ==
XCTAssertEqual(
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,
@@ -145,21 +139,19 @@ struct FlexBuffersWriterTests {
}
}
@Test
func testNestingVectorInMap() {
let buf: ByteBuffer = createSizedBuffer()
buf.withUnsafeBytes {
// swiftformat:disable all
#expect(
Array($0) ==
XCTAssertEqual(
Array($0),
flexbufferGolden
)
// swiftformat:enable all
}
}
@Test
func testAddingNil() {
var fbx = FlexBuffersWriter(
initialSize: 8,
@@ -173,15 +165,14 @@ struct FlexBuffersWriterTests {
let buf: ByteBuffer = fbx.sizedByteBuffer
buf.withUnsafeBytes {
// swiftformat:disable all
#expect(
Array($0) ==
XCTAssertEqual(
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,
@@ -218,15 +209,14 @@ struct FlexBuffersWriterTests {
let buf: ByteBuffer = fbx.sizedByteBuffer
buf.withUnsafeBytes {
// swiftformat:disable all
#expect(
Array($0) ==
XCTAssertEqual(
Array($0),
flexbufferGolden
)
// swiftformat:enable all
}
}
@Test
func testEncodingAllTypes() {
var fbx = FlexBuffersWriter()
fbx.vector {
@@ -250,8 +240,8 @@ struct FlexBuffersWriterTests {
buf.withUnsafeBytes {
// swiftformat:disable all
#expect(
Array($0) ==
XCTAssertEqual(
Array($0),
allTypesGolden)
// swiftformat:enable all
}
tests/swift/Wasm.tests/Package.swift
+2 -2
View File
@@ -24,7 +24,7 @@ let package = Package(
],
dependencies: [
.package(path: "../../.."),
.package(url: "https://github.com/swiftwasm/WasmKit", exact: "0.1.6"),
.package(url: "https://github.com/swiftwasm/WasmKit", exact: "0.1.6")
],
targets: [
.target(name: "Wasm"),
@@ -37,5 +37,5 @@ let package = Package(
name: "FlexBuffers.Test.Swift.WasmTests",
dependencies: [
.product(name: "FlexBuffers", package: "flatbuffers"),
]),
])
])
tests/swift/Wasm.tests/Tests/FlatBuffers.Test.Swift.WasmTests/FlatBuffersMonsterWriterTests.swift
+125 -136
View File
@@ -15,7 +15,7 @@
*/
import Foundation
import Testing
import XCTest
@testable import FlatBuffers
@@ -24,9 +24,8 @@ typealias Monster = MyGame_Example_Monster
typealias Vec3 = MyGame_Example_Vec3
typealias Stat = MyGame_Example_Stat
struct FlatBuffersMonsterWriterTests {
class FlatBuffersMonsterWriterTests: XCTestCase {
@Test
func testData() {
// swiftformat:disable all
let data: [UInt8] = [
@@ -48,12 +47,11 @@ struct FlatBuffersMonsterWriterTests {
readVerifiedMonster(fb: _data)
}
@Test
func testCreateMonster() {
let bytes = createMonster(withPrefix: false)
// swiftformat:disable all
#expect(
bytes.sizedByteArray ==
XCTAssertEqual(
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,
@@ -77,12 +75,11 @@ struct FlatBuffersMonsterWriterTests {
readMonster(monster: monster)
}
@Test
func testCreateMonsterResizedBuffer() {
let bytes = createMonster(withPrefix: false)
// swiftformat:disable all
#expect(
bytes.sizedByteArray ==
XCTAssertEqual(
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,
@@ -101,12 +98,11 @@ struct FlatBuffersMonsterWriterTests {
readVerifiedMonster(fb: bytes.sizedBuffer)
}
@Test
func testCreateMonsterPrefixed() {
let bytes = createMonster(withPrefix: true)
// swiftformat:disable all
#expect(
bytes.sizedByteArray ==
XCTAssertEqual(
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,
@@ -127,7 +123,6 @@ struct FlatBuffersMonsterWriterTests {
readMonster(monster: getPrefixedSizeRoot(byteBuffer: &buffer))
}
@Test
func testCreateMonsterUsingCreateMonsterMethodWithNilPos() {
var fbb = FlatBufferBuilder(initialSize: 1)
let name = fbb.create(string: "Frodo")
@@ -137,11 +132,10 @@ struct FlatBuffersMonsterWriterTests {
fbb.finish(offset: root)
var buffer = fbb.sizedBuffer
let newMonster: Monster = getRoot(byteBuffer: &buffer)
#expect(newMonster.pos == nil)
#expect(newMonster.name == "Frodo")
XCTAssertNil(newMonster.pos)
XCTAssertEqual(newMonster.name, "Frodo")
}
@Test
func testCreateMonsterUsingCreateMonsterMethodWithPosX() {
var fbb = FlatBufferBuilder(initialSize: 1)
let name = fbb.create(string: "Barney")
@@ -161,11 +155,10 @@ struct FlatBuffersMonsterWriterTests {
var buffer = fbb.sizedBuffer
let newMonster: Monster = getRoot(byteBuffer: &buffer)
#expect(newMonster.pos!.x == 10)
#expect(newMonster.name == "Barney")
XCTAssertEqual(newMonster.pos!.x, 10)
XCTAssertEqual(newMonster.name, "Barney")
}
@Test
func testReadMonsterFromUnsafePointerWithoutCopying() {
// swiftformat:disable all
var array: [UInt8] = [
@@ -197,7 +190,6 @@ struct FlatBuffersMonsterWriterTests {
readObjectApi(monster: unpacked)
}
@Test
func testArrayOfBools() {
let boolArray = [false, true, false, true, false, true, false]
var fbb = FlatBufferBuilder(initialSize: 1)
@@ -213,41 +205,37 @@ struct FlatBuffersMonsterWriterTests {
let monster: Monster = getRoot(byteBuffer: &buffer)
let values = monster.testarrayofbools
#expect(boolArray.count == values.count)
XCTAssertEqual(boolArray.count, values.count)
for (index, bool) in monster.testarrayofbools.enumerated() {
#expect(bool == boolArray[index])
XCTAssertEqual(bool, boolArray[index])
}
}
func readVerifiedMonster(fb: ByteBuffer) {
var byteBuffer = fb
do {
XCTAssertNoThrow(
try readMonster(
monster: getCheckedRoot(
byteBuffer: &byteBuffer) as MyGame_Example_Monster)
} catch {
Issue.record(error)
}
byteBuffer: &byteBuffer) as MyGame_Example_Monster))
}
@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)
readFlatbufferMonster(monster: &monster)
self.readFlatbufferMonster(monster: &monster)
return true
}
#expect(testAligned() == true)
XCTAssertEqual(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 {
Issue.record("Base pointer is not defined")
XCTFail("Base pointer is not defined")
return false
}
baseAddress = baseAddress.advanced(by: 1)
@@ -256,14 +244,13 @@ struct FlatBuffersMonsterWriterTests {
assumingMemoryBound: unlignedPtr,
capacity: ptr.count - 1)
var monster: Monster = getRoot(byteBuffer: &bytes)
readFlatbufferMonster(monster: &monster)
self.readFlatbufferMonster(monster: &monster)
return true
}
}
#expect(testUnaligned() == true)
XCTAssertEqual(testUnaligned(), true)
}
@Test
func testReadingRemovedSizeUnalignedBuffer() {
// Aligned read
let fbb = createMonster(withPrefix: true)
@@ -272,7 +259,7 @@ struct FlatBuffersMonsterWriterTests {
bytes.append(contentsOf: fbb.sizedByteArray)
return bytes.withUnsafeMutableBytes { ptr in
guard var baseAddress = ptr.baseAddress else {
Issue.record("Base pointer is not defined")
XCTFail("Base pointer is not defined")
return false
}
baseAddress = baseAddress.advanced(by: 1)
@@ -282,14 +269,13 @@ struct FlatBuffersMonsterWriterTests {
capacity: ptr.count - 1)
var newBuf = FlatBuffersUtils.removeSizePrefix(bb: bytes)
var monster: Monster = getRoot(byteBuffer: &newBuf)
readFlatbufferMonster(monster: &monster)
self.readFlatbufferMonster(monster: &monster)
return true
}
}
#expect(testUnaligned() == true)
XCTAssertEqual(testUnaligned(), true)
}
@Test
func testForceRetainedObject() {
let byteBuffer = {
// swiftformat:disable all
@@ -395,95 +381,95 @@ struct FlatBuffersMonsterWriterTests {
var fb = fb
let monster: Monster = getRoot(byteBuffer: &fb)
#expect(monster.mutate(mana: 10) == false)
#expect(monster.testarrayoftables[0].name == "Barney")
#expect(monster.testarrayoftables[1].name == "Frodo")
#expect(monster.testarrayoftables[2].name == "Wilma")
XCTAssertFalse(monster.mutate(mana: 10))
XCTAssertEqual(monster.testarrayoftables[0].name, "Barney")
XCTAssertEqual(monster.testarrayoftables[1].name, "Frodo")
XCTAssertEqual(monster.testarrayoftables[2].name, "Wilma")
// Example of searching for a table by the key
#expect(monster.testarrayoftablesBy(key: "Frodo") != nil)
#expect(monster.testarrayoftablesBy(key: "Barney") != nil)
#expect(monster.testarrayoftablesBy(key: "Wilma") != nil)
XCTAssertNotNil(monster.testarrayoftablesBy(key: "Frodo"))
XCTAssertNotNil(monster.testarrayoftablesBy(key: "Barney"))
XCTAssertNotNil(monster.testarrayoftablesBy(key: "Wilma"))
#expect(monster.testType == .monster)
XCTAssertEqual(monster.testType, .monster)
#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)
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)
for i in 0..<monster.inventory.count {
#expect(monster.inventory[i] == Byte(i + 1))
XCTAssertEqual(monster.inventory[i], Byte(i + 1))
}
#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)
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)
let vec = monster.mutablePos
#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)
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)
let mutableTest4 = monster.mutableTest4
let orignalValues = mutableTest4[0].a
#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)
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)
}
func readFlatbufferMonster(monster: inout MyGame_Example_Monster) {
#expect(monster.hp == 80)
#expect(monster.mana == 150)
#expect(monster.name == "MyMonster")
XCTAssertEqual(monster.hp, 80)
XCTAssertEqual(monster.mana, 150)
XCTAssertEqual(monster.name, "MyMonster")
let pos = monster.pos
#expect(pos?.x == 1)
#expect(pos?.y == 2)
#expect(pos?.z == 3)
#expect(pos?.test1 == 3)
#expect(pos?.test2 == .green)
XCTAssertEqual(pos?.x, 1)
XCTAssertEqual(pos?.y, 2)
XCTAssertEqual(pos?.z, 3)
XCTAssertEqual(pos?.test1, 3)
XCTAssertEqual(pos?.test2, .green)
let test = pos?.test3
#expect(test?.a == 5)
#expect(test?.b == 6)
#expect(monster.testType == .monster)
XCTAssertEqual(test?.a, 5)
XCTAssertEqual(test?.b, 6)
XCTAssertEqual(monster.testType, .monster)
let monster2 = monster.test(type: Monster.self)
#expect(monster2?.name == "Fred")
XCTAssertEqual(monster2?.name, "Fred")
#expect(monster.mutate(mana: 10) == false)
XCTAssertEqual(monster.mutate(mana: 10), false)
#expect(monster.mana == 150)
#expect(monster.inventory.count == 5)
XCTAssertEqual(monster.mana, 150)
XCTAssertEqual(monster.inventory.count, 5)
var sum: Byte = 0
for inventory in monster.inventory {
sum += inventory
}
#expect(sum == 10)
XCTAssertEqual(sum, 10)
monster.withUnsafePointerToInventory { ptr, count in
var sum: UInt8 = 0
for pointee in ptr.startIndex..<ptr.endIndex {
sum += ptr[pointee]
}
#expect(sum == 10)
XCTAssertEqual(sum, 10)
}
#expect(monster.test4.count == 2)
XCTAssertEqual(monster.test4.count, 2)
let test4 = monster.test4
var sum0 = 0
for test0 in test4 {
sum0 += Int(test0.a) + Int(test0.b)
}
#expect(sum0 == 100)
XCTAssertEqual(sum0, 100)
monster.withUnsafePointerToTest4 { ptr, count in
guard let ptr = ptr.baseAddress else { return }
@@ -499,7 +485,7 @@ struct FlatBuffersMonsterWriterTests {
pointerSum += Int(bindedMemory[pointee].a) +
Int(bindedMemory[pointee].b)
}
#expect(pointerSum == 100)
XCTAssertEqual(pointerSum, 100)
}
let mutableTest4 = monster.mutableTest4
@@ -507,84 +493,87 @@ struct FlatBuffersMonsterWriterTests {
for test0 in mutableTest4 {
sum2 += Int(test0.a) + Int(test0.b)
}
#expect(sum2 == 100)
XCTAssertEqual(sum2, 100)
let stringArray = monster.testarrayofstring
#expect(stringArray.count == 2)
#expect(stringArray[0] == "test1")
#expect(stringArray[1] == "test2")
#expect(monster.testbool == true)
XCTAssertEqual(stringArray.count, 2)
XCTAssertEqual(stringArray[0], "test1")
XCTAssertEqual(stringArray[1], "test2")
XCTAssertEqual(monster.testbool, true)
let array = monster.nameSegmentArray
#expect(String(bytes: array ?? [], encoding: .utf8) == "MyMonster")
XCTAssertEqual(String(bytes: array ?? [], encoding: .utf8), "MyMonster")
if 0 == monster.testarrayofbools.count {
#expect(monster.testarrayofbools.isEmpty == true)
XCTAssertEqual(monster.testarrayofbools.isEmpty, true)
} else {
#expect(monster.testarrayofbools.isEmpty == false)
XCTAssertEqual(monster.testarrayofbools.isEmpty, false)
}
}
func readObjectApi(monster: MyGame_Example_MonsterT) {
#expect(monster.hp == 80)
#expect(monster.mana == 150)
#expect(monster.name == "MyMonster")
XCTAssertEqual(monster.hp, 80)
XCTAssertEqual(monster.mana, 150)
XCTAssertEqual(monster.name, "MyMonster")
let pos = monster.pos
#expect(pos?.x == 1)
#expect(pos?.y == 2)
#expect(pos?.z == 3)
#expect(pos?.test1 == 3)
#expect(pos?.test2 == .green)
XCTAssertEqual(pos?.x, 1)
XCTAssertEqual(pos?.y, 2)
XCTAssertEqual(pos?.z, 3)
XCTAssertEqual(pos?.test1, 3)
XCTAssertEqual(pos?.test2, .green)
let test = pos?.test3
#expect(test?.a == 5)
#expect(test?.b == 6)
XCTAssertEqual(test?.a, 5)
XCTAssertEqual(test?.b, 6)
let monster2 = monster.test?.value as? MyGame_Example_MonsterT
#expect(monster2?.name == "Fred")
#expect(monster.mana == 150)
XCTAssertEqual(monster2?.name, "Fred")
XCTAssertEqual(monster.mana, 150)
monster.mana = 10
#expect(monster.mana == 10)
XCTAssertEqual(monster.mana, 10)
monster.mana = 150
#expect(monster.mana == 150)
XCTAssertEqual(monster.mana, 150)
#expect(monster.inventory.count == 5)
XCTAssertEqual(monster.inventory.count, 5)
var sum: Byte = 0
for i in monster.inventory {
sum += i
}
#expect(sum == 10)
#expect(monster.test4.count == 2)
XCTAssertEqual(sum, 10)
XCTAssertEqual(monster.test4.count, 2)
var sum0 = 0
for test in monster.test4 {
sum0 += Int(test.a) + Int(test.b)
}
#expect(sum0 == 100)
#expect(monster.testbool == true)
XCTAssertEqual(sum0, 100)
XCTAssertEqual(monster.testbool, true)
}
@Test
func testEncoding() throws {
func testEncoding() {
let fbb = createMonster(withPrefix: false)
var sizedBuffer = fbb.sizedBuffer
struct Test: Decodable {
struct Pos: Decodable {
let x, y, z: Int
do {
struct Test: Decodable {
struct Pos: Decodable {
let x, y, z: Int
}
let hp: Int
let inventory: [UInt8]
let name: String
let pos: Pos
}
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)
XCTAssertEqual(value.name, "MyMonster")
XCTAssertEqual(value.pos.x, 1)
XCTAssertEqual(value.pos.y, 2)
XCTAssertEqual(value.pos.z, 3)
} catch {
XCTFail(error.localizedDescription)
}
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 {
tests/swift/Wasm.tests/Tests/FlatBuffers.Test.Swift.WasmTests/monster_test_generated.swift
+424 -412
View File
File diff suppressed because it is too large Load Diff
tests/swift/Wasm.tests/Tests/FlexBuffers.Test.Swift.WasmTests/FlexBuffersJSONTests.swift
+12 -14
View File
@@ -16,19 +16,17 @@
import Common
import FlexBuffers
import Foundation
import Testing
import XCTest
struct FlexBuffersJSONTests {
@Test
final class FlexBuffersJSONTests: XCTestCase {
func testEncodingJSON() throws {
let buf: ByteBuffer = createProperBuffer().sizedByteBuffer
let reference = try getRoot(buffer: buf)!
let json = reference.jsonString()
// swiftformat:disable all
#expect(
json ==
XCTAssertEqual(
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
@@ -39,15 +37,15 @@ struct FlexBuffersJSONTests {
with: data,
options: []) as! [String: Any]
#expect(decodedData["bar"] as! [Int] == [1, 2, 3])
#expect(decodedData["bar3"] as! [Int] == [1, 2, 3])
XCTAssertEqual(decodedData["bar"] as! [Int], [1, 2, 3])
XCTAssertEqual(decodedData["bar3"] as! [Int], [1, 2, 3])
let vec: [Any] = decodedData["vec"] as! [Any]
#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)
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)
}
}
tests/swift/Wasm.tests/Tests/FlexBuffers.Test.Swift.WasmTests/FlexBuffersReaderTests.swift
+42 -46
View File
@@ -15,26 +15,22 @@
*/
import Common
import Foundation
import Testing
import XCTest
@testable import FlexBuffers
struct FlexBuffersReaderTests {
final class FlexBuffersReaderTests: XCTestCase {
@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,
@@ -42,87 +38,87 @@ struct FlexBuffersReaderTests {
write(fbx: &fbx)
try validate(buffer: ByteBuffer(bytes: fbx.sizedByteArray))
#expect(fbx.capacity == 512)
XCTAssertEqual(fbx.capacity, 512)
fbx.reset()
#expect(fbx.writerIndex == 0)
#expect(fbx.capacity == 8)
XCTAssertEqual(fbx.writerIndex, 0)
XCTAssertEqual(fbx.capacity, 8)
write(fbx: &fbx)
try validate(buffer: ByteBuffer(bytes: fbx.sizedByteArray))
fbx.reset(keepingCapacity: true)
#expect(fbx.writerIndex == 0)
#expect(fbx.capacity == 512)
XCTAssertEqual(fbx.writerIndex, 0)
XCTAssertEqual(fbx.capacity, 512)
write(fbx: &fbx)
try validate(buffer: ByteBuffer(bytes: fbx.sizedByteArray))
#expect(fbx.capacity == 512)
XCTAssertEqual(fbx.capacity, 512)
}
private func validate(buffer buf: ByteBuffer) throws {
let reference = try getRoot(buffer: buf)!
#expect(reference.type == .map)
XCTAssertEqual(reference.type, .map)
let map = reference.map!
#expect(map.count == 7)
XCTAssertEqual(map.count, 7)
let vecRef = map["vec"]!
#expect(vecRef.type == .vector)
XCTAssertEqual(vecRef.type, .vector)
let vec = vecRef.vector!
#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)
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)
let blob = vec[3]!.blob { pointer in
Array(pointer)
}
#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]
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]
let barVec = map["bar"]!.typedVector!
#expect(barVec.count == 3)
#expect(barVec[2]?.int == 3)
#expect(barVec[2]?.asInt() == UInt8(3))
XCTAssertEqual(barVec.count, 3)
XCTAssertEqual(barVec[2]?.int, 3)
XCTAssertEqual(barVec[2]?.asInt(), UInt8(3))
let fixedVec = map["bar3"]!.fixedTypedVector!
#expect(fixedVec.count == 3)
#expect(fixedVec[2]?.int == 3)
#expect(fixedVec[2]?.asInt() == UInt8(3))
#expect(map["bool"]?.bool == true)
XCTAssertEqual(fixedVec.count, 3)
XCTAssertEqual(fixedVec[2]?.int, 3)
XCTAssertEqual(fixedVec[2]?.asInt(), UInt8(3))
XCTAssertEqual(map["bool"]?.bool, true)
let boolsVector = map["bools"]!.typedVector!
#expect(boolsVector.type == .bool)
#expect(boolsVector[0]?.bool == true)
#expect(boolsVector[1]?.bool == false)
XCTAssertEqual(boolsVector.type, .bool)
XCTAssertEqual(boolsVector[0]?.bool, true)
XCTAssertEqual(boolsVector[1]?.bool, false)
let bools = [true, false, true, false]
boolsVector.withUnsafeRawBufferPointer { buff in
for i in 0..<boolsVector.count {
#expect(buff.load(fromByteOffset: i, as: Bool.self) == bools[i])
XCTAssertEqual(buff.load(fromByteOffset: i, as: Bool.self), bools[i])
}
}
#expect(map["foo"]?.double == 100)
#expect(map["unknown"] == nil)
XCTAssertEqual(map["foo"]?.double, 100)
XCTAssertNil(map["unknown"])
let mymap = map["mymap"]?.map
// Check if both addresses used are the same for keys and strings
#expect(mymap?.keys[0]?.cString == map.keys[4]?.cString)
XCTAssertEqual(mymap?.keys[0]?.cString, map.keys[4]?.cString)
map.keys[4]?.withUnsafeRawPointer { pointer in
mymap?.keys[0]?.withUnsafeRawPointer { mymapPointer in
#expect(pointer == mymapPointer)
XCTAssertEqual(pointer, mymapPointer)
}
}
#expect(mymap?.values[0]?.cString == vec[1]?.cString)
XCTAssertEqual(mymap?.values[0]?.cString, vec[1]?.cString)
vec[1]?.withUnsafeRawPointer { pointer in
mymap?.values[0]?.withUnsafeRawPointer { mymapPointer in
#expect(pointer == mymapPointer)
XCTAssertEqual(pointer, mymapPointer)
}
}
}
@@ -131,7 +127,7 @@ struct FlexBuffersReaderTests {
#if os(macOS)
// Gets the current path of this test file then
// strips out the nested directories.
let filePath = URL(filePath: #filePath)
let filePath = URL(filePath: #file)
.deletingLastPathComponent()
.deletingLastPathComponent()
.deletingLastPathComponent()
tests/swift/Wasm.tests/Tests/FlexBuffers.Test.Swift.WasmTests/FlexBuffersStringTests.swift
+3 -5
View File
@@ -16,12 +16,10 @@
import Common
import FlexBuffers
import Foundation
import Testing
import XCTest
struct FlexBuffersStringTests {
final class FlexBuffersStringTests: XCTestCase {
@Test
func testEncodingUnicodeString() {
let text = "プ画をみて✋"
@@ -40,6 +38,6 @@ struct FlexBuffersStringTests {
return String(data: data, encoding: .unicode)
}
#expect(builtString == text)
XCTAssertEqual(builtString, text)
}
}
tests/swift/Wasm.tests/Tests/FlexBuffers.Test.Swift.WasmTests/FlexBuffersWriterTests.swift
+23 -33
View File
@@ -16,10 +16,9 @@
import Common
import FlexBuffers
import Testing
import XCTest
struct FlexBuffersWriterTests {
@Test
final class FlexBuffersWriterTests: XCTestCase {
func testDeallocation() {
let buf: ByteBuffer = {
var fbx = FlexBuffersWriter()
@@ -29,13 +28,12 @@ struct FlexBuffersWriterTests {
}()
buf.withUnsafeBytes {
#expect(
Array($0) ==
[5, 72, 101, 108, 108, 111, 0, 6, 20, 1])
XCTAssertEqual(
Array($0),
[5, 72, 101, 108, 108, 111, 0, 6, 20, 1])
}
}
@Test
func testAddingVectorOfScalars() {
var fbx = FlexBuffersWriter()
fbx.vector {
@@ -47,8 +45,8 @@ struct FlexBuffersWriterTests {
buf.withUnsafeBytes {
// swiftformat:disable all
#expect(
Array($0) ==
XCTAssertEqual(
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,
@@ -57,7 +55,6 @@ struct FlexBuffersWriterTests {
}
}
@Test
func testAddingVectorOfUnsignedScalars() {
var fbx = FlexBuffersWriter()
fbx.vector {
@@ -69,8 +66,8 @@ struct FlexBuffersWriterTests {
buf.withUnsafeBytes {
// swiftformat:disable all
#expect(
Array($0) ==
XCTAssertEqual(
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,
@@ -81,7 +78,6 @@ struct FlexBuffersWriterTests {
}
}
@Test
func testAddingVectorOfBools() {
var fbx = FlexBuffersWriter()
fbx.vector {
@@ -93,14 +89,13 @@ struct FlexBuffersWriterTests {
buf.withUnsafeBytes {
// swiftformat:disable all
#expect(
Array($0) ==
XCTAssertEqual(
Array($0),
[4, 1, 0, 1, 0, 1, 5, 144, 2, 40, 1])
// swiftformat:enable all
}
}
@Test
func testSortingWithinMap() {
var fbx = FlexBuffersWriter()
fbx.map {
@@ -111,8 +106,8 @@ struct FlexBuffersWriterTests {
let buf: ByteBuffer = fbx.sizedByteBuffer
buf.withUnsafeBytes {
// swiftformat:disable all
#expect(
Array($0) ==
XCTAssertEqual(
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,
@@ -122,7 +117,6 @@ struct FlexBuffersWriterTests {
}
}
@Test
func testSharingKeyWithinMap() {
var fbx = FlexBuffersWriter(initialSize: 1000, flags: .shareKeysAndStrings)
fbx.map {
@@ -134,8 +128,8 @@ struct FlexBuffersWriterTests {
let buf: ByteBuffer = fbx.sizedByteBuffer
buf.withUnsafeBytes {
// swiftformat:disable all
#expect(
Array($0) ==
XCTAssertEqual(
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,
@@ -145,21 +139,19 @@ struct FlexBuffersWriterTests {
}
}
@Test
func testNestingVectorInMap() {
let buf: ByteBuffer = createSizedBuffer()
buf.withUnsafeBytes {
// swiftformat:disable all
#expect(
Array($0) ==
XCTAssertEqual(
Array($0),
flexbufferGolden
)
// swiftformat:enable all
}
}
@Test
func testAddingNil() {
var fbx = FlexBuffersWriter(
initialSize: 8,
@@ -173,15 +165,14 @@ struct FlexBuffersWriterTests {
let buf: ByteBuffer = fbx.sizedByteBuffer
buf.withUnsafeBytes {
// swiftformat:disable all
#expect(
Array($0) ==
XCTAssertEqual(
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,
@@ -218,15 +209,14 @@ struct FlexBuffersWriterTests {
let buf: ByteBuffer = fbx.sizedByteBuffer
buf.withUnsafeBytes {
// swiftformat:disable all
#expect(
Array($0) ==
XCTAssertEqual(
Array($0),
flexbufferGolden
)
// swiftformat:enable all
}
}
@Test
func testEncodingAllTypes() {
var fbx = FlexBuffersWriter()
fbx.vector {
@@ -250,8 +240,8 @@ struct FlexBuffersWriterTests {
buf.withUnsafeBytes {
// swiftformat:disable all
#expect(
Array($0) ==
XCTAssertEqual(
Array($0),
allTypesGolden)
// swiftformat:enable all
}
tests/swift/fuzzer/CodeGenerationTests/test_import_generated.swift
+12 -10
View File
@@ -3,12 +3,12 @@
// swiftformat:disable all
#if canImport(Common)
internal import Common
@_implementationOnly import Common
#endif
internal import FlatBuffers
@_implementationOnly import FlatBuffers
internal struct Message: FlatBufferVerifiableTable, FlatbuffersVectorInitializable, ObjectAPIPacker {
internal struct Message: FlatBufferTable, FlatbuffersVectorInitializable, Verifiable, ObjectAPIPacker {
static func validateVersion() { FlatBuffersVersion_25_12_19() }
internal var __buffer: ByteBuffer! { return _accessor.bb }
@@ -17,14 +17,16 @@ internal struct Message: FlatBufferVerifiableTable, FlatbuffersVectorInitializab
private init(_ t: Table) { _accessor = t }
internal init(_ bb: ByteBuffer, o: Int32) { _accessor = Table(bb: bb, position: o) }
private struct VT {
static let internalMessage: VOffset = 4
private enum VTOFFSET: VOffset {
case internalMessage = 4
var v: Int32 { Int32(self.rawValue) }
var p: VOffset { self.rawValue }
}
internal var internalMessage: String? { let o = _accessor.offset(VT.internalMessage); return o == 0 ? nil : _accessor.string(at: o) }
internal var internalMessageSegmentArray: [UInt8]? { return _accessor.getVector(at: VT.internalMessage) }
internal var internalMessage: String? { let o = _accessor.offset(VTOFFSET.internalMessage.v); return o == 0 ? nil : _accessor.string(at: o) }
internal var internalMessageSegmentArray: [UInt8]? { return _accessor.getVector(at: VTOFFSET.internalMessage.v) }
internal static func startMessage(_ fbb: inout FlatBufferBuilder) -> UOffset { fbb.startTable(with: 1) }
internal static func add(internalMessage: Offset, _ fbb: inout FlatBufferBuilder) { fbb.add(offset: internalMessage, at: VT.internalMessage) }
internal static func add(internalMessage: Offset, _ fbb: inout FlatBufferBuilder) { fbb.add(offset: internalMessage, at: VTOFFSET.internalMessage.p) }
internal static func endMessage(_ fbb: inout FlatBufferBuilder, start: UOffset) -> Offset { let end = Offset(offset: fbb.endTable(at: start)); return end }
internal static func createMessage(
_ fbb: inout FlatBufferBuilder,
@@ -58,16 +60,16 @@ internal struct Message: FlatBufferVerifiableTable, FlatbuffersVectorInitializab
internal static func verify<T>(_ verifier: inout Verifier, at position: Int, of type: T.Type) throws where T: Verifiable {
var _v = try verifier.visitTable(at: position)
try _v.visit(field: VT.internalMessage, fieldName: "internalMessage", required: false, type: ForwardOffset<String>.self)
try _v.visit(field: VTOFFSET.internalMessage.p, fieldName: "internalMessage", required: false, type: ForwardOffset<String>.self)
_v.finish()
}
}
extension Message: Encodable {
enum CodingKeys: String, CodingKey {
case internalMessage = "internal_message"
}
internal func encode(to encoder: Encoder) throws {
var container = encoder.container(keyedBy: CodingKeys.self)
try container.encodeIfPresent(internalMessage, forKey: .internalMessage)
tests/swift/fuzzer/CodeGenerationTests/test_no_include_generated.swift
+30 -26
View File
@@ -32,10 +32,10 @@ public struct BytesCount: NativeStruct, FlatbuffersVectorInitializable, Verifiab
}
extension BytesCount: Encodable {
enum CodingKeys: String, CodingKey {
case x = "x"
}
public func encode(to encoder: Encoder) throws {
var container = encoder.container(keyedBy: CodingKeys.self)
if x != 0 {
@@ -68,7 +68,7 @@ public struct BytesCount_Mutable: FlatBufferStruct, FlatbuffersVectorInitializab
}
}
public struct InternalMessage: FlatBufferVerifiableTable, FlatbuffersVectorInitializable, ObjectAPIPacker {
public struct InternalMessage: FlatBufferTable, FlatbuffersVectorInitializable, Verifiable, ObjectAPIPacker {
static func validateVersion() { FlatBuffersVersion_25_12_19() }
public var __buffer: ByteBuffer! { return _accessor.bb }
@@ -77,14 +77,16 @@ public struct InternalMessage: FlatBufferVerifiableTable, FlatbuffersVectorIniti
private init(_ t: Table) { _accessor = t }
public init(_ bb: ByteBuffer, o: Int32) { _accessor = Table(bb: bb, position: o) }
private struct VT {
static let str: VOffset = 4
private enum VTOFFSET: VOffset {
case str = 4
var v: Int32 { Int32(self.rawValue) }
var p: VOffset { self.rawValue }
}
public var str: String? { let o = _accessor.offset(VT.str); return o == 0 ? nil : _accessor.string(at: o) }
public var strSegmentArray: [UInt8]? { return _accessor.getVector(at: VT.str) }
public var str: String? { let o = _accessor.offset(VTOFFSET.str.v); return o == 0 ? nil : _accessor.string(at: o) }
public var strSegmentArray: [UInt8]? { return _accessor.getVector(at: VTOFFSET.str.v) }
public static func startInternalMessage(_ fbb: inout FlatBufferBuilder) -> UOffset { fbb.startTable(with: 1) }
public static func add(str: Offset, _ fbb: inout FlatBufferBuilder) { fbb.add(offset: str, at: VT.str) }
public static func add(str: Offset, _ fbb: inout FlatBufferBuilder) { fbb.add(offset: str, at: VTOFFSET.str.p) }
public static func endInternalMessage(_ fbb: inout FlatBufferBuilder, start: UOffset) -> Offset { let end = Offset(offset: fbb.endTable(at: start)); return end }
public static func createInternalMessage(
_ fbb: inout FlatBufferBuilder,
@@ -118,16 +120,16 @@ public struct InternalMessage: FlatBufferVerifiableTable, FlatbuffersVectorIniti
public static func verify<T>(_ verifier: inout Verifier, at position: Int, of type: T.Type) throws where T: Verifiable {
var _v = try verifier.visitTable(at: position)
try _v.visit(field: VT.str, fieldName: "str", required: false, type: ForwardOffset<String>.self)
try _v.visit(field: VTOFFSET.str.p, fieldName: "str", required: false, type: ForwardOffset<String>.self)
_v.finish()
}
}
extension InternalMessage: Encodable {
enum CodingKeys: String, CodingKey {
case str = "str"
}
public func encode(to encoder: Encoder) throws {
var container = encoder.container(keyedBy: CodingKeys.self)
try container.encodeIfPresent(str, forKey: .str)
@@ -148,7 +150,7 @@ public class InternalMessageT: NativeObject {
public func serialize() -> ByteBuffer { return serialize(type: InternalMessage.self) }
}
public struct Message: FlatBufferVerifiableTable, FlatbuffersVectorInitializable, ObjectAPIPacker {
public struct Message: FlatBufferTable, FlatbuffersVectorInitializable, Verifiable, ObjectAPIPacker {
static func validateVersion() { FlatBuffersVersion_25_12_19() }
public var __buffer: ByteBuffer! { return _accessor.bb }
@@ -157,21 +159,23 @@ public struct Message: FlatBufferVerifiableTable, FlatbuffersVectorInitializable
private init(_ t: Table) { _accessor = t }
public init(_ bb: ByteBuffer, o: Int32) { _accessor = Table(bb: bb, position: o) }
private struct VT {
static let id: VOffset = 4
static let position: VOffset = 6
static let pointer: VOffset = 8
private enum VTOFFSET: VOffset {
case id = 4
case position = 6
case pointer = 8
var v: Int32 { Int32(self.rawValue) }
var p: VOffset { self.rawValue }
}
public var id: Int64 { let o = _accessor.offset(VT.id); return o == 0 ? 0 : _accessor.readBuffer(of: Int64.self, at: o) }
@discardableResult public func mutate(id: Int64) -> Bool {let o = _accessor.offset(VT.id); return _accessor.mutate(id, index: o) }
public var position: BytesCount! { let o = _accessor.offset(VT.position); return _accessor.readBuffer(of: BytesCount.self, at: o) }
public var mutablePosition: BytesCount_Mutable! { let o = _accessor.offset(VT.position); return BytesCount_Mutable(_accessor.bb, o: o + _accessor.position) }
public var pointer: InternalMessage! { let o = _accessor.offset(VT.pointer); return InternalMessage(_accessor.bb, o: _accessor.indirect(o + _accessor.position)) }
public var id: Int64 { let o = _accessor.offset(VTOFFSET.id.v); return o == 0 ? 0 : _accessor.readBuffer(of: Int64.self, at: o) }
@discardableResult public func mutate(id: Int64) -> Bool {let o = _accessor.offset(VTOFFSET.id.v); return _accessor.mutate(id, index: o) }
public var position: BytesCount! { let o = _accessor.offset(VTOFFSET.position.v); return _accessor.readBuffer(of: BytesCount.self, at: o) }
public var mutablePosition: BytesCount_Mutable! { let o = _accessor.offset(VTOFFSET.position.v); return BytesCount_Mutable(_accessor.bb, o: o + _accessor.position) }
public var pointer: InternalMessage! { let o = _accessor.offset(VTOFFSET.pointer.v); return InternalMessage(_accessor.bb, o: _accessor.indirect(o + _accessor.position)) }
public static func startMessage(_ fbb: inout FlatBufferBuilder) -> UOffset { fbb.startTable(with: 3) }
public static func add(id: Int64, _ fbb: inout FlatBufferBuilder) { fbb.add(element: id, def: 0, at: VT.id) }
public static func add(position: BytesCount?, _ fbb: inout FlatBufferBuilder) { guard let position = position else { return }; fbb.create(struct: position, position: VT.position) }
public static func add(pointer: Offset, _ fbb: inout FlatBufferBuilder) { fbb.add(offset: pointer, at: VT.pointer) }
public static func add(id: Int64, _ fbb: inout FlatBufferBuilder) { fbb.add(element: id, def: 0, at: VTOFFSET.id.p) }
public static func add(position: BytesCount?, _ fbb: inout FlatBufferBuilder) { guard let position = position else { return }; fbb.create(struct: position, position: VTOFFSET.position.p) }
public static func add(pointer: Offset, _ fbb: inout FlatBufferBuilder) { fbb.add(offset: pointer, at: VTOFFSET.pointer.p) }
public static func endMessage(_ fbb: inout FlatBufferBuilder, start: UOffset) -> Offset { let end = Offset(offset: fbb.endTable(at: start)); fbb.require(table: end, fields: [6, 8]); return end }
public static func createMessage(
_ fbb: inout FlatBufferBuilder,
@@ -205,20 +209,20 @@ public struct Message: FlatBufferVerifiableTable, FlatbuffersVectorInitializable
public static func verify<T>(_ verifier: inout Verifier, at position: Int, of type: T.Type) throws where T: Verifiable {
var _v = try verifier.visitTable(at: position)
try _v.visit(field: VT.id, fieldName: "id", required: false, type: Int64.self)
try _v.visit(field: VT.position, fieldName: "position", required: true, type: BytesCount.self)
try _v.visit(field: VT.pointer, fieldName: "pointer", required: true, type: ForwardOffset<InternalMessage>.self)
try _v.visit(field: VTOFFSET.id.p, fieldName: "id", required: false, type: Int64.self)
try _v.visit(field: VTOFFSET.position.p, fieldName: "position", required: true, type: BytesCount.self)
try _v.visit(field: VTOFFSET.pointer.p, fieldName: "pointer", required: true, type: ForwardOffset<InternalMessage>.self)
_v.finish()
}
}
extension Message: Encodable {
enum CodingKeys: String, CodingKey {
case id = "id"
case position = "position"
case pointer = "pointer"
}
public func encode(to encoder: Encoder) throws {
var container = encoder.container(keyedBy: CodingKeys.self)
if id != 0 {