Blame - tests/FlatBuffers.Test.Swift/Tests/FlatBuffers.Test.SwiftTests/FlatBuffersMonsterWriterTests.swift - RealtimeRoboticsGroup/test

let data = Data([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, 0, 0, 1, 60, 0, 0, 0, 68, 0, 0, 0, 76, 0, 0, 0, 0, 0, 0, 1, 88, 0, 0, 0, 120, 0, 0, 0, 0, 0, 80, 0, 0, 0, 128, 63, 0, 0, 0, 64, 0, 0, 64, 64, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 8, 64, 2, 0, 5, 0, 6, 0, 0, 0, 2, 0, 0, 0, 64, 0, 0, 0, 48, 0, 0, 0, 2, 0, 0, 0, 30, 0, 40, 0, 10, 0, 20, 0, 152, 255, 255, 255, 4, 0, 0, 0, 4, 0, 0, 0, 70, 114, 101, 100, 0, 0, 0, 0, 5, 0, 0, 0, 0, 1, 2, 3, 4, 0, 0, 0, 5, 0, 0, 0, 116, 101, 115, 116, 50, 0, 0, 0, 5, 0, 0, 0, 116, 101, 115, 116, 49, 0, 0, 0, 9, 0, 0, 0, 77, 121, 77, 111, 110, 115, 116, 101, 114, 0, 0, 0, 3, 0, 0, 0, 20, 0, 0, 0, 36, 0, 0, 0, 4, 0, 0, 0, 240, 255, 255, 255, 32, 0, 0, 0, 248, 255, 255, 255, 36, 0, 0, 0, 12, 0, 8, 0, 0, 0, 0, 0, 0, 0, 4, 0, 12, 0, 0, 0, 28, 0, 0, 0, 5, 0, 0, 0, 87, 105, 108, 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, 111, 0, 0, 0])

14

let _data = ByteBuffer(data: data)

15

readMonster(fb: _data)

16

}

17

18

func testReadFromOtherLanguages() {

19

let path = FileManager.default.currentDirectoryPath

20

let url = URL(fileURLWithPath: path, isDirectory: true).appendingPathComponent("monsterdata_test").appendingPathExtension("mon")

21

guard let data = try? Data(contentsOf: url) else { return }

22

let _data = ByteBuffer(data: data)

23

readMonster(fb: _data)

24

}

25

26

func testCreateMonster() {

27

let bytes = createMonster(withPrefix: false)

28

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, 0, 0, 0, 0, 1, 60, 0, 0, 0, 68, 0, 0, 0, 76, 0, 0, 0, 0, 0, 0, 1, 88, 0, 0, 0, 120, 0, 0, 0, 0, 0, 80, 0, 0, 0, 128, 63, 0, 0, 0, 64, 0, 0, 64, 64, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 8, 64, 2, 0, 5, 0, 6, 0, 0, 0, 2, 0, 0, 0, 64, 0, 0, 0, 48, 0, 0, 0, 2, 0, 0, 0, 30, 0, 40, 0, 10, 0, 20, 0, 152, 255, 255, 255, 4, 0, 0, 0, 4, 0, 0, 0, 70, 114, 101, 100, 0, 0, 0, 0, 5, 0, 0, 0, 0, 1, 2, 3, 4, 0, 0, 0, 5, 0, 0, 0, 116, 101, 115, 116, 50, 0, 0, 0, 5, 0, 0, 0, 116, 101, 115, 116, 49, 0, 0, 0, 9, 0, 0, 0, 77, 121, 77, 111, 110, 115, 116, 101, 114, 0, 0, 0, 3, 0, 0, 0, 20, 0, 0, 0, 36, 0, 0, 0, 4, 0, 0, 0, 240, 255, 255, 255, 32, 0, 0, 0, 248, 255, 255, 255, 36, 0, 0, 0, 12, 0, 8, 0, 0, 0, 0, 0, 0, 0, 4, 0, 12, 0, 0, 0, 28, 0, 0, 0, 5, 0, 0, 0, 87, 105, 108, 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, 111, 0, 0, 0])

29

readMonster(fb: bytes.buffer)

30

mutateMonster(fb: bytes.buffer)

31

readMonster(fb: bytes.buffer)

32

}

33

34

func testCreateMonsterResizedBuffer() {

35

let bytes = createMonster(withPrefix: false)

36

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, 0, 0, 0, 0, 1, 60, 0, 0, 0, 68, 0, 0, 0, 76, 0, 0, 0, 0, 0, 0, 1, 88, 0, 0, 0, 120, 0, 0, 0, 0, 0, 80, 0, 0, 0, 128, 63, 0, 0, 0, 64, 0, 0, 64, 64, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 8, 64, 2, 0, 5, 0, 6, 0, 0, 0, 2, 0, 0, 0, 64, 0, 0, 0, 48, 0, 0, 0, 2, 0, 0, 0, 30, 0, 40, 0, 10, 0, 20, 0, 152, 255, 255, 255, 4, 0, 0, 0, 4, 0, 0, 0, 70, 114, 101, 100, 0, 0, 0, 0, 5, 0, 0, 0, 0, 1, 2, 3, 4, 0, 0, 0, 5, 0, 0, 0, 116, 101, 115, 116, 50, 0, 0, 0, 5, 0, 0, 0, 116, 101, 115, 116, 49, 0, 0, 0, 9, 0, 0, 0, 77, 121, 77, 111, 110, 115, 116, 101, 114, 0, 0, 0, 3, 0, 0, 0, 20, 0, 0, 0, 36, 0, 0, 0, 4, 0, 0, 0, 240, 255, 255, 255, 32, 0, 0, 0, 248, 255, 255, 255, 36, 0, 0, 0, 12, 0, 8, 0, 0, 0, 0, 0, 0, 0, 4, 0, 12, 0, 0, 0, 28, 0, 0, 0, 5, 0, 0, 0, 87, 105, 108, 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, 111, 0, 0, 0])

37

readMonster(fb: bytes.sizedBuffer)

38

}

39

40

func testCreateMonsterPrefixed() {

41

let bytes = createMonster(withPrefix: true)

42

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, 0, 0, 0, 0, 1, 60, 0, 0, 0, 68, 0, 0, 0, 76, 0, 0, 0, 0, 0, 0, 1, 88, 0, 0, 0, 120, 0, 0, 0, 0, 0, 80, 0, 0, 0, 128, 63, 0, 0, 0, 64, 0, 0, 64, 64, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 8, 64, 2, 0, 5, 0, 6, 0, 0, 0, 2, 0, 0, 0, 64, 0, 0, 0, 48, 0, 0, 0, 2, 0, 0, 0, 30, 0, 40, 0, 10, 0, 20, 0, 152, 255, 255, 255, 4, 0, 0, 0, 4, 0, 0, 0, 70, 114, 101, 100, 0, 0, 0, 0, 5, 0, 0, 0, 0, 1, 2, 3, 4, 0, 0, 0, 5, 0, 0, 0, 116, 101, 115, 116, 50, 0, 0, 0, 5, 0, 0, 0, 116, 101, 115, 116, 49, 0, 0, 0, 9, 0, 0, 0, 77, 121, 77, 111, 110, 115, 116, 101, 114, 0, 0, 0, 3, 0, 0, 0, 20, 0, 0, 0, 36, 0, 0, 0, 4, 0, 0, 0, 240, 255, 255, 255, 32, 0, 0, 0, 248, 255, 255, 255, 36, 0, 0, 0, 12, 0, 8, 0, 0, 0, 0, 0, 0, 0, 4, 0, 12, 0, 0, 0, 28, 0, 0, 0, 5, 0, 0, 0, 87, 105, 108, 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, 111, 0, 0, 0])

43

44

let newBuf = FlatBuffersUtils.removeSizePrefix(bb: bytes.buffer)

45

readMonster(fb: newBuf)

46

}

47

48

func testCreateMonsterUsingCreateMonsterMethodWithNilPos() {

49

var fbb = FlatBufferBuilder(initialSize: 1)

50

let name = fbb.create(string: "Frodo")

51

let mStart = Monster.startMonster(&fbb)

52

Monster.add(name: name, &fbb)

53

let root = Monster.endMonster(&fbb, start: mStart)

54

fbb.finish(offset: root)

55

let newMonster = Monster.getRootAsMonster(bb: fbb.sizedBuffer)

56

XCTAssertNil(newMonster.pos)

57

XCTAssertEqual(newMonster.name, "Frodo")

58

}

59

60

func testCreateMonsterUsingCreateMonsterMethodWithPosX() {

61

var fbb = FlatBufferBuilder(initialSize: 1)

62

let name = fbb.create(string: "Barney")

63

let mStart = Monster.startMonster(&fbb)

64

Monster.add(pos: MyGame_Example_Vec3.createVec3(builder: &fbb, x: 10, test2: .blue), &fbb)

65

Monster.add(name: name, &fbb)

66

let root = Monster.endMonster(&fbb, start: mStart)

67

fbb.finish(offset: root)

68

69

let newMonster = Monster.getRootAsMonster(bb: fbb.sizedBuffer)

70

XCTAssertEqual(newMonster.pos!.x, 10)

71

XCTAssertEqual(newMonster.name, "Barney")

72

}

73

74

func testReadMonsterFromUnsafePointerWithoutCopying() {

75

var array: [UInt8] = [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, 0, 0, 1, 60, 0, 0, 0, 68, 0, 0, 0, 76, 0, 0, 0, 0, 0, 0, 1, 88, 0, 0, 0, 120, 0, 0, 0, 0, 0, 80, 0, 0, 0, 128, 63, 0, 0, 0, 64, 0, 0, 64, 64, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 8, 64, 2, 0, 5, 0, 6, 0, 0, 0, 2, 0, 0, 0, 64, 0, 0, 0, 48, 0, 0, 0, 2, 0, 0, 0, 30, 0, 40, 0, 10, 0, 20, 0, 152, 255, 255, 255, 4, 0, 0, 0, 4, 0, 0, 0, 70, 114, 101, 100, 0, 0, 0, 0, 5, 0, 0, 0, 0, 1, 2, 3, 4, 0, 0, 0, 5, 0, 0, 0, 116, 101, 115, 116, 50, 0, 0, 0, 5, 0, 0, 0, 116, 101, 115, 116, 49, 0, 0, 0, 9, 0, 0, 0, 77, 121, 77, 111, 110, 115, 116, 101, 114, 0, 0, 0, 3, 0, 0, 0, 20, 0, 0, 0, 36, 0, 0, 0, 4, 0, 0, 0, 240, 255, 255, 255, 32, 0, 0, 0, 248, 255, 255, 255, 36, 0, 0, 0, 12, 0, 8, 0, 0, 0, 0, 0, 0, 0, 4, 0, 12, 0, 0, 0, 28, 0, 0, 0, 5, 0, 0, 0, 87, 105, 108, 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, 111, 0, 0, 0]

76

let unpacked = array.withUnsafeMutableBytes { (memory) -> MyGame_Example_MonsterT in

77

let bytes = ByteBuffer(assumingMemoryBound: memory.baseAddress!, capacity: memory.count)

78

var monster = Monster.getRootAsMonster(bb: bytes)

79

readFlatbufferMonster(monster: &monster)

80

let unpacked = monster.unpack()

81

return unpacked

82

}

83

readObjectApi(monster: unpacked)

84

}

85

86

func readMonster(fb: ByteBuffer) {

87

var monster = Monster.getRootAsMonster(bb: fb)

88

readFlatbufferMonster(monster: &monster)

89

let unpacked: MyGame_Example_MonsterT? = monster.unpack()

90

readObjectApi(monster: unpacked!)

91

guard let buffer = unpacked?.serialize() else { fatalError("Couldnt generate bytebuffer") }

92

var newMonster = Monster.getRootAsMonster(bb: buffer)

93

readFlatbufferMonster(monster: &newMonster)

94

}

95

96

func createMonster(withPrefix prefix: Bool) -> FlatBufferBuilder {

97

var fbb = FlatBufferBuilder(initialSize: 1)

98

let names = [fbb.create(string: "Frodo"), fbb.create(string: "Barney"), fbb.create(string: "Wilma")]

99

var offsets: [Offset<UOffset>] = []

100

let start1 = Monster.startMonster(&fbb)

101

Monster.add(name: names[0], &fbb)

102

offsets.append(Monster.endMonster(&fbb, start: start1))

103

let start2 = Monster.startMonster(&fbb)

104

Monster.add(name: names[1], &fbb)

105

offsets.append(Monster.endMonster(&fbb, start: start2))

106

let start3 = Monster.startMonster(&fbb)

107

Monster.add(name: names[2], &fbb)

108

offsets.append(Monster.endMonster(&fbb, start: start3))

109

110

let sortedArray = Monster.sortVectorOfMonster(offsets: offsets, &fbb)

111

112

let str = fbb.create(string: "MyMonster")

113

let test1 = fbb.create(string: "test1")

114

let test2 = fbb.create(string: "test2")

115

let _inv: [Byte] = [0, 1, 2, 3, 4]

116

let inv = fbb.createVector(_inv)

117

118

let fred = fbb.create(string: "Fred")

119

let mon1Start = Monster.startMonster(&fbb)

120

Monster.add(name: fred, &fbb)

121

let mon2 = Monster.endMonster(&fbb, start: mon1Start)

122

123

let size = 2

124

Monster.startVectorOfTest4(size, in: &fbb)

125

MyGame_Example_Test.createTest(builder: &fbb, a: 10, b: 20)

126

MyGame_Example_Test.createTest(builder: &fbb, a: 30, b: 40)

127

let test4 = fbb.endVectorOfStructs(count: size)

128

129

let stringTestVector = fbb.createVector(ofOffsets: [test1, test2])

130

let mStart = Monster.startMonster(&fbb)

131

let posStruct = MyGame_Example_Vec3.createVec3(builder: &fbb, x: 1, y: 2, z: 3, test1: 3, test2: .green, test3a: 5, test3b: 6)

132

Monster.add(pos: posStruct, &fbb)

133

Monster.add(hp: 80, &fbb)

134

Monster.add(name: str, &fbb)

135

Monster.addVectorOf(inventory: inv, &fbb)

136

Monster.add(testType: .monster, &fbb)

137

Monster.add(test: mon2, &fbb)

138

Monster.addVectorOf(test4: test4, &fbb)

139

Monster.addVectorOf(testarrayofstring: stringTestVector, &fbb)

140

Monster.add(testbool: true, &fbb)

141

Monster.addVectorOf(testarrayoftables: sortedArray, &fbb)

142

let end = Monster.endMonster(&fbb, start: mStart)

143

Monster.finish(&fbb, end: end, prefix: prefix)

return fbb

}

func mutateMonster(fb: ByteBuffer) {

148

let monster = Monster.getRootAsMonster(bb: fb)

149

XCTAssertFalse(monster.mutate(mana: 10))

150

XCTAssertEqual(monster.testarrayoftables(at: 0)?.name, "Barney")

151

XCTAssertEqual(monster.testarrayoftables(at: 1)?.name, "Frodo")

152

XCTAssertEqual(monster.testarrayoftables(at: 2)?.name, "Wilma")

153

154

// Example of searching for a table by the key

155

XCTAssertNotNil(monster.testarrayoftablesBy(key: "Frodo"))

156

XCTAssertNotNil(monster.testarrayoftablesBy(key: "Barney"))

157

XCTAssertNotNil(monster.testarrayoftablesBy(key: "Wilma"))

158

159

XCTAssertEqual(monster.testType, .monster)

160

161

XCTAssertEqual(monster.mutate(inventory: 1, at: 0), true)

162

XCTAssertEqual(monster.mutate(inventory: 2, at: 1), true)

163

XCTAssertEqual(monster.mutate(inventory: 3, at: 2), true)

164

XCTAssertEqual(monster.mutate(inventory: 4, at: 3), true)

165

XCTAssertEqual(monster.mutate(inventory: 5, at: 4), true)

166

167

for i in 0..<monster.inventoryCount {

168

XCTAssertEqual(monster.inventory(at: i), Byte(i + 1))

169

}

170

171

XCTAssertEqual(monster.mutate(inventory: 0, at: 0), true)

172

XCTAssertEqual(monster.mutate(inventory: 1, at: 1), true)

173

XCTAssertEqual(monster.mutate(inventory: 2, at: 2), true)

174

XCTAssertEqual(monster.mutate(inventory: 3, at: 3), true)

175

XCTAssertEqual(monster.mutate(inventory: 4, at: 4), true)

176

177

let vec = monster.pos

178

XCTAssertEqual(vec?.x, 1)

179

XCTAssertTrue(vec?.mutate(x: 55.0) ?? false)

180

XCTAssertTrue(vec?.mutate(test1: 55) ?? false)

181

XCTAssertEqual(vec?.x, 55.0)

182

XCTAssertEqual(vec?.test1, 55.0)

183

XCTAssertTrue(vec?.mutate(x: 1) ?? false)

184

XCTAssertEqual(vec?.x, 1)

185

XCTAssertTrue(vec?.mutate(test1: 3) ?? false)

186

}

187

188

func readFlatbufferMonster(monster: inout MyGame_Example_Monster) {

189

XCTAssertEqual(monster.hp, 80)

190

XCTAssertEqual(monster.mana, 150)

191

XCTAssertEqual(monster.name, "MyMonster")

192

let pos = monster.pos

193

XCTAssertEqual(pos?.x, 1)

194

XCTAssertEqual(pos?.y, 2)

195

XCTAssertEqual(pos?.z, 3)

196

XCTAssertEqual(pos?.test1, 3)

197

XCTAssertEqual(pos?.test2, .green)

198

let test = pos?.test3

199

XCTAssertEqual(test?.a, 5)

200

XCTAssertEqual(test?.b, 6)

201

XCTAssertEqual(monster.testType, .monster)

202

let monster2 = monster.test(type: Monster.self)

203

XCTAssertEqual(monster2?.name, "Fred")

204

205

XCTAssertEqual(monster.mutate(mana: 10), false)

206

207

XCTAssertEqual(monster.mana, 150)

208

XCTAssertEqual(monster.inventoryCount, 5)

209

var sum: Byte = 0

210

for i in 0...monster.inventoryCount {

211

sum += monster.inventory(at: i)

212

}

213

XCTAssertEqual(sum, 10)

214

XCTAssertEqual(monster.test4Count, 2)

215

let test0 = monster.test4(at: 0)

216

let test1 = monster.test4(at: 1)

217

var sum0 = 0

218

var sum1 = 0

219

if let a = test0?.a, let b = test0?.b {

220

sum0 = Int(a) + Int(b)

221

}

222

if let a = test1?.a, let b = test1?.b {

223

sum1 = Int(a) + Int(b)

224

}

225

XCTAssertEqual(sum0 + sum1, 100)

226

XCTAssertEqual(monster.testarrayofstringCount, 2)

227

XCTAssertEqual(monster.testarrayofstring(at: 0), "test1")

228

XCTAssertEqual(monster.testarrayofstring(at: 1), "test2")

229

XCTAssertEqual(monster.testbool, true)

230

231

let array = monster.nameSegmentArray

232

XCTAssertEqual(String(bytes: array ?? [], encoding: .utf8), "MyMonster")

233

234

if 0 == monster.testarrayofboolsCount {

235

XCTAssertEqual(monster.testarrayofbools.isEmpty, true)

236

} else {

237

XCTAssertEqual(monster.testarrayofbools.isEmpty, false)

}

}

func readObjectApi(monster: MyGame_Example_MonsterT) {

242

XCTAssertEqual(monster.hp, 80)

243

XCTAssertEqual(monster.mana, 150)

244

XCTAssertEqual(monster.name, "MyMonster")

245

let pos = monster.pos

246

XCTAssertEqual(pos?.x, 1)

247

XCTAssertEqual(pos?.y, 2)

248

XCTAssertEqual(pos?.z, 3)

249

XCTAssertEqual(pos?.test1, 3)

250

XCTAssertEqual(pos?.test2, .green)

251

let test = pos?.test3

252

XCTAssertEqual(test?.a, 5)

253

XCTAssertEqual(test?.b, 6)

254

let monster2 = monster.test?.value as? MyGame_Example_MonsterT

255

XCTAssertEqual(monster2?.name, "Fred")

256

XCTAssertEqual(monster.mana, 150)

257

monster.mana = 10

258

XCTAssertEqual(monster.mana, 10)

259

monster.mana = 150

260

XCTAssertEqual(monster.mana, 150)

261

262

XCTAssertEqual(monster.inventory.count, 5)

263

var sum: Byte = 0

264

for i in monster.inventory {

265

sum += i

266

}

267

XCTAssertEqual(sum, 10)

268

XCTAssertEqual(monster.test4.count, 2)

269

let test0 = monster.test4[0]

270

let test1 = monster.test4[1]

271

var sum0 = 0

272

var sum1 = 0

273

if let a = test0?.a, let b = test0?.b {

274

sum0 = Int(a) + Int(b)

275

}

276

if let a = test1?.a, let b = test1?.b {

277

sum1 = Int(a) + Int(b)

278

}

279

XCTAssertEqual(sum0 + sum1, 100)

280

XCTAssertEqual(monster.testbool, true)

281

}

282

}