This commit is contained in:
2026-08-17 01:21:55 +02:00
parent 5761d6e67a
commit 4bd1e24e75
265 changed files with 20617 additions and 24457 deletions
@@ -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
}
}