diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml
index 5b00ac62f28..2b7c06f50d9 100644
--- a/.github/workflows/build.yml
+++ b/.github/workflows/build.yml
@@ -358,8 +358,8 @@ jobs:
steps:
- uses: actions/checkout@v2
- name: test
- working-directory: tests
- run: bash JavaTest.sh
+ working-directory: java
+ run: mvn test
build-kotlin-macos:
name: Build Kotlin MacOS
diff --git a/.gitignore b/.gitignore
index 03a1889b4c7..08daee191a7 100644
--- a/.gitignore
+++ b/.gitignore
@@ -88,6 +88,7 @@ java/*.iml
.idea
*.iml
target
+java/target
**/*.pyc
build/VS2010/FlatBuffers.sdf
build/VS2010/FlatBuffers.opensdf
@@ -148,4 +149,4 @@ flatbuffers.pc
**/html/**
**/latex/**
# https://cmake.org/cmake/help/latest/module/FetchContent.html#variable:FETCHCONTENT_BASE_DIR
-_deps/
\ No newline at end of file
+_deps/
diff --git a/android/app/build.gradle b/android/app/build.gradle
index bf78fca2b3b..1b035bab4b8 100644
--- a/android/app/build.gradle
+++ b/android/app/build.gradle
@@ -21,7 +21,7 @@ android {
sourceSets {
main {
java {
- srcDir '../../java'
+ srcDir '../../java/src/main/java/'
}
}
}
diff --git a/pom.xml b/java/pom.xml
similarity index 85%
rename from pom.xml
rename to java/pom.xml
index 80d05c371a6..cb03ea521c4 100644
--- a/pom.xml
+++ b/java/pom.xml
@@ -37,6 +37,18 @@
HEAD
+
+ junit
+ junit
+ 4.13
+ test
+
+
+ com.google.truth
+ truth
+ 1.1.3
+ test
+
@@ -45,7 +57,21 @@
- java
+
+
+ maven-compiler-plugin
+
+ 8
+
+ **/LongEnum.java
+ MyGame/Example/MonsterStorageGrpc.java
+ MyGame/Example/StructOfStructs**
+ MyGame/OtherNameSpace/TableBT.java
+
+
+ 3.8.1
+
+
@@ -55,13 +81,6 @@
-
- maven-compiler-plugin
-
- 8
-
- 3.8.1
-
maven-surefire-plugin
diff --git a/java/com/google/flatbuffers/ArrayReadWriteBuf.java b/java/src/main/java/com/google/flatbuffers/ArrayReadWriteBuf.java
similarity index 100%
rename from java/com/google/flatbuffers/ArrayReadWriteBuf.java
rename to java/src/main/java/com/google/flatbuffers/ArrayReadWriteBuf.java
diff --git a/java/com/google/flatbuffers/BaseVector.java b/java/src/main/java/com/google/flatbuffers/BaseVector.java
similarity index 100%
rename from java/com/google/flatbuffers/BaseVector.java
rename to java/src/main/java/com/google/flatbuffers/BaseVector.java
diff --git a/java/com/google/flatbuffers/BooleanVector.java b/java/src/main/java/com/google/flatbuffers/BooleanVector.java
similarity index 100%
rename from java/com/google/flatbuffers/BooleanVector.java
rename to java/src/main/java/com/google/flatbuffers/BooleanVector.java
diff --git a/java/com/google/flatbuffers/ByteBufferReadWriteBuf.java b/java/src/main/java/com/google/flatbuffers/ByteBufferReadWriteBuf.java
similarity index 100%
rename from java/com/google/flatbuffers/ByteBufferReadWriteBuf.java
rename to java/src/main/java/com/google/flatbuffers/ByteBufferReadWriteBuf.java
diff --git a/java/com/google/flatbuffers/ByteBufferUtil.java b/java/src/main/java/com/google/flatbuffers/ByteBufferUtil.java
similarity index 100%
rename from java/com/google/flatbuffers/ByteBufferUtil.java
rename to java/src/main/java/com/google/flatbuffers/ByteBufferUtil.java
diff --git a/java/com/google/flatbuffers/ByteVector.java b/java/src/main/java/com/google/flatbuffers/ByteVector.java
similarity index 100%
rename from java/com/google/flatbuffers/ByteVector.java
rename to java/src/main/java/com/google/flatbuffers/ByteVector.java
diff --git a/java/com/google/flatbuffers/Constants.java b/java/src/main/java/com/google/flatbuffers/Constants.java
similarity index 100%
rename from java/com/google/flatbuffers/Constants.java
rename to java/src/main/java/com/google/flatbuffers/Constants.java
diff --git a/java/com/google/flatbuffers/DoubleVector.java b/java/src/main/java/com/google/flatbuffers/DoubleVector.java
similarity index 100%
rename from java/com/google/flatbuffers/DoubleVector.java
rename to java/src/main/java/com/google/flatbuffers/DoubleVector.java
diff --git a/java/com/google/flatbuffers/FlatBufferBuilder.java b/java/src/main/java/com/google/flatbuffers/FlatBufferBuilder.java
similarity index 100%
rename from java/com/google/flatbuffers/FlatBufferBuilder.java
rename to java/src/main/java/com/google/flatbuffers/FlatBufferBuilder.java
diff --git a/java/com/google/flatbuffers/FlexBuffers.java b/java/src/main/java/com/google/flatbuffers/FlexBuffers.java
similarity index 100%
rename from java/com/google/flatbuffers/FlexBuffers.java
rename to java/src/main/java/com/google/flatbuffers/FlexBuffers.java
diff --git a/java/com/google/flatbuffers/FlexBuffersBuilder.java b/java/src/main/java/com/google/flatbuffers/FlexBuffersBuilder.java
similarity index 100%
rename from java/com/google/flatbuffers/FlexBuffersBuilder.java
rename to java/src/main/java/com/google/flatbuffers/FlexBuffersBuilder.java
diff --git a/java/com/google/flatbuffers/FloatVector.java b/java/src/main/java/com/google/flatbuffers/FloatVector.java
similarity index 100%
rename from java/com/google/flatbuffers/FloatVector.java
rename to java/src/main/java/com/google/flatbuffers/FloatVector.java
diff --git a/java/com/google/flatbuffers/IntVector.java b/java/src/main/java/com/google/flatbuffers/IntVector.java
similarity index 100%
rename from java/com/google/flatbuffers/IntVector.java
rename to java/src/main/java/com/google/flatbuffers/IntVector.java
diff --git a/java/com/google/flatbuffers/LongVector.java b/java/src/main/java/com/google/flatbuffers/LongVector.java
similarity index 100%
rename from java/com/google/flatbuffers/LongVector.java
rename to java/src/main/java/com/google/flatbuffers/LongVector.java
diff --git a/java/com/google/flatbuffers/ReadBuf.java b/java/src/main/java/com/google/flatbuffers/ReadBuf.java
similarity index 100%
rename from java/com/google/flatbuffers/ReadBuf.java
rename to java/src/main/java/com/google/flatbuffers/ReadBuf.java
diff --git a/java/com/google/flatbuffers/ReadWriteBuf.java b/java/src/main/java/com/google/flatbuffers/ReadWriteBuf.java
similarity index 100%
rename from java/com/google/flatbuffers/ReadWriteBuf.java
rename to java/src/main/java/com/google/flatbuffers/ReadWriteBuf.java
diff --git a/java/com/google/flatbuffers/ShortVector.java b/java/src/main/java/com/google/flatbuffers/ShortVector.java
similarity index 100%
rename from java/com/google/flatbuffers/ShortVector.java
rename to java/src/main/java/com/google/flatbuffers/ShortVector.java
diff --git a/java/com/google/flatbuffers/StringVector.java b/java/src/main/java/com/google/flatbuffers/StringVector.java
similarity index 100%
rename from java/com/google/flatbuffers/StringVector.java
rename to java/src/main/java/com/google/flatbuffers/StringVector.java
diff --git a/java/com/google/flatbuffers/Struct.java b/java/src/main/java/com/google/flatbuffers/Struct.java
similarity index 100%
rename from java/com/google/flatbuffers/Struct.java
rename to java/src/main/java/com/google/flatbuffers/Struct.java
diff --git a/java/com/google/flatbuffers/Table.java b/java/src/main/java/com/google/flatbuffers/Table.java
similarity index 100%
rename from java/com/google/flatbuffers/Table.java
rename to java/src/main/java/com/google/flatbuffers/Table.java
diff --git a/java/com/google/flatbuffers/UnionVector.java b/java/src/main/java/com/google/flatbuffers/UnionVector.java
similarity index 100%
rename from java/com/google/flatbuffers/UnionVector.java
rename to java/src/main/java/com/google/flatbuffers/UnionVector.java
diff --git a/java/com/google/flatbuffers/Utf8.java b/java/src/main/java/com/google/flatbuffers/Utf8.java
similarity index 100%
rename from java/com/google/flatbuffers/Utf8.java
rename to java/src/main/java/com/google/flatbuffers/Utf8.java
diff --git a/java/com/google/flatbuffers/Utf8Old.java b/java/src/main/java/com/google/flatbuffers/Utf8Old.java
similarity index 100%
rename from java/com/google/flatbuffers/Utf8Old.java
rename to java/src/main/java/com/google/flatbuffers/Utf8Old.java
diff --git a/java/com/google/flatbuffers/Utf8Safe.java b/java/src/main/java/com/google/flatbuffers/Utf8Safe.java
similarity index 100%
rename from java/com/google/flatbuffers/Utf8Safe.java
rename to java/src/main/java/com/google/flatbuffers/Utf8Safe.java
diff --git a/java/src/test/java/DictionaryLookup b/java/src/test/java/DictionaryLookup
new file mode 120000
index 00000000000..231bcd8006c
--- /dev/null
+++ b/java/src/test/java/DictionaryLookup
@@ -0,0 +1 @@
+../../../../tests/DictionaryLookup
\ No newline at end of file
diff --git a/tests/JavaTest.java b/java/src/test/java/JavaTest.java
similarity index 51%
rename from tests/JavaTest.java
rename to java/src/test/java/JavaTest.java
index 24fcaaecdef..c392e040eb3 100644
--- a/tests/JavaTest.java
+++ b/java/src/test/java/JavaTest.java
@@ -1,11 +1,12 @@
import static com.google.flatbuffers.Constants.*;
+import static com.google.common.truth.Truth.assertThat;
import DictionaryLookup.*;
import MyGame.Example.*;
+import com.google.common.io.ByteStreams;
import optional_scalars.ScalarStuff;
import optional_scalars.OptionalByte;
-import MyGame.MonsterExtra;
import NamespaceA.*;
import NamespaceA.NamespaceB.*;
import com.google.flatbuffers.ByteBufferUtil;
@@ -23,15 +24,18 @@
import com.google.flatbuffers.FlexBuffers.KeyVector;
import java.io.*;
-import java.math.BigInteger;
import java.nio.ByteBuffer;
import java.nio.ByteOrder;
-import java.nio.CharBuffer;
import java.nio.channels.FileChannel;
import java.nio.charset.StandardCharsets;
import java.util.Arrays;
import java.util.HashMap;
import java.util.Map;
+import org.junit.Rule;
+import org.junit.rules.TemporaryFolder;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
/*
* Copyright 2014 Google Inc. All rights reserved.
@@ -49,151 +53,115 @@
* limitations under the License.
*/
+@RunWith(JUnit4.class)
+public class JavaTest {
+ @Rule
+ public TemporaryFolder tempFolder = new TemporaryFolder();
-class JavaTest {
- public static void main(String[] args) {
-
- // First, let's test reading a FlatBuffer generated by C++ code:
- // This file was generated from monsterdata_test.json
-
- byte[] data = null;
- File file = new File("monsterdata_test.mon");
- RandomAccessFile f = null;
- try {
- f = new RandomAccessFile(file, "r");
- data = new byte[(int)f.length()];
- f.readFully(data);
- f.close();
- } catch(java.io.IOException e) {
- System.out.println("FlatBuffers test: couldn't read file");
- return;
- }
-
- // Now test it:
-
- ByteBuffer bb = ByteBuffer.wrap(data);
- TestBuffer(bb);
-
- // Second, let's create a FlatBuffer from scratch in Java, and test it also.
- // We use an initial size of 1 to exercise the reallocation algorithm,
- // normally a size larger than the typical FlatBuffer you generate would be
- // better for performance.
- FlatBufferBuilder fbb = new FlatBufferBuilder(1);
-
- TestBuilderBasics(fbb, true);
- TestBuilderBasics(fbb, false);
-
- TestExtendedBuffer(fbb.dataBuffer().asReadOnlyBuffer());
-
- TestNamespaceNesting();
-
- TestNestedFlatBuffer();
-
- TestCreateByteVector();
-
- TestCreateUninitializedVector();
-
- TestByteBufferFactory();
-
- TestSizedInputStream();
-
- TestVectorOfUnions();
-
- TestFixedLengthArrays();
-
- TestFlexBuffers();
-
- TestVectorOfBytes();
-
- TestSharedStringPool();
-
- TestScalarOptional();
-
- TestPackUnpack(bb);
+ @org.junit.Test
+ public void mainTest() throws IOException {
+ // First, let's test reading a FlatBuffer generated by C++ code:
+ // This file was generated from monsterdata_test.json
+ byte[] data = ByteStreams.toByteArray(
+ JavaTest.class.getClassLoader().getResourceAsStream("monsterdata_test.mon"));
- TestDictionaryLookup();
+ // Now test it:
+ ByteBuffer bb = ByteBuffer.wrap(data);
+ TestBuffer(bb);
+ TestPackUnpack(bb);
+ }
- System.out.println("FlatBuffers test: completed successfully");
+ @org.junit.Test
+ public void testFlatBufferBuilder() {
+ // We use an initial size of 1 to exercise the reallocation algorithm,
+ // normally a size larger than the typical FlatBuffer you generate would be
+ // better for performance.
+ FlatBufferBuilder fbb = new FlatBufferBuilder(1);
+ TestBuilderBasics(fbb, true);
+ TestBuilderBasics(fbb, false);
+ TestExtendedBuffer(fbb.dataBuffer().asReadOnlyBuffer());
}
- static void TestEnums() {
- TestEq(Color.name(Color.Red), "Red");
- TestEq(Color.name(Color.Blue), "Blue");
- TestEq(Any.name(Any.NONE), "NONE");
- TestEq(Any.name(Any.Monster), "Monster");
+ @org.junit.Test
+ public void TestEnums() {
+ assertThat(Color.name(Color.Red)).isEqualTo("Red");
+ assertThat(Color.name(Color.Blue)).isEqualTo("Blue");
+ assertThat(Any.name(Any.NONE)).isEqualTo("NONE");
+ assertThat(Any.name(Any.Monster)).isEqualTo("Monster");
}
static void TestBuffer(ByteBuffer bb) {
- TestEq(Monster.MonsterBufferHasIdentifier(bb), true);
+ assertThat(Monster.MonsterBufferHasIdentifier(bb)).isEqualTo(true);
- Monster monster = Monster.getRootAsMonster(bb);
+ Monster monster = Monster.getRootAsMonster(bb);
- TestEq(monster.hp(), (short)80);
- TestEq(monster.mana(), (short)150); // default
+ assertThat(monster.hp()).isEqualTo((short) 80);
+ // default
+ assertThat(monster.mana()).isEqualTo((short) 150);
- TestEq(monster.name(), "MyMonster");
- // monster.friendly() // can't access, deprecated
+ assertThat(monster.name()).isEqualTo("MyMonster");
+ // monster.friendly() // can't access, deprecated
Vec3 pos = monster.pos();
- TestEq(pos.x(), 1.0f);
- TestEq(pos.y(), 2.0f);
- TestEq(pos.z(), 3.0f);
- TestEq(pos.test1(), 3.0);
- // issue: int != byte
- TestEq(pos.test2(), (int) Color.Green);
- Test t = pos.test3();
- TestEq(t.a(), (short)5);
- TestEq(t.b(), (byte)6);
-
- TestEq(monster.testType(), (byte)Any.Monster);
- Monster monster2 = new Monster();
- TestEq(monster.test(monster2) != null, true);
- TestEq(monster2.name(), "Fred");
-
- TestEq(monster.inventoryLength(), 5);
- int invsum = 0;
+ assertThat(pos.x()).isEqualTo(1.0f);
+ assertThat(pos.y()).isEqualTo(2.0f);
+ assertThat(pos.z()).isEqualTo(3.0f);
+ assertThat(pos.test1()).isEqualTo(3.0);
+ // issue: int != byte
+ assertThat(pos.test2()).isEqualTo((int) Color.Green);
+ Test t = pos.test3();
+ assertThat(t.a()).isEqualTo((short) 5);
+ assertThat(t.b()).isEqualTo((byte) 6);
+
+ assertThat(monster.testType()).isEqualTo((byte) Any.Monster);
+ Monster monster2 = new Monster();
+ assertThat(monster.test(monster2) != null).isTrue();
+ assertThat(monster2.name()).isEqualTo("Fred");
+
+ assertThat(monster.inventoryLength()).isEqualTo(5);
+ int invsum = 0;
for (int i = 0; i < monster.inventoryLength(); i++)
invsum += monster.inventory(i);
- TestEq(invsum, 10);
+ assertThat(invsum).isEqualTo(10);
- // Method using a vector access object:
+ // Method using a vector access object:
ByteVector inventoryVector = monster.inventoryVector();
- TestEq(inventoryVector.length(), 5);
- invsum = 0;
+ assertThat(inventoryVector.length()).isEqualTo(5);
+ invsum = 0;
for (int i = 0; i < inventoryVector.length(); i++)
invsum += inventoryVector.getAsUnsigned(i);
- TestEq(invsum, 10);
+ assertThat(invsum).isEqualTo(10);
- // Alternative way of accessing a vector:
+ // Alternative way of accessing a vector:
ByteBuffer ibb = monster.inventoryAsByteBuffer();
invsum = 0;
while (ibb.position() < ibb.limit())
invsum += ibb.get();
- TestEq(invsum, 10);
+ assertThat(invsum).isEqualTo(10);
- Test test_0 = monster.test4(0);
+ Test test_0 = monster.test4(0);
Test test_1 = monster.test4(1);
- TestEq(monster.test4Length(), 2);
- TestEq(test_0.a() + test_0.b() + test_1.a() + test_1.b(), 100);
+ assertThat(monster.test4Length()).isEqualTo(2);
+ assertThat(test_0.a() + test_0.b() + test_1.a() + test_1.b()).isEqualTo((Integer) 100);
- Test.Vector test4Vector = monster.test4Vector();
+ Test.Vector test4Vector = monster.test4Vector();
test_0 = test4Vector.get(0);
test_1 = test4Vector.get(1);
- TestEq(test4Vector.length(), 2);
- TestEq(test_0.a() + test_0.b() + test_1.a() + test_1.b(), 100);
+ assertThat(test4Vector.length()).isEqualTo(2);
+ assertThat(test_0.a() + test_0.b() + test_1.a() + test_1.b()).isEqualTo((Integer) 100);
- TestEq(monster.testarrayofstringLength(), 2);
- TestEq(monster.testarrayofstring(0),"test1");
- TestEq(monster.testarrayofstring(1),"test2");
+ assertThat(monster.testarrayofstringLength()).isEqualTo(2);
+ assertThat(monster.testarrayofstring(0)).isEqualTo("test1");
+ assertThat(monster.testarrayofstring(1)).isEqualTo("test2");
- // Method using a vector access object:
+ // Method using a vector access object:
StringVector testarrayofstringVector = monster.testarrayofstringVector();
- TestEq(testarrayofstringVector.length(), 2);
- TestEq(testarrayofstringVector.get(0),"test1");
- TestEq(testarrayofstringVector.get(1),"test2");
+ assertThat(testarrayofstringVector.length()).isEqualTo(2);
+ assertThat(testarrayofstringVector.get(0)).isEqualTo("test1");
+ assertThat(testarrayofstringVector.get(1)).isEqualTo("test2");
- TestEq(monster.testbool(), true);
+ assertThat(monster.testbool()).isEqualTo(true);
}
// this method checks additional fields not present in the binary buffer read from file
@@ -203,10 +171,11 @@ static void TestExtendedBuffer(ByteBuffer bb) {
Monster monster = Monster.getRootAsMonster(bb);
- TestEq(monster.testhashu32Fnv1(), Integer.MAX_VALUE + 1L);
+ assertThat(monster.testhashu32Fnv1()).isEqualTo((Integer.MAX_VALUE + 1L));
}
- static void TestNamespaceNesting() {
+
+ @org.junit.Test public void TestNamespaceNesting() {
// reference / manipulate these to verify compilation
FlatBufferBuilder fbb = new FlatBufferBuilder(1);
@@ -219,7 +188,7 @@ static void TestNamespaceNesting() {
int off = TableInFirstNS.endTableInFirstNS(fbb);
}
- static void TestNestedFlatBuffer() {
+ @org.junit.Test public void TestNestedFlatBuffer() {
final String nestedMonsterName = "NestedMonsterName";
final short nestedMonsterHp = 600;
final short nestedMonsterMana = 1024;
@@ -250,12 +219,12 @@ static void TestNestedFlatBuffer() {
Monster mons = Monster.getRootAsMonster(fbb2.dataBuffer());
Monster nestedMonster = mons.testnestedflatbufferAsMonster();
- TestEq(nestedMonsterMana, nestedMonster.mana());
- TestEq(nestedMonsterHp, nestedMonster.hp());
- TestEq(nestedMonsterName, nestedMonster.name());
+ assertThat(nestedMonsterMana).isEqualTo(nestedMonster.mana());
+ assertThat(nestedMonsterHp).isEqualTo(nestedMonster.hp());
+ assertThat(nestedMonsterName).isEqualTo(nestedMonster.name());
}
- static void TestCreateByteVector() {
+ @org.junit.Test public void TestCreateByteVector() {
FlatBufferBuilder fbb = new FlatBufferBuilder(16);
int str = fbb.createString("MyMonster");
byte[] inventory = new byte[] { 0, 1, 2, 3, 4 };
@@ -267,16 +236,17 @@ static void TestCreateByteVector() {
Monster.finishMonsterBuffer(fbb, monster1);
Monster monsterObject = Monster.getRootAsMonster(fbb.dataBuffer());
- TestEq(monsterObject.inventory(1), (int)inventory[1]);
- TestEq(monsterObject.inventoryLength(), inventory.length);
- ByteVector inventoryVector = monsterObject.inventoryVector();
- TestEq(inventoryVector.getAsUnsigned(1), (int)inventory[1]);
- TestEq(inventoryVector.length(), inventory.length);
+ assertThat((Integer) monsterObject.inventory(1)).isEqualTo((int)inventory[1]);
+ assertThat(monsterObject.inventoryLength()).isEqualTo(inventory.length);
+ ByteVector inventoryVector = monsterObject.inventoryVector();
+ assertThat(inventoryVector.getAsUnsigned(1)).isEqualTo((int)inventory[1]);
+ assertThat(inventoryVector.length()).isEqualTo(inventory.length);
- TestEq(ByteBuffer.wrap(inventory), monsterObject.inventoryAsByteBuffer());
+ assertThat(ByteBuffer.wrap(inventory)).isEqualTo(
+ monsterObject.inventoryAsByteBuffer());
}
- static void TestCreateUninitializedVector() {
+ @org.junit.Test public void TestCreateUninitializedVector() {
FlatBufferBuilder fbb = new FlatBufferBuilder(16);
int str = fbb.createString("MyMonster");
byte[] inventory = new byte[] { 0, 1, 2, 3, 4 };
@@ -292,21 +262,23 @@ static void TestCreateUninitializedVector() {
Monster.finishMonsterBuffer(fbb, monster1);
Monster monsterObject = Monster.getRootAsMonster(fbb.dataBuffer());
- TestEq(monsterObject.inventory(1), (int)inventory[1]);
- TestEq(monsterObject.inventoryLength(), inventory.length);
- ByteVector inventoryVector = monsterObject.inventoryVector();
- TestEq(inventoryVector.getAsUnsigned(1), (int)inventory[1]);
- TestEq(inventoryVector.length(), inventory.length);
- TestEq(ByteBuffer.wrap(inventory), monsterObject.inventoryAsByteBuffer());
+ assertThat((Integer) monsterObject.inventory(1)).isEqualTo((int)inventory[1]);
+ assertThat(monsterObject.inventoryLength()).isEqualTo(inventory.length);
+ ByteVector inventoryVector = monsterObject.inventoryVector();
+ assertThat(inventoryVector.getAsUnsigned(1)).isEqualTo((int)inventory[1]);
+ assertThat(inventoryVector.length()).isEqualTo(inventory.length);
+ assertThat(ByteBuffer.wrap(inventory)).isEqualTo(
+ monsterObject.inventoryAsByteBuffer());
}
- static void TestByteBufferFactory() {
+ @org.junit.Test public void TestByteBufferFactory() throws IOException {
+ File file = tempFolder.newFile("javatest.bin");
final class MappedByteBufferFactory extends FlatBufferBuilder.ByteBufferFactory {
@Override
public ByteBuffer newByteBuffer(int capacity) {
ByteBuffer bb;
try {
- RandomAccessFile f = new RandomAccessFile("javatest.bin", "rw");
+ RandomAccessFile f = new RandomAccessFile(file, "rw");
bb = f.getChannel().map(FileChannel.MapMode.READ_WRITE, 0, capacity).order(ByteOrder.LITTLE_ENDIAN);
f.close();
} catch(Throwable e) {
@@ -322,7 +294,7 @@ public ByteBuffer newByteBuffer(int capacity) {
TestBuilderBasics(fbb, false);
}
- static void TestSizedInputStream() {
+ @org.junit.Test public void TestSizedInputStream() {
// Test on default FlatBufferBuilder that uses HeapByteBuffer
FlatBufferBuilder fbb = new FlatBufferBuilder(1);
@@ -340,13 +312,13 @@ static void TestSizedInputStream() {
System.out.println("FlatBuffers test: couldn't read from InputStream");
return;
}
- TestEq((byte)currentVal, array[count]);
- count++;
+ assertThat((byte)currentVal).isEqualTo(array[count]);
+ count++;
}
- TestEq(count, array.length);
+ assertThat(count).isEqualTo(array.length);
}
- static void TestBuilderBasics(FlatBufferBuilder fbb, boolean sizePrefix) {
+ void TestBuilderBasics(FlatBufferBuilder fbb, boolean sizePrefix) {
int[] names = {fbb.createString("Frodo"), fbb.createString("Barney"), fbb.createString("Wilma")};
int[] off = new int[3];
Monster.startMonster(fbb);
@@ -409,7 +381,7 @@ static void TestBuilderBasics(FlatBufferBuilder fbb, boolean sizePrefix) {
try {
String filename = "monsterdata_java_wire" + (sizePrefix ? "_sp" : "") + ".mon";
- FileChannel fc = new FileOutputStream(filename).getChannel();
+ FileChannel fc = new FileOutputStream(tempFolder.newFile(filename)).getChannel();
fc.write(fbb.dataBuffer().duplicate());
fc.close();
} catch(java.io.IOException e) {
@@ -420,9 +392,9 @@ static void TestBuilderBasics(FlatBufferBuilder fbb, boolean sizePrefix) {
// Test it:
ByteBuffer dataBuffer = fbb.dataBuffer();
if (sizePrefix) {
- TestEq(ByteBufferUtil.getSizePrefix(dataBuffer) + SIZE_PREFIX_LENGTH,
- dataBuffer.remaining());
- dataBuffer = ByteBufferUtil.removeSizePrefix(dataBuffer);
+ assertThat(ByteBufferUtil.getSizePrefix(dataBuffer) + SIZE_PREFIX_LENGTH).isEqualTo(
+ dataBuffer.remaining());
+ dataBuffer = ByteBufferUtil.removeSizePrefix(dataBuffer);
}
TestExtendedBuffer(dataBuffer);
@@ -431,69 +403,67 @@ static void TestBuilderBasics(FlatBufferBuilder fbb, boolean sizePrefix) {
// (see Table.__string).
TestExtendedBuffer(dataBuffer.asReadOnlyBuffer());
- TestEnums();
-
//Attempt to mutate Monster fields and check whether the buffer has been mutated properly
// revert to original values after testing
Monster monster = Monster.getRootAsMonster(dataBuffer);
// mana is optional and does not exist in the buffer so the mutation should fail
// the mana field should retain its default value
- TestEq(monster.mutateMana((short)10), false);
- TestEq(monster.mana(), (short)150);
-
- // Accessing a vector of sorted by the key tables
- TestEq(monster.testarrayoftables(0).name(), "Barney");
- TestEq(monster.testarrayoftables(1).name(), "Frodo");
- TestEq(monster.testarrayoftables(2).name(), "Wilma");
- Monster.Vector testarrayoftablesVector = monster.testarrayoftablesVector();
- TestEq(testarrayoftablesVector.get(0).name(), "Barney");
- TestEq(testarrayoftablesVector.get(1).name(), "Frodo");
- TestEq(testarrayoftablesVector.get(2).name(), "Wilma");
-
- // Example of searching for a table by the key
- TestEq(monster.testarrayoftablesByKey("Frodo").name(), "Frodo");
- TestEq(monster.testarrayoftablesByKey("Barney").name(), "Barney");
- TestEq(monster.testarrayoftablesByKey("Wilma").name(), "Wilma");
- TestEq(testarrayoftablesVector.getByKey("Frodo").name(), "Frodo");
- TestEq(testarrayoftablesVector.getByKey("Barney").name(), "Barney");
- TestEq(testarrayoftablesVector.getByKey("Wilma").name(), "Wilma");
-
- // testType is an existing field and mutating it should succeed
- TestEq(monster.testType(), (byte)Any.Monster);
-
- //mutate the inventory vector
- TestEq(monster.mutateInventory(0, 1), true);
- TestEq(monster.mutateInventory(1, 2), true);
- TestEq(monster.mutateInventory(2, 3), true);
- TestEq(monster.mutateInventory(3, 4), true);
- TestEq(monster.mutateInventory(4, 5), true);
-
- for (int i = 0; i < monster.inventoryLength(); i++) {
- TestEq(monster.inventory(i), i + 1);
- }
+ assertThat(monster.mutateMana((short)10)).isFalse();
+ assertThat(monster.mana()).isEqualTo((short) 150);
+
+ // Accessing a vector of sorted by the key tables
+ assertThat(monster.testarrayoftables(0).name()).isEqualTo("Barney");
+ assertThat(monster.testarrayoftables(1).name()).isEqualTo("Frodo");
+ assertThat(monster.testarrayoftables(2).name()).isEqualTo("Wilma");
+ Monster.Vector testarrayoftablesVector = monster.testarrayoftablesVector();
+ assertThat(testarrayoftablesVector.get(0).name()).isEqualTo("Barney");
+ assertThat(testarrayoftablesVector.get(1).name()).isEqualTo("Frodo");
+ assertThat(testarrayoftablesVector.get(2).name()).isEqualTo("Wilma");
+
+ // Example of searching for a table by the key
+ assertThat(monster.testarrayoftablesByKey("Frodo").name()).isEqualTo("Frodo");
+ assertThat(monster.testarrayoftablesByKey("Barney").name()).isEqualTo("Barney");
+ assertThat(monster.testarrayoftablesByKey("Wilma").name()).isEqualTo("Wilma");
+ assertThat(testarrayoftablesVector.getByKey("Frodo").name()).isEqualTo("Frodo");
+ assertThat(testarrayoftablesVector.getByKey("Barney").name()).isEqualTo("Barney");
+ assertThat(testarrayoftablesVector.getByKey("Wilma").name()).isEqualTo("Wilma");
+
+ // testType is an existing field and mutating it should succeed
+ assertThat(monster.testType()).isEqualTo((byte) Any.Monster);
+
+ //mutate the inventory vector
+ assertThat(monster.mutateInventory(0, 1)).isTrue();
+ assertThat(monster.mutateInventory(1, 2)).isTrue();
+ assertThat(monster.mutateInventory(2, 3)).isTrue();
+ assertThat(monster.mutateInventory(3, 4)).isTrue();
+ assertThat(monster.mutateInventory(4, 5)).isTrue();
+
+ for (int i = 0; i < monster.inventoryLength(); i++) {
+ assertThat((Integer) monster.inventory(i)).isEqualTo(i + 1);
+ }
ByteVector inventoryVector = monster.inventoryVector();
for (int i = 0; i < inventoryVector.length(); i++) {
- TestEq((int)inventoryVector.get(i), i + 1);
+ assertThat((int)inventoryVector.get(i)).isEqualTo(i + 1);
}
//reverse mutation
- TestEq(monster.mutateInventory(0, 0), true);
- TestEq(monster.mutateInventory(1, 1), true);
- TestEq(monster.mutateInventory(2, 2), true);
- TestEq(monster.mutateInventory(3, 3), true);
- TestEq(monster.mutateInventory(4, 4), true);
-
- // get a struct field and edit one of its fields
- Vec3 pos = monster.pos();
- TestEq(pos.x(), 1.0f);
- pos.mutateX(55.0f);
- TestEq(pos.x(), 55.0f);
- pos.mutateX(1.0f);
- TestEq(pos.x(), 1.0f);
+ assertThat(monster.mutateInventory(0, 0)).isTrue();
+ assertThat(monster.mutateInventory(1, 1)).isTrue();
+ assertThat(monster.mutateInventory(2, 2)).isTrue();
+ assertThat(monster.mutateInventory(3, 3)).isTrue();
+ assertThat(monster.mutateInventory(4, 4)).isTrue();
+
+ // get a struct field and edit one of its fields
+ Vec3 pos = monster.pos();
+ assertThat(pos.x()).isEqualTo(1.0f);
+ pos.mutateX(55.0f);
+ assertThat(pos.x()).isEqualTo(55.0f);
+ pos.mutateX(1.0f);
+ assertThat(pos.x()).isEqualTo(1.0f);
}
- static void TestVectorOfUnions() {
+ @org.junit.Test public void TestVectorOfUnions() {
final FlatBufferBuilder fbb = new FlatBufferBuilder();
final int swordAttackDamage = 1;
@@ -521,18 +491,19 @@ static void TestVectorOfUnions() {
ByteVector charactersTypeByteVector = movie.charactersTypeVector();
UnionVector charactersVector = movie.charactersVector();
- TestEq(movie.charactersTypeLength(), characterTypeVector.length);
- TestEq(charactersTypeByteVector.length(), characterTypeVector.length);
- TestEq(movie.charactersLength(), characterVector.length);
- TestEq(charactersVector.length(), characterVector.length);
+ assertThat(movie.charactersTypeLength()).isEqualTo(characterTypeVector.length);
+ assertThat(charactersTypeByteVector.length()).isEqualTo(characterTypeVector.length);
+ assertThat(movie.charactersLength()).isEqualTo(characterVector.length);
+ assertThat(charactersVector.length()).isEqualTo(characterVector.length);
- TestEq(movie.charactersType(0), characterTypeVector[0]);
- TestEq(charactersTypeByteVector.get(0), characterTypeVector[0]);
+ assertThat((Byte) movie.charactersType(0)).isEqualTo(characterTypeVector[0]);
+ assertThat(charactersTypeByteVector.get(0)).isEqualTo(characterTypeVector[0]);
- TestEq(((Attacker)movie.characters(new Attacker(), 0)).swordAttackDamage(), swordAttackDamage);
+ assertThat(((Attacker)movie.characters(new Attacker(), 0)).swordAttackDamage()).isEqualTo(
+ swordAttackDamage);
}
- static void TestFixedLengthArrays() {
+ @org.junit.Test public void TestFixedLengthArrays() {
FlatBufferBuilder builder = new FlatBufferBuilder(0);
float a;
@@ -579,29 +550,30 @@ static void TestFixedLengthArrays() {
ArrayTable table = ArrayTable.getRootAsArrayTable(builder.dataBuffer());
NestedStruct nested = new NestedStruct();
- TestEq(table.a().a(), 0.5f);
- for (int i = 0; i < 15; i++) TestEq(table.a().b(i), i);
- TestEq(table.a().c(), (byte)1);
- TestEq(table.a().d(nested, 0).a(0), 1);
- TestEq(table.a().d(nested, 0).a(1), 2);
- TestEq(table.a().d(nested, 1).a(0), 3);
- TestEq(table.a().d(nested, 1).a(1), 4);
- TestEq(table.a().d(nested, 0).b(), TestEnum.B);
- TestEq(table.a().d(nested, 1).b(), TestEnum.C);
- TestEq(table.a().d(nested, 0).c(0), TestEnum.A);
- TestEq(table.a().d(nested, 0).c(1), TestEnum.B);
- TestEq(table.a().d(nested, 1).c(0), TestEnum.C);
- TestEq(table.a().d(nested, 1).c(1), TestEnum.B);
- TestEq(table.a().d(nested, 0).d(0), (long)-1);
- TestEq(table.a().d(nested, 0).d(1), (long)1);
- TestEq(table.a().d(nested, 1).d(0), (long)-2);
- TestEq(table.a().d(nested, 1).d(1), (long)2);
- TestEq(table.a().e(), 2);
- TestEq(table.a().f(0), (long)-1);
- TestEq(table.a().f(1), (long)1);
+ assertThat(table.a().a()).isEqualTo(0.5f);
+ for (int i = 0; i < 15; i++)
+ assertThat(table.a().b(i)).isEqualTo(i);
+ assertThat(table.a().c()).isEqualTo((byte)1);
+ assertThat(table.a().d(nested, 0).a(0)).isEqualTo(1);
+ assertThat(table.a().d(nested, 0).a(1)).isEqualTo(2);
+ assertThat(table.a().d(nested, 1).a(0)).isEqualTo(3);
+ assertThat(table.a().d(nested, 1).a(1)).isEqualTo(4);
+ assertThat(table.a().d(nested, 0).b()).isEqualTo(TestEnum.B);
+ assertThat(table.a().d(nested, 1).b()).isEqualTo(TestEnum.C);
+ assertThat(table.a().d(nested, 0).c(0)).isEqualTo(TestEnum.A);
+ assertThat(table.a().d(nested, 0).c(1)).isEqualTo(TestEnum.B);
+ assertThat(table.a().d(nested, 1).c(0)).isEqualTo(TestEnum.C);
+ assertThat(table.a().d(nested, 1).c(1)).isEqualTo(TestEnum.B);
+ assertThat(table.a().d(nested, 0).d(0)).isEqualTo((long)-1);
+ assertThat(table.a().d(nested, 0).d(1)).isEqualTo((long)1);
+ assertThat(table.a().d(nested, 1).d(0)).isEqualTo((long)-2);
+ assertThat(table.a().d(nested, 1).d(1)).isEqualTo((long)2);
+ assertThat(table.a().e()).isEqualTo(2);
+ assertThat(table.a().f(0)).isEqualTo((long)-1);
+ assertThat(table.a().f(1)).isEqualTo((long)1);
}
- public static void testFlexBuffersTest() {
+ @org.junit.Test public void testFlexBuffersTest() {
FlexBuffersBuilder builder = new FlexBuffersBuilder(ByteBuffer.allocate(512),
FlexBuffersBuilder.BUILDER_FLAG_SHARE_KEYS_AND_STRINGS);
testFlexBuffersTest(builder);
@@ -611,7 +583,7 @@ public static void testFlexBuffersTest() {
builder.clear();
testFlexBuffersTest(builder);
int bufferLimit2 = ((ArrayReadWriteBuf) builder.getBuffer()).limit();
- TestEq(bufferLimit1, bufferLimit2);
+ assertThat(bufferLimit1).isEqualTo(bufferLimit2);
}
public static void testFlexBuffersTest(FlexBuffersBuilder builder) {
@@ -664,67 +636,76 @@ public static void testFlexBuffersTest(FlexBuffersBuilder builder) {
FlexBuffers.Map m = FlexBuffers.getRoot(builder.getBuffer()).asMap();
- TestEq(m.size(), 6);
-
- // test empty (an null)
- TestEq(m.get("no_key").asString(), ""); // empty if fail
- TestEq(m.get("no_key").asMap(), FlexBuffers.Map.empty()); // empty if fail
- TestEq(m.get("no_key").asKey(), FlexBuffers.Key.empty()); // empty if fail
- TestEq(m.get("no_key").asVector(), FlexBuffers.Vector.empty()); // empty if fail
- TestEq(m.get("no_key").asBlob(), FlexBuffers.Blob.empty()); // empty if fail
- assert(m.get("no_key").asVector().isEmpty()); // empty if fail
+ assertThat(m.size()).isEqualTo(6);
+
+ // test empty (an null)
+ // empty if fail
+ assertThat(m.get("no_key").asString()).isEqualTo("");
+ // empty if fail
+ assertThat(m.get("no_key").asMap()).isEqualTo(FlexBuffers.Map.empty());
+ // empty if fail
+ assertThat(m.get("no_key").asKey()).isEqualTo(FlexBuffers.Key.empty());
+ // empty if fail
+ assertThat(m.get("no_key").asVector()).isEqualTo(Vector.empty());
+ // empty if fail
+ assertThat(m.get("no_key").asBlob()).isEqualTo(FlexBuffers.Blob.empty());
+ assert(m.get("no_key").asVector().isEmpty()); // empty if fail
// testing "vec" field
FlexBuffers.Vector vec = m.get("vec").asVector();
- TestEq(vec.size(), 8);
- TestEq(vec.get(0).asLong(), (long) -100);
- TestEq(vec.get(1).asString(), "Fred");
- TestEq(vec.get(2).isBlob(), true);
- TestEq(vec.get(2).asBlob().size(), 1);
- TestEq(vec.get(2).asBlob().data().get(0), (byte) 77);
- TestEq(vec.get(3).isBoolean(), true); // Check if type is a bool
- TestEq(vec.get(3).asBoolean(), false); // Check if value is false
- TestEq(vec.get(4).asLong(), Long.MAX_VALUE);
- TestEq(vec.get(5).isMap(), true);
- TestEq(vec.get(5).asMap().get("test").asInt(), 200);
- TestEq(Float.compare((float)vec.get(6).asFloat(), 150.9f), 0);
- TestEq(Double.compare(vec.get(7).asFloat(), 150.9999998), 0);
- TestEq((long)0, (long)vec.get(1).asLong()); //conversion fail returns 0 as C++
-
- // bar vector
+ assertThat(vec.size()).isEqualTo(8);
+ assertThat(vec.get(0).asLong()).isEqualTo((long) -100);
+ assertThat(vec.get(1).asString()).isEqualTo("Fred");
+ assertThat(vec.get(2).isBlob()).isTrue();
+ assertThat(vec.get(2).asBlob().size()).isEqualTo(1);
+ assertThat(vec.get(2).asBlob().data().get(0)).isEqualTo((byte) 77);
+ // Check if type is a bool
+ assertThat(vec.get(3).isBoolean()).isTrue();
+ // Check if value is false
+ assertThat(vec.get(3).asBoolean()).isFalse();
+ assertThat(vec.get(4).asLong()).isEqualTo(Long.MAX_VALUE);
+ assertThat(vec.get(5).isMap()).isTrue();
+ assertThat(vec.get(5).asMap().get("test").asInt()).isEqualTo(200);
+ assertThat(Float.compare((float)vec.get(6).asFloat(), 150.9f)).isEqualTo(0);
+ assertThat(Double.compare(vec.get(7).asFloat(), 150.9999998)).isEqualTo(0);
+ //conversion fail returns 0 as C++
+ assertThat((long)0).isEqualTo((long)vec.get(1).asLong());
+
+ // bar vector
FlexBuffers.Vector tvec = m.get("bar").asVector();
- TestEq(tvec.size(), 3);
- TestEq(tvec.get(0).asInt(), 1);
- TestEq(tvec.get(1).asInt(), 2);
- TestEq(tvec.get(2).asInt(), 3);
- TestEq(((FlexBuffers.TypedVector) tvec).getElemType(), FlexBuffers.FBT_INT);
+ assertThat(tvec.size()).isEqualTo(3);
+ assertThat(tvec.get(0).asInt()).isEqualTo(1);
+ assertThat(tvec.get(1).asInt()).isEqualTo(2);
+ assertThat(tvec.get(2).asInt()).isEqualTo(3);
+ assertThat(((FlexBuffers.TypedVector) tvec).getElemType()).isEqualTo(FlexBuffers.FBT_INT);
- // bools vector
+ // bools vector
FlexBuffers.Vector bvec = m.get("bools").asVector();
- TestEq(bvec.size(), 4);
- TestEq(bvec.get(0).asBoolean(), true);
- TestEq(bvec.get(1).asBoolean(), false);
- TestEq(bvec.get(2).asBoolean(), true);
- TestEq(bvec.get(3).asBoolean(), false);
- TestEq(((FlexBuffers.TypedVector) bvec).getElemType(), FlexBuffers.FBT_BOOL);
+ assertThat(bvec.size()).isEqualTo(4);
+ assertThat(bvec.get(0).asBoolean()).isTrue();
+ assertThat(bvec.get(1).asBoolean()).isFalse();
+ assertThat(bvec.get(2).asBoolean()).isTrue();
+ assertThat(bvec.get(3).asBoolean()).isFalse();
+ assertThat(((FlexBuffers.TypedVector) bvec).getElemType()).isEqualTo(FlexBuffers.FBT_BOOL);
+ assertThat((float)m.get("foo").asFloat()).isEqualTo((float) 100);
+ assertThat(m.get("unknown").isNull()).isTrue();
- TestEq((float)m.get("foo").asFloat(), (float) 100);
- TestEq(m.get("unknown").isNull(), true);
-
- // mymap vector
+ // mymap vector
FlexBuffers.Map mymap = m.get("mymap").asMap();
- TestEq(mymap.keys().get(0), m.keys().get(0)); // These should be equal by pointer equality, since key and value are shared.
- TestEq(mymap.keys().get(0).toString(), "bar");
- TestEq(mymap.values().get(0).asString(), vec.get(1).asString());
- TestEq(mymap.get("int").asInt(), -120);
- TestEq((float)mymap.get("float").asFloat(), -123.0f);
- TestEq(Arrays.equals(mymap.get("blob").asBlob().getBytes(), new byte[]{ 65, 67 }), true);
- TestEq(mymap.get("blob").asBlob().toString(), "AC");
- TestEq(mymap.get("blob").toString(), "\"AC\"");
+ // These should be equal by pointer equality, since key and value are shared.
+ assertThat(mymap.keys().get(0)).isEqualTo(m.keys().get(0));
+ assertThat(mymap.keys().get(0).toString()).isEqualTo("bar");
+ assertThat(mymap.values().get(0).asString()).isEqualTo(vec.get(1).asString());
+ assertThat(mymap.get("int").asInt()).isEqualTo(-120);
+ assertThat((float)mymap.get("float").asFloat()).isEqualTo(-123.0f);
+ assertThat(Arrays.equals(mymap.get("blob").asBlob().getBytes(), new byte[]{ 65, 67 })).isEqualTo(
+ true);
+ assertThat(mymap.get("blob").asBlob().toString()).isEqualTo("AC");
+ assertThat(mymap.get("blob").toString()).isEqualTo("\"AC\"");
}
- public static void testFlexBufferVectorStrings() {
+ @org.junit.Test public void testFlexBufferVectorStrings() {
FlexBuffersBuilder builder = new FlexBuffersBuilder(ByteBuffer.allocate(10000000));
int size = 3000;
@@ -734,9 +715,9 @@ public static void testFlexBufferVectorStrings() {
}
String text = sb.toString();
- TestEq(text.length(), size);
+ assertThat(text.length()).isEqualTo(size);
- int pos = builder.startVector();
+ int pos = builder.startVector();
for (int i=0; i source = new HashMap<>();
@@ -1041,36 +1025,37 @@ public static void testHashMapToMap() {
FlexBuffers.Reference rootReference = FlexBuffers.getRoot(bb);
- TestEq(rootReference.isMap(), true);
+ assertThat(rootReference.isMap()).isTrue();
- FlexBuffers.Map flexMap = rootReference.asMap();
+ FlexBuffers.Map flexMap = rootReference.asMap();
FlexBuffers.KeyVector keys = flexMap.keys();
FlexBuffers.Vector values = flexMap.values();
- TestEq(entriesCount, keys.size());
- TestEq(entriesCount, values.size());
+ assertThat(entriesCount).isEqualTo(keys.size());
+ assertThat(entriesCount).isEqualTo(values.size());
- HashMap result = new HashMap<>();
+ HashMap result = new HashMap<>();
for (int i = 0; i < keys.size(); i++) {
result.put(keys.get(i).toString(), values.get(i).asString());
}
- TestEq(source, result);
+ assertThat(source).isEqualTo(result);
}
- public static void testBuilderGrowth() {
+ @org.junit.Test public void testBuilderGrowth() {
FlexBuffersBuilder builder = new FlexBuffersBuilder();
String someString = "This is a small string";
builder.putString(someString);
ByteBuffer b = builder.finish();
- TestEq(someString, FlexBuffers.getRoot(b).asString());
+ assertThat(someString).isEqualTo(FlexBuffers.getRoot(b).asString());
- FlexBuffersBuilder failBuilder = new FlexBuffersBuilder(ByteBuffer.allocate(1));
+ FlexBuffersBuilder failBuilder = new FlexBuffersBuilder(ByteBuffer.allocate(1));
failBuilder.putString(someString);
}
- public static void testFlexBuffersUtf8Map() {
+ @org.junit.Test
+ public void testFlexBuffersUtf8Map() {
FlexBuffersBuilder builder = new FlexBuffersBuilder(ByteBuffer.allocate(512),
FlexBuffersBuilder.BUILDER_FLAG_SHARE_KEYS_AND_STRINGS);
@@ -1091,21 +1076,21 @@ public static void testFlexBuffersUtf8Map() {
FlexBuffers.Map m = FlexBuffers.getRoot(builder.getBuffer()).asMap();
- TestEq(m.size(), 5);
+ assertThat(m.size()).isEqualTo(5);
- KeyVector kv = m.keys();
+ KeyVector kv = m.keys();
for (int i=0; i< utf8keys.length; i++) {
- TestEq(kv.get(i).toString(), m.get(i).asString());
+ assertThat(kv.get(i).toString()).isEqualTo(m.get(i).asString());
}
- TestEq(m.get(key0).asString(), utf8keys[0]);
- TestEq(m.get(key1).asString(), utf8keys[1]);
- TestEq(m.get(key2).asString(), utf8keys[2]);
- TestEq(m.get(key3).asString(), utf8keys[3]);
- TestEq(m.get(key4).asString(), utf8keys[4]);
+ assertThat(m.get(key0).asString()).isEqualTo(utf8keys[0]);
+ assertThat(m.get(key1).asString()).isEqualTo(utf8keys[1]);
+ assertThat(m.get(key2).asString()).isEqualTo(utf8keys[2]);
+ assertThat(m.get(key3).asString()).isEqualTo(utf8keys[3]);
+ assertThat(m.get(key4).asString()).isEqualTo(utf8keys[4]);
}
- public static void testFlexBuffersMapLookup() {
+ @org.junit.Test public void testFlexBuffersMapLookup() {
FlexBuffersBuilder builder = new FlexBuffersBuilder(ByteBuffer.allocate(512),
FlexBuffersBuilder.BUILDER_FLAG_SHARE_KEYS_AND_STRINGS);
@@ -1124,39 +1109,12 @@ public static void testFlexBuffersMapLookup() {
FlexBuffers.Map m = FlexBuffers.getRoot(builder.getBuffer()).asMap();
for (int i=0; i< keys.length; i++) {
- TestEq(m.get(keys[i]).asString(), keys[i]);
- TestEq(m.get(keys[i].getBytes(StandardCharsets.UTF_8)).asString(), keys[i]);
+ assertThat(m.get(keys[i]).asString()).isEqualTo(keys[i]);
+ assertThat(m.get(keys[i].getBytes(StandardCharsets.UTF_8)).asString()).isEqualTo(keys[i]);
}
}
- public static void TestFlexBuffers() {
- testSingleElementByte();
- testSingleElementShort();
- testSingleElementInt();
- testSingleElementLong();
- testSingleElementFloat();
- testSingleElementDouble();
- testSingleElementSmallString();
- testSingleElementBigString();
- testSingleElementBlob();
- testSingleElementLongBlob();
- testSingleElementVector();
- testSingleFixedTypeVector();
- testSingleElementUShort();
- testSingleElementUInt();
- testSingleElementUByte();
- testSingleElementMap();
- testFlexBuffersTest();
- testHashMapToMap();
- testFlexBuferEmpty();
- testFlexBufferVectorStrings();
- testDeprecatedTypedVectorString();
- testBuilderGrowth();
- testFlexBuffersUtf8Map();
- testFlexBuffersMapLookup();
- }
-
- static void TestDictionaryLookup() {
+ @org.junit.Test public void TestDictionaryLookup() {
FlatBufferBuilder fbb = new FlatBufferBuilder(16);
int lfIndex = LongFloatEntry.createLongFloatEntry(fbb, 0, 99);
int vectorEntriesIdx = LongFloatMap.createEntriesVector(fbb, new int[] { lfIndex });
@@ -1164,18 +1122,18 @@ static void TestDictionaryLookup() {
LongFloatMap.finishLongFloatMapBuffer(fbb, rootIdx);
LongFloatMap map = LongFloatMap.getRootAsLongFloatMap(fbb.dataBuffer());
- TestEq(map.entriesLength(), 1);
+ assertThat(map.entriesLength()).isEqualTo(1);
- LongFloatEntry e = map.entries(0);
- TestEq(e.key(), 0L);
- TestEq(e.value(), 99.0f);
+ LongFloatEntry e = map.entries(0);
+ assertThat(e.key()).isEqualTo(0L);
+ assertThat(e.value()).isEqualTo(99.0f);
- LongFloatEntry e2 = map.entriesByKey(0);
- TestEq(e2.key(), 0L);
- TestEq(e2.value(), 99.0f);
+ LongFloatEntry e2 = map.entriesByKey(0);
+ assertThat(e2.key()).isEqualTo(0L);
+ assertThat(e2.value()).isEqualTo(99.0f);
}
- static void TestVectorOfBytes() {
+ @org.junit.Test public void TestVectorOfBytes() {
FlatBufferBuilder fbb = new FlatBufferBuilder(16);
int str = fbb.createString("ByteMonster");
byte[] data = new byte[] {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
@@ -1187,11 +1145,11 @@ static void TestVectorOfBytes() {
Monster.finishMonsterBuffer(fbb, monster1);
Monster monsterObject = Monster.getRootAsMonster(fbb.dataBuffer());
- TestEq(monsterObject.inventoryLength(), data.length);
- TestEq(monsterObject.inventory(4), (int) data[4]);
- TestEq(ByteBuffer.wrap(data), monsterObject.inventoryAsByteBuffer());
+ assertThat(monsterObject.inventoryLength()).isEqualTo(data.length);
+ assertThat((Integer) monsterObject.inventory(4)).isEqualTo((int) data[4]);
+ assertThat(ByteBuffer.wrap(data)).isEqualTo(monsterObject.inventoryAsByteBuffer());
- fbb.clear();
+ fbb.clear();
ByteBuffer bb = ByteBuffer.wrap(data);
offset = fbb.createByteVector(bb);
str = fbb.createString("ByteMonster");
@@ -1202,10 +1160,10 @@ static void TestVectorOfBytes() {
Monster.finishMonsterBuffer(fbb, monster1);
Monster monsterObject2 = Monster.getRootAsMonster(fbb.dataBuffer());
- TestEq(monsterObject2.inventoryLength(), data.length);
- for (int i = 0; i < data.length; i++) {
- TestEq(monsterObject2.inventory(i), (int) bb.get(i));
- }
+ assertThat(monsterObject2.inventoryLength()).isEqualTo(data.length);
+ for (int i = 0; i < data.length; i++) {
+ assertThat((Integer) monsterObject2.inventory(i)).isEqualTo((int) bb.get(i));
+ }
fbb.clear();
offset = fbb.createByteVector(data, 3, 4);
@@ -1217,10 +1175,10 @@ static void TestVectorOfBytes() {
Monster.finishMonsterBuffer(fbb, monster1);
Monster monsterObject3 = Monster.getRootAsMonster(fbb.dataBuffer());
- TestEq(monsterObject3.inventoryLength(), 4);
- TestEq(monsterObject3.inventory(0), (int) data[3]);
+ assertThat(monsterObject3.inventoryLength()).isEqualTo(4);
+ assertThat((Integer) monsterObject3.inventory(0)).isEqualTo((int) data[3]);
- fbb.clear();
+ fbb.clear();
bb = ByteBuffer.wrap(data);
offset = Monster.createInventoryVector(fbb, bb);
str = fbb.createString("ByteMonster");
@@ -1231,10 +1189,10 @@ static void TestVectorOfBytes() {
Monster.finishMonsterBuffer(fbb, monster1);
Monster monsterObject4 = Monster.getRootAsMonster(fbb.dataBuffer());
- TestEq(monsterObject4.inventoryLength(), data.length);
- TestEq(monsterObject4.inventory(8), (int) 8);
+ assertThat(monsterObject4.inventoryLength()).isEqualTo(data.length);
+ assertThat((Integer) monsterObject4.inventory(8)).isEqualTo((int) 8);
- fbb.clear();
+ fbb.clear();
byte[] largeData = new byte[1024];
offset = fbb.createByteVector(largeData);
str = fbb.createString("ByteMonster");
@@ -1245,15 +1203,15 @@ static void TestVectorOfBytes() {
Monster.finishMonsterBuffer(fbb, monster1);
Monster monsterObject5 = Monster.getRootAsMonster(fbb.dataBuffer());
- TestEq(monsterObject5.inventoryLength(), largeData.length);
- TestEq(monsterObject5.inventory(25), (int) largeData[25]);
+ assertThat(monsterObject5.inventoryLength()).isEqualTo(largeData.length);
+ assertThat((Integer) monsterObject5.inventory(25)).isEqualTo((int) largeData[25]);
- fbb.clear();
+ fbb.clear();
bb = ByteBuffer.wrap(largeData);
bb.position(512);
ByteBuffer bb2 = bb.slice();
- TestEq(bb2.arrayOffset(), 512);
- offset = fbb.createByteVector(bb2);
+ assertThat(bb2.arrayOffset()).isEqualTo(512);
+ offset = fbb.createByteVector(bb2);
str = fbb.createString("ByteMonster");
Monster.startMonster(fbb);
Monster.addName(fbb, str);
@@ -1262,10 +1220,10 @@ static void TestVectorOfBytes() {
Monster.finishMonsterBuffer(fbb, monster1);
Monster monsterObject6 = Monster.getRootAsMonster(fbb.dataBuffer());
- TestEq(monsterObject6.inventoryLength(), 512);
- TestEq(monsterObject6.inventory(0), (int) largeData[512]);
+ assertThat(monsterObject6.inventoryLength()).isEqualTo(512);
+ assertThat((Integer) monsterObject6.inventory(0)).isEqualTo((int) largeData[512]);
- fbb.clear();
+ fbb.clear();
bb = ByteBuffer.wrap(largeData);
bb.limit(256);
offset = fbb.createByteVector(bb);
@@ -1277,9 +1235,9 @@ static void TestVectorOfBytes() {
Monster.finishMonsterBuffer(fbb, monster1);
Monster monsterObject7 = Monster.getRootAsMonster(fbb.dataBuffer());
- TestEq(monsterObject7.inventoryLength(), 256);
+ assertThat(monsterObject7.inventoryLength()).isEqualTo(256);
- fbb.clear();
+ fbb.clear();
bb = ByteBuffer.allocateDirect(2048);
offset = fbb.createByteVector(bb);
str = fbb.createString("ByteMonster");
@@ -1290,76 +1248,76 @@ static void TestVectorOfBytes() {
Monster.finishMonsterBuffer(fbb, monster1);
Monster monsterObject8 = Monster.getRootAsMonster(fbb.dataBuffer());
- TestEq(monsterObject8.inventoryLength(), 2048);
+ assertThat(monsterObject8.inventoryLength()).isEqualTo(2048);
}
- static void TestSharedStringPool() {
+ @org.junit.Test public void TestSharedStringPool() {
FlatBufferBuilder fb = new FlatBufferBuilder(1);
String testString = "My string";
int offset = fb.createSharedString(testString);
for (int i=0; i< 10; i++) {
- TestEq(offset, fb.createSharedString(testString));
+ assertThat(offset).isEqualTo(fb.createSharedString(testString));
}
}
- static void TestScalarOptional() {
+ @org.junit.Test public void TestScalarOptional() {
FlatBufferBuilder fbb = new FlatBufferBuilder(1);
ScalarStuff.startScalarStuff(fbb);
int pos = ScalarStuff.endScalarStuff(fbb);
fbb.finish(pos);
ScalarStuff scalarStuff = ScalarStuff.getRootAsScalarStuff(fbb.dataBuffer());
- TestEq(scalarStuff.justI8(), (byte)0);
- TestEq(scalarStuff.maybeI8(), (byte)0);
- TestEq(scalarStuff.defaultI8(), (byte)42);
- TestEq(scalarStuff.justU8(), 0);
- TestEq(scalarStuff.maybeU8(), 0);
- TestEq(scalarStuff.defaultU8(), 42);
- TestEq(scalarStuff.justI16(), (short)0);
- TestEq(scalarStuff.maybeI16(), (short)0);
- TestEq(scalarStuff.defaultI16(), (short)42);
- TestEq(scalarStuff.justU16(), 0);
- TestEq(scalarStuff.maybeU16(), 0);
- TestEq(scalarStuff.defaultU16(), 42);
- TestEq(scalarStuff.justI32(), 0);
- TestEq(scalarStuff.maybeI32(), 0);
- TestEq(scalarStuff.defaultI32(), 42);
- TestEq(scalarStuff.justU32(), 0L);
- TestEq(scalarStuff.maybeU32(), 0L);
- TestEq(scalarStuff.defaultU32(), 42L);
- TestEq(scalarStuff.justI64(), 0L);
- TestEq(scalarStuff.maybeI64(), 0L);
- TestEq(scalarStuff.defaultI64(), 42L);
- TestEq(scalarStuff.justU64(), 0L);
- TestEq(scalarStuff.maybeU64(), 0L);
- TestEq(scalarStuff.defaultU64(), 42L);
- TestEq(scalarStuff.justF32(), 0.0f);
- TestEq(scalarStuff.maybeF32(), 0f);
- TestEq(scalarStuff.defaultF32(), 42.0f);
- TestEq(scalarStuff.justF64(), 0.0);
- TestEq(scalarStuff.maybeF64(), 0.0);
- TestEq(scalarStuff.defaultF64(), 42.0);
- TestEq(scalarStuff.justBool(), false);
- TestEq(scalarStuff.maybeBool(), false);
- TestEq(scalarStuff.defaultBool(), true);
- TestEq(scalarStuff.justEnum(), OptionalByte.None);
- TestEq(scalarStuff.maybeEnum(), OptionalByte.None);
- TestEq(scalarStuff.defaultEnum(), OptionalByte.One);
-
- TestEq(scalarStuff.hasMaybeI8(), false);
- TestEq(scalarStuff.hasMaybeI16(), false);
- TestEq(scalarStuff.hasMaybeI32(), false);
- TestEq(scalarStuff.hasMaybeI64(), false);
- TestEq(scalarStuff.hasMaybeU8(), false);
- TestEq(scalarStuff.hasMaybeU16(), false);
- TestEq(scalarStuff.hasMaybeU32(), false);
- TestEq(scalarStuff.hasMaybeU64(), false);
- TestEq(scalarStuff.hasMaybeF32(), false);
- TestEq(scalarStuff.hasMaybeF64(), false);
- TestEq(scalarStuff.hasMaybeBool(), false);
- TestEq(scalarStuff.hasMaybeEnum(), false);
-
- fbb.clear();
+ assertThat(scalarStuff.justI8()).isEqualTo((byte)0);
+ assertThat(scalarStuff.maybeI8()).isEqualTo((byte)0);
+ assertThat(scalarStuff.defaultI8()).isEqualTo((byte)42);
+ assertThat(scalarStuff.justU8()).isEqualTo(0);
+ assertThat(scalarStuff.maybeU8()).isEqualTo(0);
+ assertThat(scalarStuff.defaultU8()).isEqualTo(42);
+ assertThat(scalarStuff.justI16()).isEqualTo((short)0);
+ assertThat(scalarStuff.maybeI16()).isEqualTo((short)0);
+ assertThat(scalarStuff.defaultI16()).isEqualTo((short)42);
+ assertThat(scalarStuff.justU16()).isEqualTo(0);
+ assertThat(scalarStuff.maybeU16()).isEqualTo(0);
+ assertThat(scalarStuff.defaultU16()).isEqualTo(42);
+ assertThat(scalarStuff.justI32()).isEqualTo(0);
+ assertThat(scalarStuff.maybeI32()).isEqualTo(0);
+ assertThat(scalarStuff.defaultI32()).isEqualTo(42);
+ assertThat(scalarStuff.justU32()).isEqualTo(0L);
+ assertThat(scalarStuff.maybeU32()).isEqualTo(0L);
+ assertThat(scalarStuff.defaultU32()).isEqualTo(42L);
+ assertThat(scalarStuff.justI64()).isEqualTo(0L);
+ assertThat(scalarStuff.maybeI64()).isEqualTo(0L);
+ assertThat(scalarStuff.defaultI64()).isEqualTo(42L);
+ assertThat(scalarStuff.justU64()).isEqualTo(0L);
+ assertThat(scalarStuff.maybeU64()).isEqualTo(0L);
+ assertThat(scalarStuff.defaultU64()).isEqualTo(42L);
+ assertThat(scalarStuff.justF32()).isEqualTo(0.0f);
+ assertThat(scalarStuff.maybeF32()).isEqualTo(0f);
+ assertThat(scalarStuff.defaultF32()).isEqualTo(42.0f);
+ assertThat(scalarStuff.justF64()).isEqualTo(0.0);
+ assertThat(scalarStuff.maybeF64()).isEqualTo(0.0);
+ assertThat(scalarStuff.defaultF64()).isEqualTo(42.0);
+ assertThat(scalarStuff.justBool()).isFalse();
+ assertThat(scalarStuff.maybeBool()).isFalse();
+ assertThat(scalarStuff.defaultBool()).isTrue();
+ assertThat(scalarStuff.justEnum()).isEqualTo(OptionalByte.None);
+ assertThat(scalarStuff.maybeEnum()).isEqualTo(OptionalByte.None);
+ assertThat(scalarStuff.defaultEnum()).isEqualTo(OptionalByte.One);
+
+ assertThat(scalarStuff.hasMaybeI8()).isFalse();
+ assertThat(scalarStuff.hasMaybeI16()).isFalse();
+ assertThat(scalarStuff.hasMaybeI32()).isFalse();
+ assertThat(scalarStuff.hasMaybeI64()).isFalse();
+ assertThat(scalarStuff.hasMaybeU8()).isFalse();
+ assertThat(scalarStuff.hasMaybeU16()).isFalse();
+ assertThat(scalarStuff.hasMaybeU32()).isFalse();
+ assertThat(scalarStuff.hasMaybeU64()).isFalse();
+ assertThat(scalarStuff.hasMaybeF32()).isFalse();
+ assertThat(scalarStuff.hasMaybeF64()).isFalse();
+ assertThat(scalarStuff.hasMaybeBool()).isFalse();
+ assertThat(scalarStuff.hasMaybeEnum()).isFalse();
+
+ fbb.clear();
ScalarStuff.startScalarStuff(fbb);
ScalarStuff.addJustI8(fbb, (byte)5);
@@ -1405,157 +1363,158 @@ static void TestScalarOptional() {
scalarStuff = ScalarStuff.getRootAsScalarStuff(fbb.dataBuffer());
- TestEq(scalarStuff.justI8(), (byte)5);
- TestEq(scalarStuff.maybeI8(), (byte)5);
- TestEq(scalarStuff.defaultI8(), (byte)5);
- TestEq(scalarStuff.justU8(), 6);
- TestEq(scalarStuff.maybeU8(), 6);
- TestEq(scalarStuff.defaultU8(), 6);
- TestEq(scalarStuff.justI16(), (short)7);
- TestEq(scalarStuff.maybeI16(), (short)7);
- TestEq(scalarStuff.defaultI16(), (short)7);
- TestEq(scalarStuff.justU16(), 8);
- TestEq(scalarStuff.maybeU16(), 8);
- TestEq(scalarStuff.defaultU16(), 8);
- TestEq(scalarStuff.justI32(), 9);
- TestEq(scalarStuff.maybeI32(), 9);
- TestEq(scalarStuff.defaultI32(), 9);
- TestEq(scalarStuff.justU32(), 10L);
- TestEq(scalarStuff.maybeU32(), 10L);
- TestEq(scalarStuff.defaultU32(), 10L);
- TestEq(scalarStuff.justI64(), 11L);
- TestEq(scalarStuff.maybeI64(), 11L);
- TestEq(scalarStuff.defaultI64(), 11L);
- TestEq(scalarStuff.justU64(), 12L);
- TestEq(scalarStuff.maybeU64(), 12L);
- TestEq(scalarStuff.defaultU64(), 12L);
- TestEq(scalarStuff.justF32(), 13.0f);
- TestEq(scalarStuff.maybeF32(), 13.0f);
- TestEq(scalarStuff.defaultF32(), 13.0f);
- TestEq(scalarStuff.justF64(), 14.0);
- TestEq(scalarStuff.maybeF64(), 14.0);
- TestEq(scalarStuff.defaultF64(), 14.0);
- TestEq(scalarStuff.justBool(), true);
- TestEq(scalarStuff.maybeBool(), true);
- TestEq(scalarStuff.defaultBool(), true);
- TestEq(scalarStuff.justEnum(), OptionalByte.Two);
- TestEq(scalarStuff.maybeEnum(), OptionalByte.Two);
- TestEq(scalarStuff.defaultEnum(), OptionalByte.Two);
-
- TestEq(scalarStuff.hasMaybeI8(), true);
- TestEq(scalarStuff.hasMaybeI16(), true);
- TestEq(scalarStuff.hasMaybeI32(), true);
- TestEq(scalarStuff.hasMaybeI64(), true);
- TestEq(scalarStuff.hasMaybeU8(), true);
- TestEq(scalarStuff.hasMaybeU16(), true);
- TestEq(scalarStuff.hasMaybeU32(), true);
- TestEq(scalarStuff.hasMaybeU64(), true);
- TestEq(scalarStuff.hasMaybeF32(), true);
- TestEq(scalarStuff.hasMaybeF64(), true);
- TestEq(scalarStuff.hasMaybeBool(), true);
- TestEq(scalarStuff.hasMaybeEnum(), true);
+ assertThat(scalarStuff.justI8()).isEqualTo((byte)5);
+ assertThat(scalarStuff.maybeI8()).isEqualTo((byte)5);
+ assertThat(scalarStuff.defaultI8()).isEqualTo((byte)5);
+ assertThat(scalarStuff.justU8()).isEqualTo(6);
+ assertThat(scalarStuff.maybeU8()).isEqualTo(6);
+ assertThat(scalarStuff.defaultU8()).isEqualTo(6);
+ assertThat(scalarStuff.justI16()).isEqualTo((short)7);
+ assertThat(scalarStuff.maybeI16()).isEqualTo((short)7);
+ assertThat(scalarStuff.defaultI16()).isEqualTo((short)7);
+ assertThat(scalarStuff.justU16()).isEqualTo(8);
+ assertThat(scalarStuff.maybeU16()).isEqualTo(8);
+ assertThat(scalarStuff.defaultU16()).isEqualTo(8);
+ assertThat(scalarStuff.justI32()).isEqualTo(9);
+ assertThat(scalarStuff.maybeI32()).isEqualTo(9);
+ assertThat(scalarStuff.defaultI32()).isEqualTo(9);
+ assertThat(scalarStuff.justU32()).isEqualTo(10L);
+ assertThat(scalarStuff.maybeU32()).isEqualTo(10L);
+ assertThat(scalarStuff.defaultU32()).isEqualTo(10L);
+ assertThat(scalarStuff.justI64()).isEqualTo(11L);
+ assertThat(scalarStuff.maybeI64()).isEqualTo(11L);
+ assertThat(scalarStuff.defaultI64()).isEqualTo(11L);
+ assertThat(scalarStuff.justU64()).isEqualTo(12L);
+ assertThat(scalarStuff.maybeU64()).isEqualTo(12L);
+ assertThat(scalarStuff.defaultU64()).isEqualTo(12L);
+ assertThat(scalarStuff.justF32()).isEqualTo(13.0f);
+ assertThat(scalarStuff.maybeF32()).isEqualTo(13.0f);
+ assertThat(scalarStuff.defaultF32()).isEqualTo(13.0f);
+ assertThat(scalarStuff.justF64()).isEqualTo(14.0);
+ assertThat(scalarStuff.maybeF64()).isEqualTo(14.0);
+ assertThat(scalarStuff.defaultF64()).isEqualTo(14.0);
+ assertThat(scalarStuff.justBool()).isTrue();
+ assertThat(scalarStuff.maybeBool()).isTrue();
+ assertThat(scalarStuff.defaultBool()).isTrue();
+ assertThat(scalarStuff.justEnum()).isEqualTo(OptionalByte.Two);
+ assertThat(scalarStuff.maybeEnum()).isEqualTo(OptionalByte.Two);
+ assertThat(scalarStuff.defaultEnum()).isEqualTo(OptionalByte.Two);
+
+ assertThat(scalarStuff.hasMaybeI8()).isTrue();
+ assertThat(scalarStuff.hasMaybeI16()).isTrue();
+ assertThat(scalarStuff.hasMaybeI32()).isTrue();
+ assertThat(scalarStuff.hasMaybeI64()).isTrue();
+ assertThat(scalarStuff.hasMaybeU8()).isTrue();
+ assertThat(scalarStuff.hasMaybeU16()).isTrue();
+ assertThat(scalarStuff.hasMaybeU32()).isTrue();
+ assertThat(scalarStuff.hasMaybeU64()).isTrue();
+ assertThat(scalarStuff.hasMaybeF32()).isTrue();
+ assertThat(scalarStuff.hasMaybeF64()).isTrue();
+ assertThat(scalarStuff.hasMaybeBool()).isTrue();
+ assertThat(scalarStuff.hasMaybeEnum()).isTrue();
}
static void TestObject(MonsterT monster) {
- TestEq(monster.getHp(), (short) 80);
- TestEq(monster.getMana(), (short) 150); // default
+ assertThat(monster.getHp()).isEqualTo((short) 80);
+ // default
+ assertThat(monster.getMana()).isEqualTo((short) 150);
- TestEq(monster.getName(), "MyMonster");
- TestEq(monster.getColor(), Color.Blue);
- // monster.friendly() // can't access, deprecated
+ assertThat(monster.getName()).isEqualTo("MyMonster");
+ assertThat(monster.getColor()).isEqualTo((Integer) Color.Blue);
+ // monster.friendly() // can't access, deprecated
Vec3T pos = monster.getPos();
- TestEq(pos.getX(), 1.0f);
- TestEq(pos.getY(), 2.0f);
- TestEq(pos.getZ(), 3.0f);
- TestEq(pos.getTest1(), 3.0);
- // issue: int != byte
- TestEq(pos.getTest2(), (int) Color.Green);
- TestT t = pos.getTest3();
- TestEq(t.getA(), (short) 5);
- TestEq(t.getB(), (byte) 6);
-
- TestEq(monster.getTest().getType(), (byte) Any.Monster);
- MonsterT monster2 = (MonsterT) monster.getTest().getValue();
- TestEq(monster2 != null, true);
- TestEq(monster2.getName(), "Fred");
-
- int[] inv = monster.getInventory();
- TestEq(inv.length, 5);
- int[] expInv = {0, 1, 2, 3, 4};
+ assertThat(pos.getX()).isEqualTo(1.0f);
+ assertThat(pos.getY()).isEqualTo(2.0f);
+ assertThat(pos.getZ()).isEqualTo(3.0f);
+ assertThat(pos.getTest1()).isEqualTo(3.0);
+ // issue: int != byte
+ assertThat(pos.getTest2()).isEqualTo((int) Color.Green);
+ TestT t = pos.getTest3();
+ assertThat(t.getA()).isEqualTo((short) 5);
+ assertThat(t.getB()).isEqualTo((byte) 6);
+
+ assertThat(monster.getTest().getType()).isEqualTo((byte) Any.Monster);
+ MonsterT monster2 = (MonsterT) monster.getTest().getValue();
+ assertThat(monster2 != null).isTrue();
+ assertThat(monster2.getName()).isEqualTo("Fred");
+
+ int[] inv = monster.getInventory();
+ assertThat(inv.length).isEqualTo(5);
+ int[] expInv = {0, 1, 2, 3, 4};
for (int i = 0; i < inv.length; i++)
- TestEq(expInv[i], inv[i]);
+ assertThat(expInv[i]).isEqualTo(inv[i]);
TestT[] test4 = monster.getTest4();
TestT test_0 = test4[0];
TestT test_1 = test4[1];
- TestEq(test4.length, 2);
- TestEq(test_0.getA(), (short) 10);
- TestEq(test_0.getB(), (byte) 20);
- TestEq(test_1.getA(), (short) 30);
- TestEq(test_1.getB(), (byte) 40);
-
- String[] testarrayofstring = monster.getTestarrayofstring();
- TestEq(testarrayofstring.length, 2);
- TestEq(testarrayofstring[0], "test1");
- TestEq(testarrayofstring[1], "test2");
-
- MonsterT[] testarrayoftables = monster.getTestarrayoftables();
- TestEq(testarrayoftables.length, 0);
-
- MonsterT enemy = monster.getEnemy();
- TestEq(enemy != null, true);
- TestEq(enemy.getName(), "Fred");
-
- int[] testnestedflatbuffer = monster.getTestnestedflatbuffer();
- TestEq(testnestedflatbuffer.length, 0);
-
- TestEq(monster.getTestempty() == null, true);
-
- TestEq(monster.getTestbool(), true);
-
- boolean[] testarrayofbools = monster.getTestarrayofbools();
- TestEq(testarrayofbools.length, 3);
- TestEq(testarrayofbools[0], true);
- TestEq(testarrayofbools[1], false);
- TestEq(testarrayofbools[2], true);
-
- TestEq(monster.getTestf(), 3.14159f);
- TestEq(monster.getTestf2(), 3.0f);
- TestEq(monster.getTestf3(), 0.0f);
- TestEq(monster.getTestf3(), 0.0f);
-
- AbilityT[] testarrayofsortedstruct = monster.getTestarrayofsortedstruct();
- TestEq(testarrayofsortedstruct.length, 3);
- TestEq(testarrayofsortedstruct[0].getId(), (long) 0);
- TestEq(testarrayofsortedstruct[1].getId(), (long) 1);
- TestEq(testarrayofsortedstruct[2].getId(), (long) 5);
- TestEq(testarrayofsortedstruct[0].getDistance(), (long) 45);
- TestEq(testarrayofsortedstruct[1].getDistance(), (long) 21);
- TestEq(testarrayofsortedstruct[2].getDistance(), (long) 12);
-
- int[] flex = monster.getFlex();
- TestEq(flex.length, 0);
-
- long[] vectorOfLongs = monster.getVectorOfLongs();
- TestEq(vectorOfLongs.length, 5);
- long l = 1;
+ assertThat(test4.length).isEqualTo(2);
+ assertThat(test_0.getA()).isEqualTo((short) 10);
+ assertThat(test_0.getB()).isEqualTo((byte) 20);
+ assertThat(test_1.getA()).isEqualTo((short) 30);
+ assertThat(test_1.getB()).isEqualTo((byte) 40);
+
+ String[] testarrayofstring = monster.getTestarrayofstring();
+ assertThat(testarrayofstring.length).isEqualTo(2);
+ assertThat(testarrayofstring[0]).isEqualTo("test1");
+ assertThat(testarrayofstring[1]).isEqualTo("test2");
+
+ MonsterT[] testarrayoftables = monster.getTestarrayoftables();
+ assertThat(testarrayoftables.length).isEqualTo(0);
+
+ MonsterT enemy = monster.getEnemy();
+ assertThat(enemy != null).isTrue();
+ assertThat(enemy.getName()).isEqualTo("Fred");
+
+ int[] testnestedflatbuffer = monster.getTestnestedflatbuffer();
+ assertThat(testnestedflatbuffer.length).isEqualTo(0);
+
+ assertThat(monster.getTestempty() == null).isTrue();
+
+ assertThat(monster.getTestbool()).isTrue();
+
+ boolean[] testarrayofbools = monster.getTestarrayofbools();
+ assertThat(testarrayofbools.length).isEqualTo(3);
+ assertThat(testarrayofbools[0]).isTrue();
+ assertThat(testarrayofbools[1]).isFalse();
+ assertThat(testarrayofbools[2]).isTrue();
+
+ assertThat(monster.getTestf()).isEqualTo(3.14159f);
+ assertThat(monster.getTestf2()).isEqualTo(3.0f);
+ assertThat(monster.getTestf3()).isEqualTo(0.0f);
+ assertThat(monster.getTestf3()).isEqualTo(0.0f);
+
+ AbilityT[] testarrayofsortedstruct = monster.getTestarrayofsortedstruct();
+ assertThat(testarrayofsortedstruct.length).isEqualTo(3);
+ assertThat(testarrayofsortedstruct[0].getId()).isEqualTo((long) 0);
+ assertThat(testarrayofsortedstruct[1].getId()).isEqualTo((long) 1);
+ assertThat(testarrayofsortedstruct[2].getId()).isEqualTo((long) 5);
+ assertThat(testarrayofsortedstruct[0].getDistance()).isEqualTo((long) 45);
+ assertThat(testarrayofsortedstruct[1].getDistance()).isEqualTo((long) 21);
+ assertThat(testarrayofsortedstruct[2].getDistance()).isEqualTo((long) 12);
+
+ int[] flex = monster.getFlex();
+ assertThat(flex.length).isEqualTo(0);
+
+ long[] vectorOfLongs = monster.getVectorOfLongs();
+ assertThat(vectorOfLongs.length).isEqualTo(5);
+ long l = 1;
for (int i = 0; i < vectorOfLongs.length; i++) {
- TestEq(vectorOfLongs[i], l);
- l *= 100;
+ assertThat(vectorOfLongs[i]).isEqualTo(l);
+ l *= 100;
}
double[] vectorOfDoubles = monster.getVectorOfDoubles();
- TestEq(vectorOfDoubles.length, 3);
- TestEq(vectorOfDoubles[0], -1.7976931348623157E308);
- TestEq(vectorOfDoubles[1], 0.0);
- TestEq(vectorOfDoubles[2], 1.7976931348623157E308);
+ assertThat(vectorOfDoubles.length).isEqualTo(3);
+ assertThat(vectorOfDoubles[0]).isEqualTo(-1.7976931348623157E308);
+ assertThat(vectorOfDoubles[1]).isEqualTo(0.0);
+ assertThat(vectorOfDoubles[2]).isEqualTo(1.7976931348623157E308);
- TestEq(monster.getParentNamespaceTest() == null, true);
- ReferrableT[] vectorOfReferrables = monster.getVectorOfReferrables();
- TestEq(vectorOfReferrables.length, 0);
+ assertThat(monster.getParentNamespaceTest() == null).isTrue();
+ ReferrableT[] vectorOfReferrables = monster.getVectorOfReferrables();
+ assertThat(vectorOfReferrables.length).isEqualTo(0);
- TestEq(monster.getSignedEnum(), (byte) -1);
+ assertThat(monster.getSignedEnum()).isEqualTo((byte) -1);
}
static void TestPackUnpack(ByteBuffer bb) {
@@ -1571,15 +1530,4 @@ static void TestPackUnpack(ByteBuffer bb) {
MonsterT newMonsterT = MonsterT.deserializeFromBinary(bytes);
TestObject(newMonsterT);
}
-
- static void TestEq(T a, T b) {
- if ((a == null && a != b) || (a != null && !a.equals(b))) {
- System.out.println("" + a.getClass().getName() + " " + b.getClass().getName());
- System.out.println("FlatBuffers test FAILED: \'" + a + "\' != \'" + b + "\'");
- new Throwable().printStackTrace();
- assert false;
- System.exit(1);
- }
- }
-
}
diff --git a/java/src/test/java/MyGame b/java/src/test/java/MyGame
new file mode 120000
index 00000000000..0ba918ed02d
--- /dev/null
+++ b/java/src/test/java/MyGame
@@ -0,0 +1 @@
+../../../../tests/MyGame
\ No newline at end of file
diff --git a/java/src/test/java/NamespaceA b/java/src/test/java/NamespaceA
new file mode 120000
index 00000000000..37a8d897e4c
--- /dev/null
+++ b/java/src/test/java/NamespaceA
@@ -0,0 +1 @@
+../../../../tests/namespace_test/NamespaceA
\ No newline at end of file
diff --git a/java/src/test/java/NamespaceC b/java/src/test/java/NamespaceC
new file mode 120000
index 00000000000..c1e44a8c94b
--- /dev/null
+++ b/java/src/test/java/NamespaceC
@@ -0,0 +1 @@
+../../../../tests/namespace_test/NamespaceC
\ No newline at end of file
diff --git a/java/src/test/java/optional_scalars b/java/src/test/java/optional_scalars
new file mode 120000
index 00000000000..44a35f96769
--- /dev/null
+++ b/java/src/test/java/optional_scalars
@@ -0,0 +1 @@
+../../../../tests/optional_scalars
\ No newline at end of file
diff --git a/java/src/test/java/union_vector b/java/src/test/java/union_vector
new file mode 120000
index 00000000000..cc82221f5de
--- /dev/null
+++ b/java/src/test/java/union_vector
@@ -0,0 +1 @@
+../../../../tests/union_vector
\ No newline at end of file
diff --git a/java/src/test/resources/monsterdata_test.mon b/java/src/test/resources/monsterdata_test.mon
new file mode 100644
index 00000000000..da0ed8698fc
Binary files /dev/null and b/java/src/test/resources/monsterdata_test.mon differ
diff --git a/kotlin/benchmark/src/jvmMain/java b/kotlin/benchmark/src/jvmMain/java
index 2260196d66c..fd62a87c52b 120000
--- a/kotlin/benchmark/src/jvmMain/java
+++ b/kotlin/benchmark/src/jvmMain/java
@@ -1 +1 @@
-../../../../java/
\ No newline at end of file
+../../../../java/src/main/java
\ No newline at end of file
diff --git a/tests/JavaTest.bat b/tests/JavaTest.bat
deleted file mode 100644
index 921815a1578..00000000000
--- a/tests/JavaTest.bat
+++ /dev/null
@@ -1,21 +0,0 @@
-@echo off
-rem Copyright 2014 Google Inc. All rights reserved.
-rem
-rem Licensed under the Apache License, Version 2.0 (the "License");
-rem you may not use this file except in compliance with the License.
-rem You may obtain a copy of the License at
-rem
-rem http://www.apache.org/licenses/LICENSE-2.0
-rem
-rem Unless required by applicable law or agreed to in writing, software
-rem distributed under the License is distributed on an "AS IS" BASIS,
-rem WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-rem See the License for the specific language governing permissions and
-rem limitations under the License.
-
-rem Compile then run the Java test.
-
-set batch_file_dir=%~d0%~p0
-
-javac -g -classpath %batch_file_dir%\..\java;%batch_file_dir%;%batch_file_dir%\namespace_test;%batch_file_dir%\union_vector JavaTest.java
-java -classpath %batch_file_dir%\..\java;%batch_file_dir%;%batch_file_dir%\namespace_test;%batch_file_dir%\union_vector JavaTest
diff --git a/tests/JavaTest.sh b/tests/JavaTest.sh
deleted file mode 100755
index 099447e8bb6..00000000000
--- a/tests/JavaTest.sh
+++ /dev/null
@@ -1,43 +0,0 @@
-#!/bin/bash
-#
-# Copyright 2014 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.
-
-set -o errexit
-
-echo Compile then run the Java test.
-
-java -version
-
-testdir=$(dirname $0)
-
-targetdir="${testdir}/target"
-
-if [[ -e "${targetdir}" ]]; then
- echo "cleaning target"
- rm -rf "${targetdir}"
-fi
-
-mkdir -v "${targetdir}"
-
-if ! find "${testdir}/../java" -type f -name "*.class" -delete; then
- echo "failed to clean .class files from java directory" >&2
- exit 1
-fi
-
-javac -d "${targetdir}" -classpath "${testdir}/optional_scalars:${testdir}/../java:${testdir}:${testdir}/namespace_test:${testdir}/union_vector" "${testdir}/JavaTest.java"
-
-(cd "${testdir}" && java -ea -classpath "${targetdir}" JavaTest )
-
-rm -rf "${targetdir}"