forked from BigfootDev/flatbuffers
392165432a
* Migrating from Xctests to swift testing This migrates to the new Swift testing framework, which would allow us to always use the latest tech from swift moving forward. * Updates flag to make sure that Wasm testing works
256 lines
7.7 KiB
Swift
256 lines
7.7 KiB
Swift
/*
|
|
* Copyright 2024 Google Inc. All rights reserved.
|
|
*
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
* you may not use this file except in compliance with the License.
|
|
* You may obtain a copy of the License at
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
* See the License for the specific language governing permissions and
|
|
* limitations under the License.
|
|
*/
|
|
|
|
import Testing
|
|
|
|
@testable import FlatBuffers
|
|
|
|
struct FlatBuffersVectors {
|
|
|
|
@Test
|
|
func testCreatingTwoCountries() {
|
|
let norway = "Norway"
|
|
let denmark = "Denmark"
|
|
var b = FlatBufferBuilder(initialSize: 20)
|
|
let noStr = b.create(string: norway)
|
|
let deStr = b.create(string: denmark)
|
|
let n = Country.createCountry(
|
|
builder: &b,
|
|
offset: noStr,
|
|
log: 888,
|
|
lan: 700)
|
|
let d = Country.createCountry(
|
|
builder: &b,
|
|
offset: deStr,
|
|
log: 200,
|
|
lan: 100)
|
|
let vector = [n, d]
|
|
let vectorOffset = b.createVector(ofOffsets: vector)
|
|
b.finish(offset: vectorOffset)
|
|
// swiftformat:disable all
|
|
#expect(
|
|
b.sizedByteArray ==
|
|
[
|
|
4, 0, 0, 0, 2, 0, 0, 0, 48, 0, 0, 0, 16, 0, 0, 0, 0, 0, 10, 0, 18, 0, 4, 0, 8, 0, 12, 0, 10,
|
|
0, 0, 0, 40, 0, 0, 0, 100, 0, 0, 0, 200, 0, 0, 0, 0, 0, 10, 0, 16, 0, 4, 0, 8, 0, 12, 0, 10,
|
|
0, 0, 0, 24, 0, 0, 0, 188, 2, 0, 0, 120, 3, 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,
|
|
])
|
|
// 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 ==
|
|
[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
|
|
}
|
|
let vector: [Vec] = [
|
|
Vec(x: 1, y: 2, z: 3),
|
|
Vec(x: 4, y: 5, z: 6),
|
|
Vec(x: 7, y: 8, z: 9),
|
|
]
|
|
var b = FlatBufferBuilder(initialSize: 100)
|
|
let o = b.createVector(ofStructs: vector)
|
|
b.finish(offset: o)
|
|
// swiftformat:disable all
|
|
#expect(
|
|
b.sizedByteArray ==
|
|
[
|
|
4, 0, 0, 0, 3, 0, 0, 0, 0, 0, 128, 63, 0, 0, 0, 64, 0, 0, 64, 64, 0, 0, 128, 64, 0, 0, 160,
|
|
64, 0, 0, 192, 64, 0, 0, 224, 64, 0, 0, 0, 65, 0, 0, 16, 65,
|
|
])
|
|
// 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])
|
|
}
|
|
|
|
@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 ==
|
|
[
|
|
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"
|
|
var b = FlatBufferBuilder(initialSize: 20)
|
|
let noStr = b.createShared(string: norway)
|
|
let deStr = b.createShared(string: denmark)
|
|
let _noStr = b.createShared(string: norway)
|
|
let _deStr = b.createShared(string: denmark)
|
|
let v = [noStr, deStr, _noStr, _deStr]
|
|
let end = b.createVector(ofOffsets: v)
|
|
b.finish(offset: end)
|
|
// swiftformat:disable all
|
|
#expect(
|
|
b.sizedByteArray ==
|
|
[
|
|
4, 0, 0, 0, 4, 0, 0, 0, 28, 0, 0, 0, 12, 0, 0, 0, 20, 0, 0, 0, 4, 0, 0, 0, 7, 0, 0, 0, 68,
|
|
101, 110, 109, 97, 114, 107, 0, 6, 0, 0, 0, 78, 111, 114, 119, 97, 121, 0, 0,
|
|
])
|
|
// swiftformat:enable all
|
|
}
|
|
|
|
@Test
|
|
func testReadInt32Array() {
|
|
let data: [Int32] = [1, 2, 3, 4, 5]
|
|
var b = FlatBufferBuilder(initialSize: 20)
|
|
let v = Numbers.createNumbersVector(b: &b, array: data)
|
|
let end = Numbers.createNumbers(b: &b, o: v)
|
|
b.finish(offset: end)
|
|
let number = Numbers.getRootAsNumbers(ByteBuffer(bytes: b.sizedByteArray))
|
|
for (index, num) in number.vArrayInt32.enumerated() {
|
|
#expect(num == data[index])
|
|
}
|
|
}
|
|
|
|
@Test
|
|
func testReadDoubleArray() {
|
|
let data: [Double] = [1, 2, 3, 4, 5]
|
|
var b = FlatBufferBuilder(initialSize: 20)
|
|
let v = Numbers.createNumbersVector(b: &b, array: data)
|
|
let end = Numbers.createNumbers(b: &b, o: v)
|
|
b.finish(offset: end)
|
|
let number = Numbers.getRootAsNumbers(ByteBuffer(bytes: b.sizedByteArray))
|
|
for (index, num) in number.vArrayDouble.enumerated() {
|
|
#expect(num == data[index])
|
|
}
|
|
}
|
|
|
|
@Test
|
|
func testHasForArray() {
|
|
var builder = FlatBufferBuilder(initialSize: 20)
|
|
let emptyVector = [UInt8]()
|
|
let emptyOffset = builder.createVector(emptyVector)
|
|
let nonEmptyVector = [1, 2, 3]
|
|
let nonEmptyVectorOffest = builder.createVector(nonEmptyVector)
|
|
let start = Swift_Tests_Vectors.startVectors(&builder)
|
|
Swift_Tests_Vectors.addVectorOf(empty: emptyOffset, &builder)
|
|
Swift_Tests_Vectors.addVectorOf(array: nonEmptyVectorOffest, &builder)
|
|
let finish = Swift_Tests_Vectors.endVectors(&builder, start: start)
|
|
builder.finish(offset: finish)
|
|
|
|
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)
|
|
|
|
for i in msg.array.startIndex..<msg.array.endIndex {
|
|
#expect(msg.array[i] == 1 + UInt64(i))
|
|
}
|
|
|
|
let array = msg.withUnsafePointerToArray { ptr, count in
|
|
let ptr: UnsafeBufferPointer<UInt64> = UnsafeBufferPointer(
|
|
start: ptr.baseAddress?.bindMemory(
|
|
to: UInt64.self,
|
|
capacity: count),
|
|
count: count)
|
|
return Array(ptr)
|
|
}
|
|
|
|
#expect(array == [1, 2, 3])
|
|
}
|
|
}
|
|
|
|
struct Numbers {
|
|
|
|
private var __t: Table
|
|
|
|
private init(_ t: Table) {
|
|
__t = t
|
|
}
|
|
|
|
@inlinable
|
|
static func getRootAsNumbers(_ bb: ByteBuffer) -> Numbers {
|
|
Numbers(
|
|
Table(
|
|
bb: bb,
|
|
position: Int32(bb.read(def: UOffset.self, position: 0))))
|
|
}
|
|
|
|
var vArrayInt: FlatbufferVector<Int> { __t.vector(at: 4, byteSize: 8) }
|
|
var vArrayInt32: FlatbufferVector<Int32> { __t.vector(at: 4, byteSize: 4) }
|
|
var vArrayDouble: FlatbufferVector<Double> { __t.vector(at: 4, byteSize: 8) }
|
|
var vArrayFloat: FlatbufferVector<Float32> { __t.vector(at: 4, byteSize: 4) }
|
|
|
|
static func createNumbersVector(
|
|
b: inout FlatBufferBuilder,
|
|
array: [Int]) -> Offset
|
|
{
|
|
b.createVector(array, size: array.count)
|
|
}
|
|
|
|
static func createNumbersVector(
|
|
b: inout FlatBufferBuilder,
|
|
array: [Int32]) -> Offset
|
|
{
|
|
b.createVector(array, size: array.count)
|
|
}
|
|
|
|
static func createNumbersVector(
|
|
b: inout FlatBufferBuilder,
|
|
array: [Double]) -> Offset
|
|
{
|
|
b.createVector(array, size: array.count)
|
|
}
|
|
|
|
static func createNumbersVector(
|
|
b: inout FlatBufferBuilder,
|
|
array: [Float32]) -> Offset
|
|
{
|
|
b.createVector(array, size: array.count)
|
|
}
|
|
|
|
static func createNumbers(b: inout FlatBufferBuilder, o: Offset) -> Offset {
|
|
let start = b.startTable(with: 1)
|
|
b.add(offset: o, at: 4)
|
|
return Offset(offset: b.endTable(at: start))
|
|
}
|
|
}
|