1 2 import static com.google.flatbuffers.Constants.*; 3 import static com.google.common.truth.Truth.assertThat; 4 5 import DictionaryLookup.*; 6 import MyGame.Example.*; 7 import com.google.common.io.ByteStreams; 8 import optional_scalars.ScalarStuff; 9 import optional_scalars.OptionalByte; 10 import NamespaceA.*; 11 import NamespaceA.NamespaceB.*; 12 import com.google.flatbuffers.ByteBufferUtil; 13 import com.google.flatbuffers.ByteVector; 14 import com.google.flatbuffers.FlatBufferBuilder; 15 import com.google.flatbuffers.FlexBuffers; 16 import com.google.flatbuffers.FlexBuffersBuilder; 17 import com.google.flatbuffers.StringVector; 18 import com.google.flatbuffers.UnionVector; 19 20 import com.google.flatbuffers.FlexBuffers.FlexBufferException; 21 import com.google.flatbuffers.FlexBuffers.Reference; 22 import com.google.flatbuffers.FlexBuffers.Vector; 23 import com.google.flatbuffers.ArrayReadWriteBuf; 24 import com.google.flatbuffers.FlexBuffers.KeyVector; 25 26 import java.io.*; 27 import java.nio.ByteBuffer; 28 import java.nio.ByteOrder; 29 import java.nio.channels.FileChannel; 30 import java.nio.charset.StandardCharsets; 31 import java.util.Arrays; 32 import java.util.HashMap; 33 import java.util.Map; 34 import org.junit.Rule; 35 import org.junit.rules.TemporaryFolder; 36 import org.junit.runner.RunWith; 37 import org.junit.runners.JUnit4; 38 39 40 /* 41 * Copyright 2014 Google Inc. All rights reserved. 42 * 43 * Licensed under the Apache License, Version 2.0 (the "License"); 44 * you may not use this file except in compliance with the License. 45 * You may obtain a copy of the License at 46 * 47 * http://www.apache.org/licenses/LICENSE-2.0 48 * 49 * Unless required by applicable law or agreed to in writing, software 50 * distributed under the License is distributed on an "AS IS" BASIS, 51 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 52 * See the License for the specific language governing permissions and 53 * limitations under the License. 54 */ 55 56 @RunWith(JUnit4.class) 57 public class JavaTest { 58 59 @Rule 60 public TemporaryFolder tempFolder = new TemporaryFolder(); 61 62 @org.junit.Test mainTest()63 public void mainTest() throws IOException { 64 // First, let's test reading a FlatBuffer generated by C++ code: 65 // This file was generated from monsterdata_test.json 66 byte[] data = ByteStreams.toByteArray( 67 JavaTest.class.getClassLoader().getResourceAsStream("monsterdata_test.mon")); 68 69 // Now test it: 70 ByteBuffer bb = ByteBuffer.wrap(data); 71 TestBuffer(bb); 72 TestPackUnpack(bb); 73 } 74 75 @org.junit.Test testFlatBufferBuilder()76 public void testFlatBufferBuilder() { 77 // We use an initial size of 1 to exercise the reallocation algorithm, 78 // normally a size larger than the typical FlatBuffer you generate would be 79 // better for performance. 80 FlatBufferBuilder fbb = new FlatBufferBuilder(1); 81 TestBuilderBasics(fbb, true); 82 TestBuilderBasics(fbb, false); 83 TestExtendedBuffer(fbb.dataBuffer().asReadOnlyBuffer()); 84 } 85 86 @org.junit.Test TestEnums()87 public void TestEnums() { 88 assertThat(Color.name(Color.Red)).isEqualTo("Red"); 89 assertThat(Color.name(Color.Blue)).isEqualTo("Blue"); 90 assertThat(Any.name(Any.NONE)).isEqualTo("NONE"); 91 assertThat(Any.name(Any.Monster)).isEqualTo("Monster"); 92 } 93 TestBuffer(ByteBuffer bb)94 static void TestBuffer(ByteBuffer bb) { 95 assertThat(Monster.MonsterBufferHasIdentifier(bb)).isEqualTo(true); 96 97 Monster monster = Monster.getRootAsMonster(bb); 98 99 assertThat(monster.hp()).isEqualTo((short) 80); 100 // default 101 assertThat(monster.mana()).isEqualTo((short) 150); 102 103 assertThat(monster.name()).isEqualTo("MyMonster"); 104 // monster.friendly() // can't access, deprecated 105 106 Vec3 pos = monster.pos(); 107 assertThat(pos.x()).isEqualTo(1.0f); 108 assertThat(pos.y()).isEqualTo(2.0f); 109 assertThat(pos.z()).isEqualTo(3.0f); 110 assertThat(pos.test1()).isEqualTo(3.0); 111 // issue: int != byte 112 assertThat(pos.test2()).isEqualTo((int) Color.Green); 113 Test t = pos.test3(); 114 assertThat(t.a()).isEqualTo((short) 5); 115 assertThat(t.b()).isEqualTo((byte) 6); 116 117 assertThat(monster.testType()).isEqualTo((byte) Any.Monster); 118 Monster monster2 = new Monster(); 119 assertThat(monster.test(monster2) != null).isTrue(); 120 assertThat(monster2.name()).isEqualTo("Fred"); 121 122 assertThat(monster.inventoryLength()).isEqualTo(5); 123 int invsum = 0; 124 for (int i = 0; i < monster.inventoryLength(); i++) 125 invsum += monster.inventory(i); 126 assertThat(invsum).isEqualTo(10); 127 128 // Method using a vector access object: 129 ByteVector inventoryVector = monster.inventoryVector(); 130 assertThat(inventoryVector.length()).isEqualTo(5); 131 invsum = 0; 132 for (int i = 0; i < inventoryVector.length(); i++) 133 invsum += inventoryVector.getAsUnsigned(i); 134 assertThat(invsum).isEqualTo(10); 135 136 // Alternative way of accessing a vector: 137 ByteBuffer ibb = monster.inventoryAsByteBuffer(); 138 invsum = 0; 139 while (ibb.position() < ibb.limit()) 140 invsum += ibb.get(); 141 assertThat(invsum).isEqualTo(10); 142 143 Test test_0 = monster.test4(0); 144 Test test_1 = monster.test4(1); 145 assertThat(monster.test4Length()).isEqualTo(2); 146 assertThat(test_0.a() + test_0.b() + test_1.a() + test_1.b()).isEqualTo((Integer) 100); 147 148 Test.Vector test4Vector = monster.test4Vector(); 149 test_0 = test4Vector.get(0); 150 test_1 = test4Vector.get(1); 151 assertThat(test4Vector.length()).isEqualTo(2); 152 assertThat(test_0.a() + test_0.b() + test_1.a() + test_1.b()).isEqualTo((Integer) 100); 153 154 assertThat(monster.testarrayofstringLength()).isEqualTo(2); 155 assertThat(monster.testarrayofstring(0)).isEqualTo("test1"); 156 assertThat(monster.testarrayofstring(1)).isEqualTo("test2"); 157 158 // Method using a vector access object: 159 StringVector testarrayofstringVector = monster.testarrayofstringVector(); 160 assertThat(testarrayofstringVector.length()).isEqualTo(2); 161 assertThat(testarrayofstringVector.get(0)).isEqualTo("test1"); 162 assertThat(testarrayofstringVector.get(1)).isEqualTo("test2"); 163 164 assertThat(monster.testbool()).isEqualTo(true); 165 } 166 167 // this method checks additional fields not present in the binary buffer read from file 168 // these new tests are performed on top of the regular tests TestExtendedBuffer(ByteBuffer bb)169 static void TestExtendedBuffer(ByteBuffer bb) { 170 TestBuffer(bb); 171 172 Monster monster = Monster.getRootAsMonster(bb); 173 174 assertThat(monster.testhashu32Fnv1()).isEqualTo((Integer.MAX_VALUE + 1L)); 175 } 176 177 TestNamespaceNesting()178 @org.junit.Test public void TestNamespaceNesting() { 179 // reference / manipulate these to verify compilation 180 FlatBufferBuilder fbb = new FlatBufferBuilder(1); 181 182 TableInNestedNS.startTableInNestedNS(fbb); 183 TableInNestedNS.addFoo(fbb, 1234); 184 int nestedTableOff = TableInNestedNS.endTableInNestedNS(fbb); 185 186 TableInFirstNS.startTableInFirstNS(fbb); 187 TableInFirstNS.addFooTable(fbb, nestedTableOff); 188 int off = TableInFirstNS.endTableInFirstNS(fbb); 189 } 190 TestNestedFlatBuffer()191 @org.junit.Test public void TestNestedFlatBuffer() { 192 final String nestedMonsterName = "NestedMonsterName"; 193 final short nestedMonsterHp = 600; 194 final short nestedMonsterMana = 1024; 195 196 FlatBufferBuilder fbb1 = new FlatBufferBuilder(16); 197 int str1 = fbb1.createString(nestedMonsterName); 198 Monster.startMonster(fbb1); 199 Monster.addName(fbb1, str1); 200 Monster.addHp(fbb1, nestedMonsterHp); 201 Monster.addMana(fbb1, nestedMonsterMana); 202 int monster1 = Monster.endMonster(fbb1); 203 Monster.finishMonsterBuffer(fbb1, monster1); 204 byte[] fbb1Bytes = fbb1.sizedByteArray(); 205 fbb1 = null; 206 207 FlatBufferBuilder fbb2 = new FlatBufferBuilder(16); 208 int str2 = fbb2.createString("My Monster"); 209 int nestedBuffer = Monster.createTestnestedflatbufferVector(fbb2, fbb1Bytes); 210 Monster.startMonster(fbb2); 211 Monster.addName(fbb2, str2); 212 Monster.addHp(fbb2, (short)50); 213 Monster.addMana(fbb2, (short)32); 214 Monster.addTestnestedflatbuffer(fbb2, nestedBuffer); 215 int monster = Monster.endMonster(fbb2); 216 Monster.finishMonsterBuffer(fbb2, monster); 217 218 // Now test the data extracted from the nested buffer 219 Monster mons = Monster.getRootAsMonster(fbb2.dataBuffer()); 220 Monster nestedMonster = mons.testnestedflatbufferAsMonster(); 221 222 assertThat(nestedMonsterMana).isEqualTo(nestedMonster.mana()); 223 assertThat(nestedMonsterHp).isEqualTo(nestedMonster.hp()); 224 assertThat(nestedMonsterName).isEqualTo(nestedMonster.name()); 225 } 226 TestCreateByteVector()227 @org.junit.Test public void TestCreateByteVector() { 228 FlatBufferBuilder fbb = new FlatBufferBuilder(16); 229 int str = fbb.createString("MyMonster"); 230 byte[] inventory = new byte[] { 0, 1, 2, 3, 4 }; 231 int vec = fbb.createByteVector(inventory); 232 Monster.startMonster(fbb); 233 Monster.addInventory(fbb, vec); 234 Monster.addName(fbb, str); 235 int monster1 = Monster.endMonster(fbb); 236 Monster.finishMonsterBuffer(fbb, monster1); 237 Monster monsterObject = Monster.getRootAsMonster(fbb.dataBuffer()); 238 239 assertThat((Integer) monsterObject.inventory(1)).isEqualTo((int)inventory[1]); 240 assertThat(monsterObject.inventoryLength()).isEqualTo(inventory.length); 241 ByteVector inventoryVector = monsterObject.inventoryVector(); 242 assertThat(inventoryVector.getAsUnsigned(1)).isEqualTo((int)inventory[1]); 243 assertThat(inventoryVector.length()).isEqualTo(inventory.length); 244 245 assertThat(ByteBuffer.wrap(inventory)).isEqualTo( 246 monsterObject.inventoryAsByteBuffer()); 247 } 248 TestCreateUninitializedVector()249 @org.junit.Test public void TestCreateUninitializedVector() { 250 FlatBufferBuilder fbb = new FlatBufferBuilder(16); 251 int str = fbb.createString("MyMonster"); 252 byte[] inventory = new byte[] { 0, 1, 2, 3, 4 }; 253 ByteBuffer bb = fbb.createUnintializedVector(1, inventory.length, 1); 254 for (byte i:inventory) { 255 bb.put(i); 256 } 257 int vec = fbb.endVector(); 258 Monster.startMonster(fbb); 259 Monster.addInventory(fbb, vec); 260 Monster.addName(fbb, str); 261 int monster1 = Monster.endMonster(fbb); 262 Monster.finishMonsterBuffer(fbb, monster1); 263 Monster monsterObject = Monster.getRootAsMonster(fbb.dataBuffer()); 264 265 assertThat((Integer) monsterObject.inventory(1)).isEqualTo((int)inventory[1]); 266 assertThat(monsterObject.inventoryLength()).isEqualTo(inventory.length); 267 ByteVector inventoryVector = monsterObject.inventoryVector(); 268 assertThat(inventoryVector.getAsUnsigned(1)).isEqualTo((int)inventory[1]); 269 assertThat(inventoryVector.length()).isEqualTo(inventory.length); 270 assertThat(ByteBuffer.wrap(inventory)).isEqualTo( 271 monsterObject.inventoryAsByteBuffer()); 272 } 273 TestByteBufferFactory()274 @org.junit.Test public void TestByteBufferFactory() throws IOException { 275 File file = tempFolder.newFile("javatest.bin"); 276 final class MappedByteBufferFactory extends FlatBufferBuilder.ByteBufferFactory { 277 @Override 278 public ByteBuffer newByteBuffer(int capacity) { 279 ByteBuffer bb; 280 try { 281 RandomAccessFile f = new RandomAccessFile(file, "rw"); 282 bb = f.getChannel().map(FileChannel.MapMode.READ_WRITE, 0, capacity).order(ByteOrder.LITTLE_ENDIAN); 283 f.close(); 284 } catch(Throwable e) { 285 System.out.println("FlatBuffers test: couldn't map ByteBuffer to a file"); 286 bb = null; 287 } 288 return bb; 289 } 290 } 291 292 FlatBufferBuilder fbb = new FlatBufferBuilder(1, new MappedByteBufferFactory()); 293 294 TestBuilderBasics(fbb, false); 295 } 296 TestSizedInputStream()297 @org.junit.Test public void TestSizedInputStream() { 298 // Test on default FlatBufferBuilder that uses HeapByteBuffer 299 FlatBufferBuilder fbb = new FlatBufferBuilder(1); 300 301 TestBuilderBasics(fbb, false); 302 303 InputStream in = fbb.sizedInputStream(); 304 byte[] array = fbb.sizedByteArray(); 305 int count = 0; 306 int currentVal = 0; 307 308 while (currentVal != -1 && count < array.length) { 309 try { 310 currentVal = in.read(); 311 } catch(java.io.IOException e) { 312 System.out.println("FlatBuffers test: couldn't read from InputStream"); 313 return; 314 } 315 assertThat((byte)currentVal).isEqualTo(array[count]); 316 count++; 317 } 318 assertThat(count).isEqualTo(array.length); 319 } 320 TestBuilderBasics(FlatBufferBuilder fbb, boolean sizePrefix)321 void TestBuilderBasics(FlatBufferBuilder fbb, boolean sizePrefix) { 322 int[] names = {fbb.createString("Frodo"), fbb.createString("Barney"), fbb.createString("Wilma")}; 323 int[] off = new int[3]; 324 Monster.startMonster(fbb); 325 Monster.addName(fbb, names[0]); 326 off[0] = Monster.endMonster(fbb); 327 Monster.startMonster(fbb); 328 Monster.addName(fbb, names[1]); 329 off[1] = Monster.endMonster(fbb); 330 Monster.startMonster(fbb); 331 Monster.addName(fbb, names[2]); 332 off[2] = Monster.endMonster(fbb); 333 int sortMons = fbb.createSortedVectorOfTables(new Monster(), off); 334 335 // We set up the same values as monsterdata.json: 336 337 int str = fbb.createString("MyMonster"); 338 339 int inv = Monster.createInventoryVector(fbb, new byte[] { 0, 1, 2, 3, 4 }); 340 341 int fred = fbb.createString("Fred"); 342 Monster.startMonster(fbb); 343 Monster.addName(fbb, fred); 344 int mon2 = Monster.endMonster(fbb); 345 346 Monster.startTest4Vector(fbb, 2); 347 Test.createTest(fbb, (short)10, (byte)20); 348 Test.createTest(fbb, (short)30, (byte)40); 349 int test4 = fbb.endVector(); 350 351 int testArrayOfString = Monster.createTestarrayofstringVector(fbb, new int[] { 352 fbb.createString("test1"), 353 fbb.createString("test2") 354 }); 355 356 Monster.startMonster(fbb); 357 Monster.addPos(fbb, Vec3.createVec3(fbb, 1.0f, 2.0f, 3.0f, 3.0, 358 Color.Green, (short)5, (byte)6)); 359 Monster.addHp(fbb, (short)80); 360 Monster.addName(fbb, str); 361 Monster.addInventory(fbb, inv); 362 Monster.addTestType(fbb, (byte)Any.Monster); 363 Monster.addTest(fbb, mon2); 364 Monster.addTest4(fbb, test4); 365 Monster.addTestarrayofstring(fbb, testArrayOfString); 366 Monster.addTestbool(fbb, true); 367 Monster.addTesthashu32Fnv1(fbb, Integer.MAX_VALUE + 1L); 368 Monster.addTestarrayoftables(fbb, sortMons); 369 int mon = Monster.endMonster(fbb); 370 371 if (sizePrefix) { 372 Monster.finishSizePrefixedMonsterBuffer(fbb, mon); 373 } else { 374 Monster.finishMonsterBuffer(fbb, mon); 375 } 376 377 // Write the result to a file for debugging purposes: 378 // Note that the binaries are not necessarily identical, since the JSON 379 // parser may serialize in a slightly different order than the above 380 // Java code. They are functionally equivalent though. 381 382 try { 383 String filename = "monsterdata_java_wire" + (sizePrefix ? "_sp" : "") + ".mon"; 384 FileChannel fc = new FileOutputStream(tempFolder.newFile(filename)).getChannel(); 385 fc.write(fbb.dataBuffer().duplicate()); 386 fc.close(); 387 } catch(java.io.IOException e) { 388 System.out.println("FlatBuffers test: couldn't write file"); 389 return; 390 } 391 392 // Test it: 393 ByteBuffer dataBuffer = fbb.dataBuffer(); 394 if (sizePrefix) { 395 assertThat(ByteBufferUtil.getSizePrefix(dataBuffer) + SIZE_PREFIX_LENGTH).isEqualTo( 396 dataBuffer.remaining()); 397 dataBuffer = ByteBufferUtil.removeSizePrefix(dataBuffer); 398 } 399 TestExtendedBuffer(dataBuffer); 400 401 // Make sure it also works with read only ByteBuffers. This is slower, 402 // since creating strings incurs an additional copy 403 // (see Table.__string). 404 TestExtendedBuffer(dataBuffer.asReadOnlyBuffer()); 405 406 //Attempt to mutate Monster fields and check whether the buffer has been mutated properly 407 // revert to original values after testing 408 Monster monster = Monster.getRootAsMonster(dataBuffer); 409 410 // mana is optional and does not exist in the buffer so the mutation should fail 411 // the mana field should retain its default value 412 assertThat(monster.mutateMana((short)10)).isFalse(); 413 assertThat(monster.mana()).isEqualTo((short) 150); 414 415 // Accessing a vector of sorted by the key tables 416 assertThat(monster.testarrayoftables(0).name()).isEqualTo("Barney"); 417 assertThat(monster.testarrayoftables(1).name()).isEqualTo("Frodo"); 418 assertThat(monster.testarrayoftables(2).name()).isEqualTo("Wilma"); 419 Monster.Vector testarrayoftablesVector = monster.testarrayoftablesVector(); 420 assertThat(testarrayoftablesVector.get(0).name()).isEqualTo("Barney"); 421 assertThat(testarrayoftablesVector.get(1).name()).isEqualTo("Frodo"); 422 assertThat(testarrayoftablesVector.get(2).name()).isEqualTo("Wilma"); 423 424 // Example of searching for a table by the key 425 assertThat(monster.testarrayoftablesByKey("Frodo").name()).isEqualTo("Frodo"); 426 assertThat(monster.testarrayoftablesByKey("Barney").name()).isEqualTo("Barney"); 427 assertThat(monster.testarrayoftablesByKey("Wilma").name()).isEqualTo("Wilma"); 428 assertThat(testarrayoftablesVector.getByKey("Frodo").name()).isEqualTo("Frodo"); 429 assertThat(testarrayoftablesVector.getByKey("Barney").name()).isEqualTo("Barney"); 430 assertThat(testarrayoftablesVector.getByKey("Wilma").name()).isEqualTo("Wilma"); 431 432 // testType is an existing field and mutating it should succeed 433 assertThat(monster.testType()).isEqualTo((byte) Any.Monster); 434 435 //mutate the inventory vector 436 assertThat(monster.mutateInventory(0, 1)).isTrue(); 437 assertThat(monster.mutateInventory(1, 2)).isTrue(); 438 assertThat(monster.mutateInventory(2, 3)).isTrue(); 439 assertThat(monster.mutateInventory(3, 4)).isTrue(); 440 assertThat(monster.mutateInventory(4, 5)).isTrue(); 441 442 for (int i = 0; i < monster.inventoryLength(); i++) { 443 assertThat((Integer) monster.inventory(i)).isEqualTo(i + 1); 444 } 445 ByteVector inventoryVector = monster.inventoryVector(); 446 for (int i = 0; i < inventoryVector.length(); i++) { 447 assertThat((int)inventoryVector.get(i)).isEqualTo(i + 1); 448 } 449 450 //reverse mutation 451 assertThat(monster.mutateInventory(0, 0)).isTrue(); 452 assertThat(monster.mutateInventory(1, 1)).isTrue(); 453 assertThat(monster.mutateInventory(2, 2)).isTrue(); 454 assertThat(monster.mutateInventory(3, 3)).isTrue(); 455 assertThat(monster.mutateInventory(4, 4)).isTrue(); 456 457 // get a struct field and edit one of its fields 458 Vec3 pos = monster.pos(); 459 assertThat(pos.x()).isEqualTo(1.0f); 460 pos.mutateX(55.0f); 461 assertThat(pos.x()).isEqualTo(55.0f); 462 pos.mutateX(1.0f); 463 assertThat(pos.x()).isEqualTo(1.0f); 464 } 465 TestVectorOfUnions()466 @org.junit.Test public void TestVectorOfUnions() { 467 final FlatBufferBuilder fbb = new FlatBufferBuilder(); 468 469 final int swordAttackDamage = 1; 470 471 final int[] characterVector = new int[] { 472 Attacker.createAttacker(fbb, swordAttackDamage), 473 }; 474 475 final byte[] characterTypeVector = new byte[]{ 476 Character.MuLan, 477 }; 478 479 Movie.finishMovieBuffer( 480 fbb, 481 Movie.createMovie( 482 fbb, 483 (byte)0, 484 (byte)0, 485 Movie.createCharactersTypeVector(fbb, characterTypeVector), 486 Movie.createCharactersVector(fbb, characterVector) 487 ) 488 ); 489 490 final Movie movie = Movie.getRootAsMovie(fbb.dataBuffer()); 491 ByteVector charactersTypeByteVector = movie.charactersTypeVector(); 492 UnionVector charactersVector = movie.charactersVector(); 493 494 assertThat(movie.charactersTypeLength()).isEqualTo(characterTypeVector.length); 495 assertThat(charactersTypeByteVector.length()).isEqualTo(characterTypeVector.length); 496 assertThat(movie.charactersLength()).isEqualTo(characterVector.length); 497 assertThat(charactersVector.length()).isEqualTo(characterVector.length); 498 499 assertThat((Byte) movie.charactersType(0)).isEqualTo(characterTypeVector[0]); 500 assertThat(charactersTypeByteVector.get(0)).isEqualTo(characterTypeVector[0]); 501 502 assertThat(((Attacker)movie.characters(new Attacker(), 0)).swordAttackDamage()).isEqualTo( 503 swordAttackDamage); 504 } 505 TestFixedLengthArrays()506 @org.junit.Test public void TestFixedLengthArrays() { 507 FlatBufferBuilder builder = new FlatBufferBuilder(0); 508 509 float a; 510 int[] b = new int[15]; 511 byte c; 512 int[][] d_a = new int[2][2]; 513 byte[] d_b = new byte[2]; 514 byte[][] d_c = new byte[2][2]; 515 long[][] d_d = new long[2][2]; 516 int e; 517 long[] f = new long[2]; 518 519 a = 0.5f; 520 for (int i = 0; i < 15; i++) b[i] = i; 521 c = 1; 522 d_a[0][0] = 1; 523 d_a[0][1] = 2; 524 d_a[1][0] = 3; 525 d_a[1][1] = 4; 526 d_b[0] = TestEnum.B; 527 d_b[1] = TestEnum.C; 528 d_c[0][0] = TestEnum.A; 529 d_c[0][1] = TestEnum.B; 530 d_c[1][0] = TestEnum.C; 531 d_c[1][1] = TestEnum.B; 532 d_d[0][0] = -1; 533 d_d[0][1] = 1; 534 d_d[1][0] = -2; 535 d_d[1][1] = 2; 536 e = 2; 537 f[0] = -1; 538 f[1] = 1; 539 540 int arrayOffset = ArrayStruct.createArrayStruct(builder, 541 a, b, c, d_a, d_b, d_c, d_d, e, f); 542 543 // Create a table with the ArrayStruct. 544 ArrayTable.startArrayTable(builder); 545 ArrayTable.addA(builder, arrayOffset); 546 int tableOffset = ArrayTable.endArrayTable(builder); 547 548 ArrayTable.finishArrayTableBuffer(builder, tableOffset); 549 550 ArrayTable table = ArrayTable.getRootAsArrayTable(builder.dataBuffer()); 551 NestedStruct nested = new NestedStruct(); 552 553 assertThat(table.a().a()).isEqualTo(0.5f); 554 for (int i = 0; i < 15; i++) 555 assertThat(table.a().b(i)).isEqualTo(i); 556 assertThat(table.a().c()).isEqualTo((byte)1); 557 assertThat(table.a().d(nested, 0).a(0)).isEqualTo(1); 558 assertThat(table.a().d(nested, 0).a(1)).isEqualTo(2); 559 assertThat(table.a().d(nested, 1).a(0)).isEqualTo(3); 560 assertThat(table.a().d(nested, 1).a(1)).isEqualTo(4); 561 assertThat(table.a().d(nested, 0).b()).isEqualTo(TestEnum.B); 562 assertThat(table.a().d(nested, 1).b()).isEqualTo(TestEnum.C); 563 assertThat(table.a().d(nested, 0).c(0)).isEqualTo(TestEnum.A); 564 assertThat(table.a().d(nested, 0).c(1)).isEqualTo(TestEnum.B); 565 assertThat(table.a().d(nested, 1).c(0)).isEqualTo(TestEnum.C); 566 assertThat(table.a().d(nested, 1).c(1)).isEqualTo(TestEnum.B); 567 assertThat(table.a().d(nested, 0).d(0)).isEqualTo((long)-1); 568 assertThat(table.a().d(nested, 0).d(1)).isEqualTo((long)1); 569 assertThat(table.a().d(nested, 1).d(0)).isEqualTo((long)-2); 570 assertThat(table.a().d(nested, 1).d(1)).isEqualTo((long)2); 571 assertThat(table.a().e()).isEqualTo(2); 572 assertThat(table.a().f(0)).isEqualTo((long)-1); 573 assertThat(table.a().f(1)).isEqualTo((long)1); 574 } 575 testFlexBuffersTest()576 @org.junit.Test public void testFlexBuffersTest() { 577 FlexBuffersBuilder builder = new FlexBuffersBuilder(ByteBuffer.allocate(512), 578 FlexBuffersBuilder.BUILDER_FLAG_SHARE_KEYS_AND_STRINGS); 579 testFlexBuffersTest(builder); 580 int bufferLimit1 = ((ArrayReadWriteBuf) builder.getBuffer()).limit(); 581 582 // Repeat after clearing the builder to ensure the builder is reusable 583 builder.clear(); 584 testFlexBuffersTest(builder); 585 int bufferLimit2 = ((ArrayReadWriteBuf) builder.getBuffer()).limit(); 586 assertThat(bufferLimit1).isEqualTo(bufferLimit2); 587 } 588 testFlexBuffersTest(FlexBuffersBuilder builder)589 public static void testFlexBuffersTest(FlexBuffersBuilder builder) { 590 // Write the equivalent of: 591 // { vec: [ -100, "Fred", 4.0, false ], bar: [ 1, 2, 3 ], bar3: [ 1, 2, 3 ], 592 // foo: 100, bool: true, mymap: { foo: "Fred" } } 593 // It's possible to do this without std::function support as well. 594 int map1 = builder.startMap(); 595 596 int vec1 = builder.startVector(); 597 builder.putInt(-100); 598 builder.putString("Fred"); 599 builder.putBlob(new byte[]{(byte) 77}); 600 builder.putBoolean(false); 601 builder.putInt(Long.MAX_VALUE); 602 603 int map2 = builder.startMap(); 604 builder.putInt("test", 200); 605 builder.endMap(null, map2); 606 607 builder.putFloat(150.9); 608 builder.putFloat(150.9999998); 609 builder.endVector("vec", vec1, false, false); 610 611 vec1 = builder.startVector(); 612 builder.putInt(1); 613 builder.putInt(2); 614 builder.putInt(3); 615 builder.endVector("bar", vec1, true, false); 616 617 vec1 = builder.startVector(); 618 builder.putBoolean(true); 619 builder.putBoolean(false); 620 builder.putBoolean(true); 621 builder.putBoolean(false); 622 builder.endVector("bools", vec1, true, false); 623 624 builder.putBoolean("bool", true); 625 builder.putFloat("foo", 100); 626 627 map2 = builder.startMap(); 628 builder.putString("bar", "Fred"); // Testing key and string reuse. 629 builder.putInt("int", -120); 630 builder.putFloat("float", -123.0f); 631 builder.putBlob("blob", new byte[]{ 65, 67 }); 632 builder.endMap("mymap", map2); 633 634 builder.endMap(null, map1); 635 builder.finish(); 636 637 FlexBuffers.Map m = FlexBuffers.getRoot(builder.getBuffer()).asMap(); 638 639 assertThat(m.size()).isEqualTo(6); 640 641 // test empty (an null) 642 // empty if fail 643 assertThat(m.get("no_key").asString()).isEqualTo(""); 644 // empty if fail 645 assertThat(m.get("no_key").asMap()).isEqualTo(FlexBuffers.Map.empty()); 646 // empty if fail 647 assertThat(m.get("no_key").asKey()).isEqualTo(FlexBuffers.Key.empty()); 648 // empty if fail 649 assertThat(m.get("no_key").asVector()).isEqualTo(Vector.empty()); 650 // empty if fail 651 assertThat(m.get("no_key").asBlob()).isEqualTo(FlexBuffers.Blob.empty()); 652 assert(m.get("no_key").asVector().isEmpty()); // empty if fail 653 654 // testing "vec" field 655 FlexBuffers.Vector vec = m.get("vec").asVector(); 656 assertThat(vec.size()).isEqualTo(8); 657 assertThat(vec.get(0).asLong()).isEqualTo((long) -100); 658 assertThat(vec.get(1).asString()).isEqualTo("Fred"); 659 assertThat(vec.get(2).isBlob()).isTrue(); 660 assertThat(vec.get(2).asBlob().size()).isEqualTo(1); 661 assertThat(vec.get(2).asBlob().data().get(0)).isEqualTo((byte) 77); 662 // Check if type is a bool 663 assertThat(vec.get(3).isBoolean()).isTrue(); 664 // Check if value is false 665 assertThat(vec.get(3).asBoolean()).isFalse(); 666 assertThat(vec.get(4).asLong()).isEqualTo(Long.MAX_VALUE); 667 assertThat(vec.get(5).isMap()).isTrue(); 668 assertThat(vec.get(5).asMap().get("test").asInt()).isEqualTo(200); 669 assertThat(Float.compare((float)vec.get(6).asFloat(), 150.9f)).isEqualTo(0); 670 assertThat(Double.compare(vec.get(7).asFloat(), 150.9999998)).isEqualTo(0); 671 //conversion fail returns 0 as C++ 672 assertThat((long)0).isEqualTo((long)vec.get(1).asLong()); 673 674 // bar vector 675 FlexBuffers.Vector tvec = m.get("bar").asVector(); 676 assertThat(tvec.size()).isEqualTo(3); 677 assertThat(tvec.get(0).asInt()).isEqualTo(1); 678 assertThat(tvec.get(1).asInt()).isEqualTo(2); 679 assertThat(tvec.get(2).asInt()).isEqualTo(3); 680 assertThat(((FlexBuffers.TypedVector) tvec).getElemType()).isEqualTo(FlexBuffers.FBT_INT); 681 682 // bools vector 683 FlexBuffers.Vector bvec = m.get("bools").asVector(); 684 assertThat(bvec.size()).isEqualTo(4); 685 assertThat(bvec.get(0).asBoolean()).isTrue(); 686 assertThat(bvec.get(1).asBoolean()).isFalse(); 687 assertThat(bvec.get(2).asBoolean()).isTrue(); 688 assertThat(bvec.get(3).asBoolean()).isFalse(); 689 assertThat(((FlexBuffers.TypedVector) bvec).getElemType()).isEqualTo(FlexBuffers.FBT_BOOL); 690 691 assertThat((float)m.get("foo").asFloat()).isEqualTo((float) 100); 692 assertThat(m.get("unknown").isNull()).isTrue(); 693 694 // mymap vector 695 FlexBuffers.Map mymap = m.get("mymap").asMap(); 696 // These should be equal by pointer equality, since key and value are shared. 697 assertThat(mymap.keys().get(0)).isEqualTo(m.keys().get(0)); 698 assertThat(mymap.keys().get(0).toString()).isEqualTo("bar"); 699 assertThat(mymap.values().get(0).asString()).isEqualTo(vec.get(1).asString()); 700 assertThat(mymap.get("int").asInt()).isEqualTo(-120); 701 assertThat((float)mymap.get("float").asFloat()).isEqualTo(-123.0f); 702 assertThat(Arrays.equals(mymap.get("blob").asBlob().getBytes(), new byte[]{ 65, 67 })).isEqualTo( 703 true); 704 assertThat(mymap.get("blob").asBlob().toString()).isEqualTo("AC"); 705 assertThat(mymap.get("blob").toString()).isEqualTo("\"AC\""); 706 } 707 testFlexBufferVectorStrings()708 @org.junit.Test public void testFlexBufferVectorStrings() { 709 FlexBuffersBuilder builder = new FlexBuffersBuilder(ByteBuffer.allocate(10000000)); 710 711 int size = 3000; 712 StringBuilder sb = new StringBuilder(); 713 for (int i=0; i< size; i++) { 714 sb.append("a"); 715 } 716 717 String text = sb.toString(); 718 assertThat(text.length()).isEqualTo(size); 719 720 int pos = builder.startVector(); 721 722 for (int i=0; i<size; i++) { 723 builder.putString(text); 724 } 725 726 try { 727 builder.endVector(null, pos, true, false); 728 // this should raise an exception as 729 // typed vector of string was deprecated 730 assert false; 731 } catch(FlexBufferException fb) { 732 // no op 733 } 734 // we finish the vector again as non-typed 735 builder.endVector(null, pos, false, false); 736 737 ByteBuffer b = builder.finish(); 738 Vector v = FlexBuffers.getRoot(b).asVector(); 739 740 assertThat(v.size()).isEqualTo(size); 741 for (int i=0; i<size; i++) { 742 assertThat(v.get(i).asString().length()).isEqualTo(size); 743 assertThat(v.get(i).asString()).isEqualTo(text); 744 } 745 } 746 testDeprecatedTypedVectorString()747 @org.junit.Test public void testDeprecatedTypedVectorString() { 748 // tests whether we are able to support reading deprecated typed vector string 749 // data is equivalent to [ "abc", "abc", "abc", "abc"] 750 byte[] data = new byte[] {0x03, 0x61, 0x62, 0x63, 0x00, 0x03, 0x61, 0x62, 0x63, 0x00, 751 0x03, 0x61, 0x62, 0x63, 0x00, 0x03, 0x61, 0x62, 0x63, 0x00, 0x04, 0x14, 0x10, 752 0x0c, 0x08, 0x04, 0x3c, 0x01}; 753 Reference ref = FlexBuffers.getRoot(ByteBuffer.wrap(data)); 754 assertThat(ref.getType()).isEqualTo(FlexBuffers.FBT_VECTOR_STRING_DEPRECATED); 755 assertThat(ref.isTypedVector()).isTrue(); 756 Vector vec = ref.asVector(); 757 for (int i=0; i< vec.size(); i++) { 758 assertThat("abc").isEqualTo(vec.get(i).asString()); 759 } 760 } 761 testSingleElementBoolean()762 @org.junit.Test public void testSingleElementBoolean() { 763 FlexBuffersBuilder builder = new FlexBuffersBuilder(ByteBuffer.allocate(100)); 764 builder.putBoolean(true); 765 ByteBuffer b = builder.finish(); 766 assertThat(FlexBuffers.getRoot(b).asBoolean()).isTrue(); 767 } 768 testSingleElementByte()769 @org.junit.Test public void testSingleElementByte() { 770 FlexBuffersBuilder builder = new FlexBuffersBuilder(); 771 builder.putInt(10); 772 ByteBuffer b = builder.finish(); 773 assertThat(10).isEqualTo(FlexBuffers.getRoot(b).asInt()); 774 } 775 testSingleElementShort()776 @org.junit.Test public void testSingleElementShort() { 777 FlexBuffersBuilder builder = new FlexBuffersBuilder(); 778 builder.putInt(Short.MAX_VALUE); 779 ByteBuffer b = builder.finish(); 780 assertThat(Short.MAX_VALUE).isEqualTo((short) FlexBuffers.getRoot(b).asInt()); 781 } 782 testSingleElementInt()783 @org.junit.Test public void testSingleElementInt() { 784 FlexBuffersBuilder builder = new FlexBuffersBuilder(); 785 builder.putInt(Integer.MIN_VALUE); 786 ByteBuffer b = builder.finish(); 787 assertThat(Integer.MIN_VALUE).isEqualTo(FlexBuffers.getRoot(b).asInt()); 788 } 789 testSingleElementLong()790 @org.junit.Test public void testSingleElementLong() { 791 FlexBuffersBuilder builder = new FlexBuffersBuilder(); 792 builder.putInt(Long.MAX_VALUE); 793 ByteBuffer b = builder.finish(); 794 assertThat(Long.MAX_VALUE).isEqualTo(FlexBuffers.getRoot(b).asLong()); 795 } 796 testSingleElementFloat()797 @org.junit.Test public void testSingleElementFloat() { 798 FlexBuffersBuilder builder = new FlexBuffersBuilder(); 799 builder.putFloat(Float.MAX_VALUE); 800 ByteBuffer b = builder.finish(); 801 assertThat(Float.compare(Float.MAX_VALUE, (float) FlexBuffers.getRoot(b).asFloat())).isEqualTo( 802 0); 803 } 804 testSingleElementDouble()805 @org.junit.Test public void testSingleElementDouble() { 806 FlexBuffersBuilder builder = new FlexBuffersBuilder(); 807 builder.putFloat(Double.MAX_VALUE); 808 ByteBuffer b = builder.finish(); 809 assertThat(Double.compare(Double.MAX_VALUE, FlexBuffers.getRoot(b).asFloat())).isEqualTo(0); 810 } 811 testSingleElementBigString()812 @org.junit.Test public void testSingleElementBigString() { 813 FlexBuffersBuilder builder = new FlexBuffersBuilder(ByteBuffer.allocate(10000)); 814 StringBuilder sb = new StringBuilder(); 815 816 for (int i=0; i< 3000; i++) { 817 sb.append("a"); 818 } 819 820 builder.putString(sb.toString()); 821 ByteBuffer b = builder.finish(); 822 823 FlexBuffers.Reference r = FlexBuffers.getRoot(b); 824 825 assertThat(FlexBuffers.FBT_STRING).isEqualTo(r.getType()); 826 assertThat(sb.toString()).isEqualTo(r.asString()); 827 } 828 testSingleElementSmallString()829 @org.junit.Test public void testSingleElementSmallString() { 830 FlexBuffersBuilder builder = new FlexBuffersBuilder(ByteBuffer.allocate(10000)); 831 832 builder.putString("aa"); 833 ByteBuffer b = builder.finish(); 834 FlexBuffers.Reference r = FlexBuffers.getRoot(b); 835 836 assertThat(FlexBuffers.FBT_STRING).isEqualTo(r.getType()); 837 assertThat("aa").isEqualTo(r.asString()); 838 } 839 testSingleElementBlob()840 @org.junit.Test public void testSingleElementBlob() { 841 FlexBuffersBuilder builder = new FlexBuffersBuilder(); 842 builder.putBlob(new byte[]{5, 124, 118, -1}); 843 ByteBuffer b = builder.finish(); 844 FlexBuffers.Reference r = FlexBuffers.getRoot(b); 845 byte[] result = r.asBlob().getBytes(); 846 assertThat((byte)5).isEqualTo(result[0]); 847 assertThat((byte)124).isEqualTo(result[1]); 848 assertThat((byte)118).isEqualTo(result[2]); 849 assertThat((byte)-1).isEqualTo(result[3]); 850 } 851 testSingleElementLongBlob()852 @org.junit.Test public void testSingleElementLongBlob() { 853 854 // verifies blobs of up to 2^16 in length 855 for (int i = 2; i <= 1<<16; i = i<<1) { 856 byte[] input = new byte[i-1]; 857 for (int index = 0; index < input.length; index++) { 858 input[index] = (byte)(index % 64); 859 } 860 861 FlexBuffersBuilder builder = new FlexBuffersBuilder(); 862 builder.putBlob(input); 863 ByteBuffer b = builder.finish(); 864 FlexBuffers.Reference r = FlexBuffers.getRoot(b); 865 byte[] result = r.asBlob().getBytes(); 866 867 for (int index = 0; index < input.length; index++) { 868 assertThat((byte)(index % 64)).isEqualTo(result[index]); 869 } 870 } 871 } 872 testSingleElementUByte()873 @org.junit.Test public void testSingleElementUByte() { 874 FlexBuffersBuilder builder = new FlexBuffersBuilder(); 875 builder.putUInt(0xFF); 876 ByteBuffer b = builder.finish(); 877 FlexBuffers.Reference r = FlexBuffers.getRoot(b); 878 assertThat(255).isEqualTo((int)r.asUInt()); 879 } 880 testSingleElementUShort()881 @org.junit.Test public void testSingleElementUShort() { 882 FlexBuffersBuilder builder = new FlexBuffersBuilder(); 883 builder.putUInt(0xFFFF); 884 ByteBuffer b = builder.finish(); 885 FlexBuffers.Reference r = FlexBuffers.getRoot(b); 886 assertThat(65535).isEqualTo((int)r.asUInt()); 887 } 888 testSingleElementUInt()889 @org.junit.Test public void testSingleElementUInt() { 890 FlexBuffersBuilder builder = new FlexBuffersBuilder(); 891 builder.putUInt(0xFFFF_FFFFL); 892 ByteBuffer b = builder.finish(); 893 FlexBuffers.Reference r = FlexBuffers.getRoot(b); 894 assertThat(4294967295L).isEqualTo(r.asUInt()); 895 } 896 testSingleFixedTypeVector()897 @org.junit.Test public void testSingleFixedTypeVector() { 898 899 int[] ints = new int[]{5, 124, 118, -1}; 900 float[] floats = new float[]{5.5f, 124.124f, 118.118f, -1.1f}; 901 String[] strings = new String[]{"This", "is", "a", "typed", "array"}; 902 boolean[] booleans = new boolean[]{false, true, true, false}; 903 904 905 FlexBuffersBuilder builder = new FlexBuffersBuilder(ByteBuffer.allocate(512), 906 FlexBuffersBuilder.BUILDER_FLAG_NONE); 907 908 int mapPos = builder.startMap(); 909 910 int vecPos = builder.startVector(); 911 for (final int i : ints) { 912 builder.putInt(i); 913 } 914 builder.endVector("ints", vecPos, true, false); 915 916 vecPos = builder.startVector(); 917 for (final float i : floats) { 918 builder.putFloat(i); 919 } 920 builder.endVector("floats", vecPos, true, false); 921 922 vecPos = builder.startVector(); 923 for (final boolean i : booleans) { 924 builder.putBoolean(i); 925 } 926 builder.endVector("booleans", vecPos, true, false); 927 928 builder.endMap(null, mapPos); 929 930 931 ByteBuffer b = builder.finish(); 932 FlexBuffers.Reference r = FlexBuffers.getRoot(b); 933 assert(r.asMap().get("ints").isTypedVector()); 934 assert(r.asMap().get("floats").isTypedVector()); 935 assert(r.asMap().get("booleans").isTypedVector()); 936 } 937 testSingleElementVector()938 @org.junit.Test public void testSingleElementVector() { 939 FlexBuffersBuilder b = new FlexBuffersBuilder(); 940 941 int vecPos = b.startVector(); 942 b.putInt(99); 943 b.putString("wow"); 944 b.putNull(); 945 int vecpos2 = b.startVector(); 946 b.putInt(99); 947 b.putString("wow"); 948 b.putNull(); 949 b.endVector(null, vecpos2, false, false); 950 b.endVector(null, vecPos, false, false); 951 b.finish(); 952 953 FlexBuffers.Reference r = FlexBuffers.getRoot(b.getBuffer()); 954 assertThat(FlexBuffers.FBT_VECTOR).isEqualTo(r.getType()); 955 FlexBuffers.Vector vec = FlexBuffers.getRoot(b.getBuffer()).asVector(); 956 assertThat(4).isEqualTo(vec.size()); 957 assertThat(99).isEqualTo(vec.get(0).asInt()); 958 assertThat("wow").isEqualTo(vec.get(1).asString()); 959 assertThat(true).isEqualTo(vec.get(2).isNull()); 960 assertThat("[ 99, \"wow\", null ]").isEqualTo(vec.get(3).toString()); 961 assertThat("[ 99, \"wow\", null, [ 99, \"wow\", null ] ]").isEqualTo( 962 FlexBuffers.getRoot(b.getBuffer()).toString()); 963 } 964 testSingleElementMap()965 @org.junit.Test public void testSingleElementMap() { 966 FlexBuffersBuilder b = new FlexBuffersBuilder(); 967 968 int mapPost = b.startMap(); 969 b.putInt("myInt", 0x7fffffbbbfffffffL); 970 b.putString("myString", "wow"); 971 b.putString("myString2", "incredible"); 972 b.putNull("myNull"); 973 int start = b.startVector(); 974 b.putInt(99); 975 b.putString("wow"); 976 b.endVector("myVec", start, false, false); 977 978 b.putFloat("double", 0x1.ffffbbbffffffP+1023); 979 b.endMap(null, mapPost); 980 b.finish(); 981 982 FlexBuffers.Reference r = FlexBuffers.getRoot(b.getBuffer()); 983 assertThat(FlexBuffers.FBT_MAP).isEqualTo(r.getType()); 984 FlexBuffers.Map map = FlexBuffers.getRoot(b.getBuffer()).asMap(); 985 assertThat(6).isEqualTo(map.size()); 986 assertThat(0x7fffffbbbfffffffL).isEqualTo(map.get("myInt").asLong()); 987 assertThat("wow").isEqualTo(map.get("myString").asString()); 988 assertThat("incredible").isEqualTo(map.get("myString2").asString()); 989 assertThat(true).isEqualTo(map.get("myNull").isNull()); 990 assertThat(99).isEqualTo(map.get("myVec").asVector().get(0).asInt()); 991 assertThat("wow").isEqualTo(map.get("myVec").asVector().get(1).asString()); 992 assertThat(Double.compare(0x1.ffffbbbffffffP+1023, map.get("double").asFloat())).isEqualTo(0); 993 assertThat( 994 "{ \"double\" : 1.7976894783391937E308, \"myInt\" : 9223371743723257855, \"myNull\" : null, \"myString\" : \"wow\", \"myString2\" : \"incredible\", \"myVec\" : [ 99, \"wow\" ] }").isEqualTo( 995 FlexBuffers.getRoot(b.getBuffer()).toString()); 996 } 997 testFlexBuferEmpty()998 @org.junit.Test public void testFlexBuferEmpty() { 999 FlexBuffers.Blob blob = FlexBuffers.Blob.empty(); 1000 FlexBuffers.Map ary = FlexBuffers.Map.empty(); 1001 FlexBuffers.Vector map = FlexBuffers.Vector.empty(); 1002 FlexBuffers.TypedVector typedAry = FlexBuffers.TypedVector.empty(); 1003 assertThat(blob.size()).isEqualTo(0); 1004 assertThat(map.size()).isEqualTo(0); 1005 assertThat(ary.size()).isEqualTo(0); 1006 assertThat(typedAry.size()).isEqualTo(0); 1007 } 1008 testHashMapToMap()1009 @org.junit.Test public void testHashMapToMap() { 1010 int entriesCount = 12; 1011 1012 HashMap<String, String> source = new HashMap<>(); 1013 for (int i = 0; i < entriesCount; i++) { 1014 source.put("foo_param_" + i, "foo_value_" + i); 1015 } 1016 1017 FlexBuffersBuilder builder = new FlexBuffersBuilder(1000); 1018 int mapStart = builder.startMap(); 1019 for (Map.Entry<String, String> entry : source.entrySet()) { 1020 builder.putString(entry.getKey(), entry.getValue()); 1021 } 1022 builder.endMap(null, mapStart); 1023 ByteBuffer bb = builder.finish(); 1024 bb.rewind(); 1025 1026 FlexBuffers.Reference rootReference = FlexBuffers.getRoot(bb); 1027 1028 assertThat(rootReference.isMap()).isTrue(); 1029 1030 FlexBuffers.Map flexMap = rootReference.asMap(); 1031 1032 FlexBuffers.KeyVector keys = flexMap.keys(); 1033 FlexBuffers.Vector values = flexMap.values(); 1034 1035 assertThat(entriesCount).isEqualTo(keys.size()); 1036 assertThat(entriesCount).isEqualTo(values.size()); 1037 1038 HashMap<String, String> result = new HashMap<>(); 1039 for (int i = 0; i < keys.size(); i++) { 1040 result.put(keys.get(i).toString(), values.get(i).asString()); 1041 } 1042 1043 assertThat(source).isEqualTo(result); 1044 } 1045 testBuilderGrowth()1046 @org.junit.Test public void testBuilderGrowth() { 1047 FlexBuffersBuilder builder = new FlexBuffersBuilder(); 1048 String someString = "This is a small string"; 1049 builder.putString(someString); 1050 ByteBuffer b = builder.finish(); 1051 assertThat(someString).isEqualTo(FlexBuffers.getRoot(b).asString()); 1052 1053 FlexBuffersBuilder failBuilder = new FlexBuffersBuilder(ByteBuffer.allocate(1)); 1054 failBuilder.putString(someString); 1055 } 1056 1057 @org.junit.Test testFlexBuffersUtf8Map()1058 public void testFlexBuffersUtf8Map() { 1059 FlexBuffersBuilder builder = new FlexBuffersBuilder(ByteBuffer.allocate(512), 1060 FlexBuffersBuilder.BUILDER_FLAG_SHARE_KEYS_AND_STRINGS); 1061 1062 String key0 = "�� face1"; 1063 String key1 = "�� face2"; 1064 String key2 = "�� face3"; 1065 String key3 = "trademark ®"; 1066 String key4 = "€ euro"; 1067 String utf8keys[] = { "�� face1", "�� face2", "�� face3", "trademark ®", "€ euro"}; 1068 1069 int map = builder.startMap(); 1070 1071 for (int i=0; i< utf8keys.length; i++) { 1072 builder.putString(utf8keys[i], utf8keys[i]); // Testing key and string reuse. 1073 } 1074 builder.endMap(null, map); 1075 builder.finish(); 1076 1077 FlexBuffers.Map m = FlexBuffers.getRoot(builder.getBuffer()).asMap(); 1078 1079 assertThat(m.size()).isEqualTo(5); 1080 1081 KeyVector kv = m.keys(); 1082 for (int i=0; i< utf8keys.length; i++) { 1083 assertThat(kv.get(i).toString()).isEqualTo(m.get(i).asString()); 1084 } 1085 1086 assertThat(m.get(key0).asString()).isEqualTo(utf8keys[0]); 1087 assertThat(m.get(key1).asString()).isEqualTo(utf8keys[1]); 1088 assertThat(m.get(key2).asString()).isEqualTo(utf8keys[2]); 1089 assertThat(m.get(key3).asString()).isEqualTo(utf8keys[3]); 1090 assertThat(m.get(key4).asString()).isEqualTo(utf8keys[4]); 1091 } 1092 testFlexBuffersMapLookup()1093 @org.junit.Test public void testFlexBuffersMapLookup() { 1094 FlexBuffersBuilder builder = new FlexBuffersBuilder(ByteBuffer.allocate(512), 1095 FlexBuffersBuilder.BUILDER_FLAG_SHARE_KEYS_AND_STRINGS); 1096 1097 String key0 = "123"; 1098 String key1 = "1234"; 1099 String key2 = "12345"; 1100 String[] keys = new String[]{key0, key1, key2}; 1101 1102 int map = builder.startMap(); 1103 1104 for (int i=0; i< keys.length; i++) { 1105 builder.putString(keys[i], keys[i]); // Testing key and string reuse. 1106 } 1107 builder.endMap(null, map); 1108 builder.finish(); 1109 1110 FlexBuffers.Map m = FlexBuffers.getRoot(builder.getBuffer()).asMap(); 1111 for (int i=0; i< keys.length; i++) { 1112 assertThat(m.get(keys[i]).asString()).isEqualTo(keys[i]); 1113 assertThat(m.get(keys[i].getBytes(StandardCharsets.UTF_8)).asString()).isEqualTo(keys[i]); 1114 } 1115 } 1116 TestDictionaryLookup()1117 @org.junit.Test public void TestDictionaryLookup() { 1118 FlatBufferBuilder fbb = new FlatBufferBuilder(16); 1119 int lfIndex = LongFloatEntry.createLongFloatEntry(fbb, 0, 99); 1120 int vectorEntriesIdx = LongFloatMap.createEntriesVector(fbb, new int[] { lfIndex }); 1121 int rootIdx = LongFloatMap.createLongFloatMap(fbb, vectorEntriesIdx); 1122 1123 LongFloatMap.finishLongFloatMapBuffer(fbb, rootIdx); 1124 LongFloatMap map = LongFloatMap.getRootAsLongFloatMap(fbb.dataBuffer()); 1125 assertThat(map.entriesLength()).isEqualTo(1); 1126 1127 LongFloatEntry e = map.entries(0); 1128 assertThat(e.key()).isEqualTo(0L); 1129 assertThat(e.value()).isEqualTo(99.0f); 1130 1131 LongFloatEntry e2 = map.entriesByKey(0); 1132 assertThat(e2.key()).isEqualTo(0L); 1133 assertThat(e2.value()).isEqualTo(99.0f); 1134 } 1135 TestVectorOfBytes()1136 @org.junit.Test public void TestVectorOfBytes() { 1137 FlatBufferBuilder fbb = new FlatBufferBuilder(16); 1138 int str = fbb.createString("ByteMonster"); 1139 byte[] data = new byte[] {0, 1, 2, 3, 4, 5, 6, 7, 8, 9}; 1140 int offset = Monster.createInventoryVector(fbb, data); 1141 Monster.startMonster(fbb); 1142 Monster.addName(fbb, str); 1143 Monster.addInventory(fbb, offset); 1144 int monster1 = Monster.endMonster(fbb); 1145 Monster.finishMonsterBuffer(fbb, monster1); 1146 Monster monsterObject = Monster.getRootAsMonster(fbb.dataBuffer()); 1147 1148 assertThat(monsterObject.inventoryLength()).isEqualTo(data.length); 1149 assertThat((Integer) monsterObject.inventory(4)).isEqualTo((int) data[4]); 1150 assertThat(ByteBuffer.wrap(data)).isEqualTo(monsterObject.inventoryAsByteBuffer()); 1151 1152 fbb.clear(); 1153 ByteBuffer bb = ByteBuffer.wrap(data); 1154 offset = fbb.createByteVector(bb); 1155 str = fbb.createString("ByteMonster"); 1156 Monster.startMonster(fbb); 1157 Monster.addName(fbb, str); 1158 Monster.addInventory(fbb, offset); 1159 monster1 = Monster.endMonster(fbb); 1160 Monster.finishMonsterBuffer(fbb, monster1); 1161 Monster monsterObject2 = Monster.getRootAsMonster(fbb.dataBuffer()); 1162 1163 assertThat(monsterObject2.inventoryLength()).isEqualTo(data.length); 1164 for (int i = 0; i < data.length; i++) { 1165 assertThat((Integer) monsterObject2.inventory(i)).isEqualTo((int) bb.get(i)); 1166 } 1167 1168 fbb.clear(); 1169 offset = fbb.createByteVector(data, 3, 4); 1170 str = fbb.createString("ByteMonster"); 1171 Monster.startMonster(fbb); 1172 Monster.addName(fbb, str); 1173 Monster.addInventory(fbb, offset); 1174 monster1 = Monster.endMonster(fbb); 1175 Monster.finishMonsterBuffer(fbb, monster1); 1176 Monster monsterObject3 = Monster.getRootAsMonster(fbb.dataBuffer()); 1177 1178 assertThat(monsterObject3.inventoryLength()).isEqualTo(4); 1179 assertThat((Integer) monsterObject3.inventory(0)).isEqualTo((int) data[3]); 1180 1181 fbb.clear(); 1182 bb = ByteBuffer.wrap(data); 1183 offset = Monster.createInventoryVector(fbb, bb); 1184 str = fbb.createString("ByteMonster"); 1185 Monster.startMonster(fbb); 1186 Monster.addName(fbb, str); 1187 Monster.addInventory(fbb, offset); 1188 monster1 = Monster.endMonster(fbb); 1189 Monster.finishMonsterBuffer(fbb, monster1); 1190 Monster monsterObject4 = Monster.getRootAsMonster(fbb.dataBuffer()); 1191 1192 assertThat(monsterObject4.inventoryLength()).isEqualTo(data.length); 1193 assertThat((Integer) monsterObject4.inventory(8)).isEqualTo((int) 8); 1194 1195 fbb.clear(); 1196 byte[] largeData = new byte[1024]; 1197 offset = fbb.createByteVector(largeData); 1198 str = fbb.createString("ByteMonster"); 1199 Monster.startMonster(fbb); 1200 Monster.addName(fbb, str); 1201 Monster.addInventory(fbb, offset); 1202 monster1 = Monster.endMonster(fbb); 1203 Monster.finishMonsterBuffer(fbb, monster1); 1204 Monster monsterObject5 = Monster.getRootAsMonster(fbb.dataBuffer()); 1205 1206 assertThat(monsterObject5.inventoryLength()).isEqualTo(largeData.length); 1207 assertThat((Integer) monsterObject5.inventory(25)).isEqualTo((int) largeData[25]); 1208 1209 fbb.clear(); 1210 bb = ByteBuffer.wrap(largeData); 1211 bb.position(512); 1212 ByteBuffer bb2 = bb.slice(); 1213 assertThat(bb2.arrayOffset()).isEqualTo(512); 1214 offset = fbb.createByteVector(bb2); 1215 str = fbb.createString("ByteMonster"); 1216 Monster.startMonster(fbb); 1217 Monster.addName(fbb, str); 1218 Monster.addInventory(fbb, offset); 1219 monster1 = Monster.endMonster(fbb); 1220 Monster.finishMonsterBuffer(fbb, monster1); 1221 Monster monsterObject6 = Monster.getRootAsMonster(fbb.dataBuffer()); 1222 1223 assertThat(monsterObject6.inventoryLength()).isEqualTo(512); 1224 assertThat((Integer) monsterObject6.inventory(0)).isEqualTo((int) largeData[512]); 1225 1226 fbb.clear(); 1227 bb = ByteBuffer.wrap(largeData); 1228 bb.limit(256); 1229 offset = fbb.createByteVector(bb); 1230 str = fbb.createString("ByteMonster"); 1231 Monster.startMonster(fbb); 1232 Monster.addName(fbb, str); 1233 Monster.addInventory(fbb, offset); 1234 monster1 = Monster.endMonster(fbb); 1235 Monster.finishMonsterBuffer(fbb, monster1); 1236 Monster monsterObject7 = Monster.getRootAsMonster(fbb.dataBuffer()); 1237 1238 assertThat(monsterObject7.inventoryLength()).isEqualTo(256); 1239 1240 fbb.clear(); 1241 bb = ByteBuffer.allocateDirect(2048); 1242 offset = fbb.createByteVector(bb); 1243 str = fbb.createString("ByteMonster"); 1244 Monster.startMonster(fbb); 1245 Monster.addName(fbb, str); 1246 Monster.addInventory(fbb, offset); 1247 monster1 = Monster.endMonster(fbb); 1248 Monster.finishMonsterBuffer(fbb, monster1); 1249 Monster monsterObject8 = Monster.getRootAsMonster(fbb.dataBuffer()); 1250 1251 assertThat(monsterObject8.inventoryLength()).isEqualTo(2048); 1252 } 1253 TestSharedStringPool()1254 @org.junit.Test public void TestSharedStringPool() { 1255 FlatBufferBuilder fb = new FlatBufferBuilder(1); 1256 String testString = "My string"; 1257 int offset = fb.createSharedString(testString); 1258 for (int i=0; i< 10; i++) { 1259 assertThat(offset).isEqualTo(fb.createSharedString(testString)); 1260 } 1261 } 1262 TestScalarOptional()1263 @org.junit.Test public void TestScalarOptional() { 1264 FlatBufferBuilder fbb = new FlatBufferBuilder(1); 1265 ScalarStuff.startScalarStuff(fbb); 1266 int pos = ScalarStuff.endScalarStuff(fbb); 1267 fbb.finish(pos); 1268 1269 ScalarStuff scalarStuff = ScalarStuff.getRootAsScalarStuff(fbb.dataBuffer()); 1270 assertThat(scalarStuff.justI8()).isEqualTo((byte)0); 1271 assertThat(scalarStuff.maybeI8()).isEqualTo((byte)0); 1272 assertThat(scalarStuff.defaultI8()).isEqualTo((byte)42); 1273 assertThat(scalarStuff.justU8()).isEqualTo(0); 1274 assertThat(scalarStuff.maybeU8()).isEqualTo(0); 1275 assertThat(scalarStuff.defaultU8()).isEqualTo(42); 1276 assertThat(scalarStuff.justI16()).isEqualTo((short)0); 1277 assertThat(scalarStuff.maybeI16()).isEqualTo((short)0); 1278 assertThat(scalarStuff.defaultI16()).isEqualTo((short)42); 1279 assertThat(scalarStuff.justU16()).isEqualTo(0); 1280 assertThat(scalarStuff.maybeU16()).isEqualTo(0); 1281 assertThat(scalarStuff.defaultU16()).isEqualTo(42); 1282 assertThat(scalarStuff.justI32()).isEqualTo(0); 1283 assertThat(scalarStuff.maybeI32()).isEqualTo(0); 1284 assertThat(scalarStuff.defaultI32()).isEqualTo(42); 1285 assertThat(scalarStuff.justU32()).isEqualTo(0L); 1286 assertThat(scalarStuff.maybeU32()).isEqualTo(0L); 1287 assertThat(scalarStuff.defaultU32()).isEqualTo(42L); 1288 assertThat(scalarStuff.justI64()).isEqualTo(0L); 1289 assertThat(scalarStuff.maybeI64()).isEqualTo(0L); 1290 assertThat(scalarStuff.defaultI64()).isEqualTo(42L); 1291 assertThat(scalarStuff.justU64()).isEqualTo(0L); 1292 assertThat(scalarStuff.maybeU64()).isEqualTo(0L); 1293 assertThat(scalarStuff.defaultU64()).isEqualTo(42L); 1294 assertThat(scalarStuff.justF32()).isEqualTo(0.0f); 1295 assertThat(scalarStuff.maybeF32()).isEqualTo(0f); 1296 assertThat(scalarStuff.defaultF32()).isEqualTo(42.0f); 1297 assertThat(scalarStuff.justF64()).isEqualTo(0.0); 1298 assertThat(scalarStuff.maybeF64()).isEqualTo(0.0); 1299 assertThat(scalarStuff.defaultF64()).isEqualTo(42.0); 1300 assertThat(scalarStuff.justBool()).isFalse(); 1301 assertThat(scalarStuff.maybeBool()).isFalse(); 1302 assertThat(scalarStuff.defaultBool()).isTrue(); 1303 assertThat(scalarStuff.justEnum()).isEqualTo(OptionalByte.None); 1304 assertThat(scalarStuff.maybeEnum()).isEqualTo(OptionalByte.None); 1305 assertThat(scalarStuff.defaultEnum()).isEqualTo(OptionalByte.One); 1306 1307 assertThat(scalarStuff.hasMaybeI8()).isFalse(); 1308 assertThat(scalarStuff.hasMaybeI16()).isFalse(); 1309 assertThat(scalarStuff.hasMaybeI32()).isFalse(); 1310 assertThat(scalarStuff.hasMaybeI64()).isFalse(); 1311 assertThat(scalarStuff.hasMaybeU8()).isFalse(); 1312 assertThat(scalarStuff.hasMaybeU16()).isFalse(); 1313 assertThat(scalarStuff.hasMaybeU32()).isFalse(); 1314 assertThat(scalarStuff.hasMaybeU64()).isFalse(); 1315 assertThat(scalarStuff.hasMaybeF32()).isFalse(); 1316 assertThat(scalarStuff.hasMaybeF64()).isFalse(); 1317 assertThat(scalarStuff.hasMaybeBool()).isFalse(); 1318 assertThat(scalarStuff.hasMaybeEnum()).isFalse(); 1319 1320 fbb.clear(); 1321 1322 ScalarStuff.startScalarStuff(fbb); 1323 ScalarStuff.addJustI8(fbb, (byte)5); 1324 ScalarStuff.addMaybeI8(fbb, (byte)5); 1325 ScalarStuff.addDefaultI8(fbb, (byte)5); 1326 ScalarStuff.addJustU8(fbb, 6); 1327 ScalarStuff.addMaybeU8(fbb, 6); 1328 ScalarStuff.addDefaultU8(fbb, 6); 1329 ScalarStuff.addJustI16(fbb, (short)7); 1330 ScalarStuff.addMaybeI16(fbb, (short)7); 1331 ScalarStuff.addDefaultI16(fbb, (short)7); 1332 ScalarStuff.addJustU16(fbb, 8); 1333 ScalarStuff.addMaybeU16(fbb, 8); 1334 ScalarStuff.addDefaultU16(fbb, 8); 1335 ScalarStuff.addJustI32(fbb, 9); 1336 ScalarStuff.addMaybeI32(fbb, 9); 1337 ScalarStuff.addDefaultI32(fbb, 9); 1338 ScalarStuff.addJustU32(fbb, (long)10); 1339 ScalarStuff.addMaybeU32(fbb, (long)10); 1340 ScalarStuff.addDefaultU32(fbb, (long)10); 1341 ScalarStuff.addJustI64(fbb, 11L); 1342 ScalarStuff.addMaybeI64(fbb, 11L); 1343 ScalarStuff.addDefaultI64(fbb, 11L); 1344 ScalarStuff.addJustU64(fbb, 12L); 1345 ScalarStuff.addMaybeU64(fbb, 12L); 1346 ScalarStuff.addDefaultU64(fbb, 12L); 1347 ScalarStuff.addJustF32(fbb, 13.0f); 1348 ScalarStuff.addMaybeF32(fbb, 13.0f); 1349 ScalarStuff.addDefaultF32(fbb, 13.0f); 1350 ScalarStuff.addJustF64(fbb, 14.0); 1351 ScalarStuff.addMaybeF64(fbb, 14.0); 1352 ScalarStuff.addDefaultF64(fbb, 14.0); 1353 ScalarStuff.addJustBool(fbb, true); 1354 ScalarStuff.addMaybeBool(fbb, true); 1355 ScalarStuff.addDefaultBool(fbb, true); 1356 ScalarStuff.addJustEnum(fbb, OptionalByte.Two); 1357 ScalarStuff.addMaybeEnum(fbb, OptionalByte.Two); 1358 ScalarStuff.addDefaultEnum(fbb, OptionalByte.Two); 1359 1360 pos = ScalarStuff.endScalarStuff(fbb); 1361 1362 fbb.finish(pos); 1363 1364 scalarStuff = ScalarStuff.getRootAsScalarStuff(fbb.dataBuffer()); 1365 1366 assertThat(scalarStuff.justI8()).isEqualTo((byte)5); 1367 assertThat(scalarStuff.maybeI8()).isEqualTo((byte)5); 1368 assertThat(scalarStuff.defaultI8()).isEqualTo((byte)5); 1369 assertThat(scalarStuff.justU8()).isEqualTo(6); 1370 assertThat(scalarStuff.maybeU8()).isEqualTo(6); 1371 assertThat(scalarStuff.defaultU8()).isEqualTo(6); 1372 assertThat(scalarStuff.justI16()).isEqualTo((short)7); 1373 assertThat(scalarStuff.maybeI16()).isEqualTo((short)7); 1374 assertThat(scalarStuff.defaultI16()).isEqualTo((short)7); 1375 assertThat(scalarStuff.justU16()).isEqualTo(8); 1376 assertThat(scalarStuff.maybeU16()).isEqualTo(8); 1377 assertThat(scalarStuff.defaultU16()).isEqualTo(8); 1378 assertThat(scalarStuff.justI32()).isEqualTo(9); 1379 assertThat(scalarStuff.maybeI32()).isEqualTo(9); 1380 assertThat(scalarStuff.defaultI32()).isEqualTo(9); 1381 assertThat(scalarStuff.justU32()).isEqualTo(10L); 1382 assertThat(scalarStuff.maybeU32()).isEqualTo(10L); 1383 assertThat(scalarStuff.defaultU32()).isEqualTo(10L); 1384 assertThat(scalarStuff.justI64()).isEqualTo(11L); 1385 assertThat(scalarStuff.maybeI64()).isEqualTo(11L); 1386 assertThat(scalarStuff.defaultI64()).isEqualTo(11L); 1387 assertThat(scalarStuff.justU64()).isEqualTo(12L); 1388 assertThat(scalarStuff.maybeU64()).isEqualTo(12L); 1389 assertThat(scalarStuff.defaultU64()).isEqualTo(12L); 1390 assertThat(scalarStuff.justF32()).isEqualTo(13.0f); 1391 assertThat(scalarStuff.maybeF32()).isEqualTo(13.0f); 1392 assertThat(scalarStuff.defaultF32()).isEqualTo(13.0f); 1393 assertThat(scalarStuff.justF64()).isEqualTo(14.0); 1394 assertThat(scalarStuff.maybeF64()).isEqualTo(14.0); 1395 assertThat(scalarStuff.defaultF64()).isEqualTo(14.0); 1396 assertThat(scalarStuff.justBool()).isTrue(); 1397 assertThat(scalarStuff.maybeBool()).isTrue(); 1398 assertThat(scalarStuff.defaultBool()).isTrue(); 1399 assertThat(scalarStuff.justEnum()).isEqualTo(OptionalByte.Two); 1400 assertThat(scalarStuff.maybeEnum()).isEqualTo(OptionalByte.Two); 1401 assertThat(scalarStuff.defaultEnum()).isEqualTo(OptionalByte.Two); 1402 1403 assertThat(scalarStuff.hasMaybeI8()).isTrue(); 1404 assertThat(scalarStuff.hasMaybeI16()).isTrue(); 1405 assertThat(scalarStuff.hasMaybeI32()).isTrue(); 1406 assertThat(scalarStuff.hasMaybeI64()).isTrue(); 1407 assertThat(scalarStuff.hasMaybeU8()).isTrue(); 1408 assertThat(scalarStuff.hasMaybeU16()).isTrue(); 1409 assertThat(scalarStuff.hasMaybeU32()).isTrue(); 1410 assertThat(scalarStuff.hasMaybeU64()).isTrue(); 1411 assertThat(scalarStuff.hasMaybeF32()).isTrue(); 1412 assertThat(scalarStuff.hasMaybeF64()).isTrue(); 1413 assertThat(scalarStuff.hasMaybeBool()).isTrue(); 1414 assertThat(scalarStuff.hasMaybeEnum()).isTrue(); 1415 } 1416 TestObject(MonsterT monster)1417 static void TestObject(MonsterT monster) { 1418 assertThat(monster.getHp()).isEqualTo((short) 80); 1419 // default 1420 assertThat(monster.getMana()).isEqualTo((short) 150); 1421 1422 assertThat(monster.getName()).isEqualTo("MyMonster"); 1423 assertThat(monster.getColor()).isEqualTo((Integer) Color.Blue); 1424 // monster.friendly() // can't access, deprecated 1425 1426 Vec3T pos = monster.getPos(); 1427 assertThat(pos.getX()).isEqualTo(1.0f); 1428 assertThat(pos.getY()).isEqualTo(2.0f); 1429 assertThat(pos.getZ()).isEqualTo(3.0f); 1430 assertThat(pos.getTest1()).isEqualTo(3.0); 1431 // issue: int != byte 1432 assertThat(pos.getTest2()).isEqualTo((int) Color.Green); 1433 TestT t = pos.getTest3(); 1434 assertThat(t.getA()).isEqualTo((short) 5); 1435 assertThat(t.getB()).isEqualTo((byte) 6); 1436 1437 assertThat(monster.getTest().getType()).isEqualTo((byte) Any.Monster); 1438 MonsterT monster2 = (MonsterT) monster.getTest().getValue(); 1439 assertThat(monster2 != null).isTrue(); 1440 assertThat(monster2.getName()).isEqualTo("Fred"); 1441 1442 int[] inv = monster.getInventory(); 1443 assertThat(inv.length).isEqualTo(5); 1444 int[] expInv = {0, 1, 2, 3, 4}; 1445 for (int i = 0; i < inv.length; i++) 1446 assertThat(expInv[i]).isEqualTo(inv[i]); 1447 1448 TestT[] test4 = monster.getTest4(); 1449 TestT test_0 = test4[0]; 1450 TestT test_1 = test4[1]; 1451 assertThat(test4.length).isEqualTo(2); 1452 assertThat(test_0.getA()).isEqualTo((short) 10); 1453 assertThat(test_0.getB()).isEqualTo((byte) 20); 1454 assertThat(test_1.getA()).isEqualTo((short) 30); 1455 assertThat(test_1.getB()).isEqualTo((byte) 40); 1456 1457 String[] testarrayofstring = monster.getTestarrayofstring(); 1458 assertThat(testarrayofstring.length).isEqualTo(2); 1459 assertThat(testarrayofstring[0]).isEqualTo("test1"); 1460 assertThat(testarrayofstring[1]).isEqualTo("test2"); 1461 1462 MonsterT[] testarrayoftables = monster.getTestarrayoftables(); 1463 assertThat(testarrayoftables.length).isEqualTo(0); 1464 1465 MonsterT enemy = monster.getEnemy(); 1466 assertThat(enemy != null).isTrue(); 1467 assertThat(enemy.getName()).isEqualTo("Fred"); 1468 1469 int[] testnestedflatbuffer = monster.getTestnestedflatbuffer(); 1470 assertThat(testnestedflatbuffer.length).isEqualTo(0); 1471 1472 assertThat(monster.getTestempty() == null).isTrue(); 1473 1474 assertThat(monster.getTestbool()).isTrue(); 1475 1476 boolean[] testarrayofbools = monster.getTestarrayofbools(); 1477 assertThat(testarrayofbools.length).isEqualTo(3); 1478 assertThat(testarrayofbools[0]).isTrue(); 1479 assertThat(testarrayofbools[1]).isFalse(); 1480 assertThat(testarrayofbools[2]).isTrue(); 1481 1482 assertThat(monster.getTestf()).isEqualTo(3.14159f); 1483 assertThat(monster.getTestf2()).isEqualTo(3.0f); 1484 assertThat(monster.getTestf3()).isEqualTo(0.0f); 1485 assertThat(monster.getTestf3()).isEqualTo(0.0f); 1486 1487 AbilityT[] testarrayofsortedstruct = monster.getTestarrayofsortedstruct(); 1488 assertThat(testarrayofsortedstruct.length).isEqualTo(3); 1489 assertThat(testarrayofsortedstruct[0].getId()).isEqualTo((long) 0); 1490 assertThat(testarrayofsortedstruct[1].getId()).isEqualTo((long) 1); 1491 assertThat(testarrayofsortedstruct[2].getId()).isEqualTo((long) 5); 1492 assertThat(testarrayofsortedstruct[0].getDistance()).isEqualTo((long) 45); 1493 assertThat(testarrayofsortedstruct[1].getDistance()).isEqualTo((long) 21); 1494 assertThat(testarrayofsortedstruct[2].getDistance()).isEqualTo((long) 12); 1495 1496 int[] flex = monster.getFlex(); 1497 assertThat(flex.length).isEqualTo(0); 1498 1499 long[] vectorOfLongs = monster.getVectorOfLongs(); 1500 assertThat(vectorOfLongs.length).isEqualTo(5); 1501 long l = 1; 1502 for (int i = 0; i < vectorOfLongs.length; i++) { 1503 assertThat(vectorOfLongs[i]).isEqualTo(l); 1504 l *= 100; 1505 } 1506 1507 double[] vectorOfDoubles = monster.getVectorOfDoubles(); 1508 assertThat(vectorOfDoubles.length).isEqualTo(3); 1509 assertThat(vectorOfDoubles[0]).isEqualTo(-1.7976931348623157E308); 1510 assertThat(vectorOfDoubles[1]).isEqualTo(0.0); 1511 assertThat(vectorOfDoubles[2]).isEqualTo(1.7976931348623157E308); 1512 1513 assertThat(monster.getParentNamespaceTest() == null).isTrue(); 1514 ReferrableT[] vectorOfReferrables = monster.getVectorOfReferrables(); 1515 assertThat(vectorOfReferrables.length).isEqualTo(0); 1516 1517 assertThat(monster.getSignedEnum()).isEqualTo((byte) -1); 1518 } 1519 TestPackUnpack(ByteBuffer bb)1520 static void TestPackUnpack(ByteBuffer bb) { 1521 Monster m = Monster.getRootAsMonster(bb); 1522 MonsterT mObject = m.unpack(); 1523 TestObject(mObject); 1524 FlatBufferBuilder fbb = new FlatBufferBuilder(); 1525 int monster = Monster.pack(fbb, mObject); 1526 Monster.finishMonsterBuffer(fbb, monster); 1527 TestBuffer(fbb.dataBuffer()); 1528 1529 byte[] bytes = mObject.serializeToBinary(); 1530 MonsterT newMonsterT = MonsterT.deserializeFromBinary(bytes); 1531 TestObject(newMonsterT); 1532 } 1533 } 1534