diff --git a/java/pom.xml b/java/pom.xml
new file mode 100644
index 0000000..34f154a
--- /dev/null
+++ b/java/pom.xml
@@ -0,0 +1,176 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
+  <modelVersion>4.0.0</modelVersion>
+  <groupId>com.google.flatbuffers</groupId>
+  <artifactId>flatbuffers-java</artifactId>
+  <version>2.0.8</version>
+  <packaging>bundle</packaging>
+  <name>FlatBuffers Java API</name>
+  <description>
+    Memory Efficient Serialization Library
+  </description>
+  <developers>
+    <developer>
+      <name>Wouter van Oortmerssen</name>
+    </developer>
+    <developer>
+      <name>Derek Bailey</name>
+      <email>dbaileychess@gmail.com</email>
+    </developer>
+  </developers>
+  <properties>
+    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
+  </properties>
+  <url>https://github.com/google/flatbuffers</url>
+  <licenses>
+    <license>
+      <name>Apache License V2.0</name>
+      <url>https://raw.githubusercontent.com/google/flatbuffers/master/LICENSE.txt</url>
+      <distribution>repo</distribution>
+    </license>
+  </licenses>
+  <scm>
+    <url>https://github.com/google/flatbuffers</url>
+    <connection>
+      scm:git:https://github.com/google/flatbuffers.git
+    </connection>
+    <tag>HEAD</tag>
+  </scm>
+  <dependencies>
+    <dependency>
+      <groupId>junit</groupId>
+      <artifactId>junit</artifactId>
+      <version>4.13.1</version>
+      <scope>test</scope>
+    </dependency>
+    <dependency>
+      <groupId>com.google.truth</groupId>
+      <artifactId>truth</artifactId>
+      <version>1.1.3</version>
+      <scope>test</scope>
+    </dependency>
+  </dependencies>
+  <distributionManagement>
+    <snapshotRepository>
+      <id>ossrh</id>
+      <url>https://oss.sonatype.org/content/repositories/snapshots</url>
+    </snapshotRepository>
+  </distributionManagement>
+  <build>
+    <plugins>
+    <plugin>
+      <artifactId>maven-compiler-plugin</artifactId>
+      <configuration>
+        <release>8</release>
+        <testExcludes>
+          <testExclude>**/LongEnum.java</testExclude>
+          <testExclude>MyGame/Example/MonsterStorageGrpc.java</testExclude>
+          <testExclude>MyGame/Example/StructOfStructs**</testExclude>
+          <testExclude>MyGame/OtherNameSpace/TableBT.java</testExclude>
+        </testExcludes>
+      </configuration>
+      <version>3.8.1</version>
+    </plugin>
+    </plugins>
+  </build>
+  <profiles>
+    <profile>
+      <id>jdk9</id>
+      <activation>
+        <jdk>[1.9,)</jdk>
+      </activation>
+      <build>
+        <plugins>
+          <plugin>
+            <artifactId>maven-surefire-plugin</artifactId>
+            <configuration>
+              <includes>
+                <include>**/*Test.java</include>
+              </includes>
+            </configuration>
+            <version>2.22.2</version>
+          </plugin>
+          <plugin>
+            <groupId>org.apache.maven.plugins</groupId>
+            <artifactId>maven-source-plugin</artifactId>
+            <version>3.2.1</version>
+            <executions>
+              <execution>
+                <id>attach-sources</id>
+                <goals>
+                  <goal>jar</goal>
+                </goals>
+              </execution>
+            </executions>
+          </plugin>
+          <plugin>
+            <groupId>org.apache.maven.plugins</groupId>
+            <artifactId>maven-javadoc-plugin</artifactId>
+            <version>3.3.0</version>
+            <configuration>
+              <additionalparam>-Xdoclint:none</additionalparam>
+              <additionalOptions>-Xdoclint:none</additionalOptions>
+            </configuration>
+            <executions>
+              <execution>
+                <id>attach-javadocs</id>
+                <goals>
+                  <goal>jar</goal>
+                </goals>
+              </execution>
+            </executions>
+          </plugin>
+          <plugin>
+            <groupId>org.apache.felix</groupId>
+            <artifactId>maven-bundle-plugin</artifactId>
+            <version>5.1.2</version>
+            <extensions>true</extensions>
+          </plugin>
+          <plugin>
+            <groupId>org.sonatype.plugins</groupId>
+            <artifactId>nexus-staging-maven-plugin</artifactId>
+            <version>1.6.8</version>
+            <extensions>true</extensions>
+            <configuration>
+              <serverId>ossrh</serverId>
+              <nexusUrl>https://oss.sonatype.org/</nexusUrl>
+              <autoReleaseAfterClose>true</autoReleaseAfterClose>
+            </configuration>
+          </plugin>
+          <plugin>
+            <groupId>org.apache.maven.plugins</groupId>
+            <artifactId>maven-gpg-plugin</artifactId>
+            <version>3.0.1</version>
+            <executions>
+              <execution>
+                <id>sign-artifacts</id>
+                <phase>verify</phase>
+                <goals>
+                  <goal>sign</goal>
+                </goals>
+                <configuration>
+                    <gpgArguments>
+                        <arg>--pinentry-mode</arg>
+                        <arg>loopback</arg>
+                    </gpgArguments>
+                </configuration>
+              </execution>
+            </executions>
+          </plugin>
+          <plugin>
+            <groupId>org.apache.maven.plugins</groupId>
+            <artifactId>maven-release-plugin</artifactId>
+            <version>2.5.3</version>
+            <configuration>
+              <autoVersionSubmodules>true</autoVersionSubmodules>
+              <useReleaseProfile>false</useReleaseProfile>
+              <releaseProfiles>release</releaseProfiles>
+              <goals>deploy</goals>
+            </configuration>
+          </plugin>
+        </plugins>
+      </build>
+    </profile>
+  </profiles>
+</project>
+
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 97%
rename from java/com/google/flatbuffers/Constants.java
rename to java/src/main/java/com/google/flatbuffers/Constants.java
index 0c0920f..b9cb8f2 100644
--- a/java/com/google/flatbuffers/Constants.java
+++ b/java/src/main/java/com/google/flatbuffers/Constants.java
@@ -46,7 +46,7 @@
     Changes to the Java implementation need to be sure to change
     the version here and in the code generator on every possible
     incompatible change */
-    public static void FLATBUFFERS_2_0_0() {}
+    public static void FLATBUFFERS_2_0_8() {}
 }
 
 /// @endcond
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 97%
rename from java/com/google/flatbuffers/FlexBuffersBuilder.java
rename to java/src/main/java/com/google/flatbuffers/FlexBuffersBuilder.java
index 7f41bb6..60ab535 100644
--- a/java/com/google/flatbuffers/FlexBuffersBuilder.java
+++ b/java/src/main/java/com/google/flatbuffers/FlexBuffersBuilder.java
@@ -174,6 +174,21 @@
     }
 
     /**
+     * Insert a null value into the buffer
+     */
+    public void putNull() {
+        putNull(null);
+    }
+
+    /**
+     * Insert a null value into the buffer
+     * @param key key used to store element in map
+     */
+    public void putNull(String key) {
+        stack.add(Value.nullValue(putKey(key)));
+    }
+
+    /**
      * Insert a single boolean into the buffer
      * @param val true or false
      */
@@ -451,7 +466,7 @@
     /**
      * Finishes a vector, but writing the information in the buffer
      * @param key   key used to store element in map
-     * @param start reference for begining of the vector. Returned by {@link startVector()}
+     * @param start reference for beginning of the vector. Returned by {@link startVector()}
      * @param typed boolean indicating whether vector is typed
      * @param fixed boolean indicating whether vector is fixed
      * @return      Reference to the vector
@@ -502,7 +517,9 @@
      * @return Value representing the created vector
      */
     private Value createVector(int key, int start, int length, boolean typed, boolean fixed, Value keys) {
-        assert (!fixed || typed); // typed=false, fixed=true combination is not supported.
+        if (fixed & !typed)
+            throw new UnsupportedOperationException("Untyped fixed vector is not supported");
+
         // Figure out smallest bit width we can store this vector with.
         int bitWidth = Math.max(WIDTH_8, widthUInBits(length));
         int prefixElems = 1;
@@ -602,7 +619,7 @@
     /**
      * Finishes a map, but writing the information in the buffer
      * @param key   key used to store element in map
-     * @param start reference for begining of the map. Returned by {@link startMap()}
+     * @param start reference for beginning of the map. Returned by {@link startMap()}
      * @return      Reference to the map
      */
     public int endMap(String key, int start) {
@@ -673,6 +690,10 @@
             this.iValue = Long.MIN_VALUE;
         }
 
+        static Value nullValue(int key) {
+            return new Value(key, FBT_NULL, WIDTH_8, 0);
+        }
+
         static Value bool(int key, boolean b) {
             return new Value(key, FBT_BOOL, WIDTH_8, b ? 1 : 0);
         }
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 0000000..231bcd8
--- /dev/null
+++ b/java/src/test/java/DictionaryLookup
@@ -0,0 +1 @@
+../../../../tests/DictionaryLookup
\ No newline at end of file
diff --git a/java/src/test/java/JavaTest.java b/java/src/test/java/JavaTest.java
new file mode 100644
index 0000000..c392e04
--- /dev/null
+++ b/java/src/test/java/JavaTest.java
@@ -0,0 +1,1533 @@
+
+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 NamespaceA.*;
+import NamespaceA.NamespaceB.*;
+import com.google.flatbuffers.ByteBufferUtil;
+import com.google.flatbuffers.ByteVector;
+import com.google.flatbuffers.FlatBufferBuilder;
+import com.google.flatbuffers.FlexBuffers;
+import com.google.flatbuffers.FlexBuffersBuilder;
+import com.google.flatbuffers.StringVector;
+import com.google.flatbuffers.UnionVector;
+
+import com.google.flatbuffers.FlexBuffers.FlexBufferException;
+import com.google.flatbuffers.FlexBuffers.Reference;
+import com.google.flatbuffers.FlexBuffers.Vector;
+import com.google.flatbuffers.ArrayReadWriteBuf;
+import com.google.flatbuffers.FlexBuffers.KeyVector;
+
+import java.io.*;
+import java.nio.ByteBuffer;
+import java.nio.ByteOrder;
+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.
+ *
+ * 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.
+ */
+
+@RunWith(JUnit4.class)
+public class JavaTest {
+
+    @Rule
+    public TemporaryFolder tempFolder = new TemporaryFolder();
+
+    @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"));
+
+      // Now test it:
+      ByteBuffer bb = ByteBuffer.wrap(data);
+      TestBuffer(bb);
+      TestPackUnpack(bb);
+    }
+
+    @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());
+    }
+
+    @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) {
+      assertThat(Monster.MonsterBufferHasIdentifier(bb)).isEqualTo(true);
+
+      Monster monster = Monster.getRootAsMonster(bb);
+
+      assertThat(monster.hp()).isEqualTo((short) 80);
+      // default
+      assertThat(monster.mana()).isEqualTo((short) 150);
+
+      assertThat(monster.name()).isEqualTo("MyMonster");
+      // monster.friendly() // can't access, deprecated
+
+        Vec3 pos = monster.pos();
+      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);
+      assertThat(invsum).isEqualTo(10);
+
+      // Method using a vector access object:
+        ByteVector inventoryVector = monster.inventoryVector();
+      assertThat(inventoryVector.length()).isEqualTo(5);
+      invsum = 0;
+        for (int i = 0; i < inventoryVector.length(); i++)
+            invsum += inventoryVector.getAsUnsigned(i);
+      assertThat(invsum).isEqualTo(10);
+
+      // Alternative way of accessing a vector:
+        ByteBuffer ibb = monster.inventoryAsByteBuffer();
+        invsum = 0;
+        while (ibb.position() < ibb.limit())
+            invsum += ibb.get();
+      assertThat(invsum).isEqualTo(10);
+
+      Test test_0 = monster.test4(0);
+        Test test_1 = monster.test4(1);
+      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_0 = test4Vector.get(0);
+        test_1 = test4Vector.get(1);
+      assertThat(test4Vector.length()).isEqualTo(2);
+      assertThat(test_0.a() + test_0.b() + test_1.a() + test_1.b()).isEqualTo((Integer) 100);
+
+      assertThat(monster.testarrayofstringLength()).isEqualTo(2);
+      assertThat(monster.testarrayofstring(0)).isEqualTo("test1");
+      assertThat(monster.testarrayofstring(1)).isEqualTo("test2");
+
+      // Method using a vector access object:
+        StringVector testarrayofstringVector = monster.testarrayofstringVector();
+      assertThat(testarrayofstringVector.length()).isEqualTo(2);
+      assertThat(testarrayofstringVector.get(0)).isEqualTo("test1");
+      assertThat(testarrayofstringVector.get(1)).isEqualTo("test2");
+
+      assertThat(monster.testbool()).isEqualTo(true);
+    }
+
+    // this method checks additional fields not present in the binary buffer read from file
+    // these new tests are performed on top of the regular tests
+    static void TestExtendedBuffer(ByteBuffer bb) {
+        TestBuffer(bb);
+
+        Monster monster = Monster.getRootAsMonster(bb);
+
+      assertThat(monster.testhashu32Fnv1()).isEqualTo((Integer.MAX_VALUE + 1L));
+    }
+
+
+    @org.junit.Test public void TestNamespaceNesting() {
+        // reference / manipulate these to verify compilation
+        FlatBufferBuilder fbb = new FlatBufferBuilder(1);
+
+        TableInNestedNS.startTableInNestedNS(fbb);
+        TableInNestedNS.addFoo(fbb, 1234);
+        int nestedTableOff = TableInNestedNS.endTableInNestedNS(fbb);
+
+        TableInFirstNS.startTableInFirstNS(fbb);
+        TableInFirstNS.addFooTable(fbb, nestedTableOff);
+        int off = TableInFirstNS.endTableInFirstNS(fbb);
+    }
+
+    @org.junit.Test public void TestNestedFlatBuffer() {
+        final String nestedMonsterName = "NestedMonsterName";
+        final short nestedMonsterHp = 600;
+        final short nestedMonsterMana = 1024;
+
+        FlatBufferBuilder fbb1 = new FlatBufferBuilder(16);
+        int str1 = fbb1.createString(nestedMonsterName);
+        Monster.startMonster(fbb1);
+        Monster.addName(fbb1, str1);
+        Monster.addHp(fbb1, nestedMonsterHp);
+        Monster.addMana(fbb1, nestedMonsterMana);
+        int monster1 = Monster.endMonster(fbb1);
+        Monster.finishMonsterBuffer(fbb1, monster1);
+        byte[] fbb1Bytes = fbb1.sizedByteArray();
+        fbb1 = null;
+
+        FlatBufferBuilder fbb2 = new FlatBufferBuilder(16);
+        int str2 = fbb2.createString("My Monster");
+        int nestedBuffer = Monster.createTestnestedflatbufferVector(fbb2, fbb1Bytes);
+        Monster.startMonster(fbb2);
+        Monster.addName(fbb2, str2);
+        Monster.addHp(fbb2, (short)50);
+        Monster.addMana(fbb2, (short)32);
+        Monster.addTestnestedflatbuffer(fbb2, nestedBuffer);
+        int monster = Monster.endMonster(fbb2);
+        Monster.finishMonsterBuffer(fbb2, monster);
+
+        // Now test the data extracted from the nested buffer
+        Monster mons = Monster.getRootAsMonster(fbb2.dataBuffer());
+        Monster nestedMonster = mons.testnestedflatbufferAsMonster();
+
+      assertThat(nestedMonsterMana).isEqualTo(nestedMonster.mana());
+      assertThat(nestedMonsterHp).isEqualTo(nestedMonster.hp());
+      assertThat(nestedMonsterName).isEqualTo(nestedMonster.name());
+    }
+
+    @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 };
+        int vec = fbb.createByteVector(inventory);
+        Monster.startMonster(fbb);
+        Monster.addInventory(fbb, vec);
+        Monster.addName(fbb, str);
+        int monster1 = Monster.endMonster(fbb);
+        Monster.finishMonsterBuffer(fbb, monster1);
+        Monster monsterObject = Monster.getRootAsMonster(fbb.dataBuffer());
+
+      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());
+    }
+
+    @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 };
+        ByteBuffer bb = fbb.createUnintializedVector(1, inventory.length, 1);
+        for (byte i:inventory) {
+            bb.put(i);
+        }
+        int vec = fbb.endVector();
+        Monster.startMonster(fbb);
+        Monster.addInventory(fbb, vec);
+        Monster.addName(fbb, str);
+        int monster1 = Monster.endMonster(fbb);
+        Monster.finishMonsterBuffer(fbb, monster1);
+        Monster monsterObject = Monster.getRootAsMonster(fbb.dataBuffer());
+
+      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());
+    }
+
+    @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(file, "rw");
+                    bb =  f.getChannel().map(FileChannel.MapMode.READ_WRITE, 0, capacity).order(ByteOrder.LITTLE_ENDIAN);
+                    f.close();
+                } catch(Throwable e) {
+                    System.out.println("FlatBuffers test: couldn't map ByteBuffer to a file");
+                    bb = null;
+                }
+                return bb;
+            }
+        }
+
+        FlatBufferBuilder fbb = new FlatBufferBuilder(1, new MappedByteBufferFactory());
+
+        TestBuilderBasics(fbb, false);
+    }
+
+    @org.junit.Test public void TestSizedInputStream() {
+        // Test on default FlatBufferBuilder that uses HeapByteBuffer
+        FlatBufferBuilder fbb = new FlatBufferBuilder(1);
+
+        TestBuilderBasics(fbb, false);
+
+        InputStream in = fbb.sizedInputStream();
+        byte[] array = fbb.sizedByteArray();
+        int count = 0;
+        int currentVal = 0;
+
+        while (currentVal != -1 && count < array.length) {
+            try {
+                currentVal = in.read();
+            } catch(java.io.IOException e) {
+                System.out.println("FlatBuffers test: couldn't read from InputStream");
+                return;
+            }
+          assertThat((byte)currentVal).isEqualTo(array[count]);
+          count++;
+        }
+      assertThat(count).isEqualTo(array.length);
+    }
+
+    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);
+        Monster.addName(fbb, names[0]);
+        off[0] = Monster.endMonster(fbb);
+        Monster.startMonster(fbb);
+        Monster.addName(fbb, names[1]);
+        off[1] = Monster.endMonster(fbb);
+        Monster.startMonster(fbb);
+        Monster.addName(fbb, names[2]);
+        off[2] = Monster.endMonster(fbb);
+        int sortMons = fbb.createSortedVectorOfTables(new Monster(), off);
+
+        // We set up the same values as monsterdata.json:
+
+        int str = fbb.createString("MyMonster");
+
+        int inv = Monster.createInventoryVector(fbb, new byte[] { 0, 1, 2, 3, 4 });
+
+        int fred = fbb.createString("Fred");
+        Monster.startMonster(fbb);
+        Monster.addName(fbb, fred);
+        int mon2 = Monster.endMonster(fbb);
+
+        Monster.startTest4Vector(fbb, 2);
+        Test.createTest(fbb, (short)10, (byte)20);
+        Test.createTest(fbb, (short)30, (byte)40);
+        int test4 = fbb.endVector();
+
+        int testArrayOfString = Monster.createTestarrayofstringVector(fbb, new int[] {
+                fbb.createString("test1"),
+                fbb.createString("test2")
+        });
+
+        Monster.startMonster(fbb);
+        Monster.addPos(fbb, Vec3.createVec3(fbb, 1.0f, 2.0f, 3.0f, 3.0,
+                Color.Green, (short)5, (byte)6));
+        Monster.addHp(fbb, (short)80);
+        Monster.addName(fbb, str);
+        Monster.addInventory(fbb, inv);
+        Monster.addTestType(fbb, (byte)Any.Monster);
+        Monster.addTest(fbb, mon2);
+        Monster.addTest4(fbb, test4);
+        Monster.addTestarrayofstring(fbb, testArrayOfString);
+        Monster.addTestbool(fbb, true);
+        Monster.addTesthashu32Fnv1(fbb, Integer.MAX_VALUE + 1L);
+        Monster.addTestarrayoftables(fbb, sortMons);
+        int mon = Monster.endMonster(fbb);
+
+        if (sizePrefix) {
+            Monster.finishSizePrefixedMonsterBuffer(fbb, mon);
+        } else {
+            Monster.finishMonsterBuffer(fbb, mon);
+        }
+
+        // Write the result to a file for debugging purposes:
+        // Note that the binaries are not necessarily identical, since the JSON
+        // parser may serialize in a slightly different order than the above
+        // Java code. They are functionally equivalent though.
+
+        try {
+            String filename = "monsterdata_java_wire" + (sizePrefix ? "_sp" : "") + ".mon";
+            FileChannel fc = new FileOutputStream(tempFolder.newFile(filename)).getChannel();
+            fc.write(fbb.dataBuffer().duplicate());
+            fc.close();
+        } catch(java.io.IOException e) {
+            System.out.println("FlatBuffers test: couldn't write file");
+            return;
+        }
+
+        // Test it:
+        ByteBuffer dataBuffer = fbb.dataBuffer();
+        if (sizePrefix) {
+          assertThat(ByteBufferUtil.getSizePrefix(dataBuffer) + SIZE_PREFIX_LENGTH).isEqualTo(
+            dataBuffer.remaining());
+          dataBuffer = ByteBufferUtil.removeSizePrefix(dataBuffer);
+        }
+        TestExtendedBuffer(dataBuffer);
+
+        // Make sure it also works with read only ByteBuffers. This is slower,
+        // since creating strings incurs an additional copy
+        // (see Table.__string).
+        TestExtendedBuffer(dataBuffer.asReadOnlyBuffer());
+
+        //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
+      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++) {
+          assertThat((int)inventoryVector.get(i)).isEqualTo(i + 1);
+        }
+
+        //reverse mutation
+      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);
+    }
+
+    @org.junit.Test public void TestVectorOfUnions() {
+        final FlatBufferBuilder fbb = new FlatBufferBuilder();
+
+        final int swordAttackDamage = 1;
+
+        final int[] characterVector = new int[] {
+            Attacker.createAttacker(fbb, swordAttackDamage),
+        };
+
+        final byte[] characterTypeVector = new byte[]{
+            Character.MuLan,
+        };
+
+        Movie.finishMovieBuffer(
+            fbb,
+            Movie.createMovie(
+                fbb,
+                (byte)0,
+                (byte)0,
+                Movie.createCharactersTypeVector(fbb, characterTypeVector),
+                Movie.createCharactersVector(fbb, characterVector)
+            )
+        );
+
+        final Movie movie = Movie.getRootAsMovie(fbb.dataBuffer());
+        ByteVector charactersTypeByteVector = movie.charactersTypeVector();
+        UnionVector charactersVector = movie.charactersVector();
+
+      assertThat(movie.charactersTypeLength()).isEqualTo(characterTypeVector.length);
+      assertThat(charactersTypeByteVector.length()).isEqualTo(characterTypeVector.length);
+      assertThat(movie.charactersLength()).isEqualTo(characterVector.length);
+      assertThat(charactersVector.length()).isEqualTo(characterVector.length);
+
+      assertThat((Byte) movie.charactersType(0)).isEqualTo(characterTypeVector[0]);
+      assertThat(charactersTypeByteVector.get(0)).isEqualTo(characterTypeVector[0]);
+
+      assertThat(((Attacker)movie.characters(new Attacker(), 0)).swordAttackDamage()).isEqualTo(
+        swordAttackDamage);
+    }
+
+    @org.junit.Test public void TestFixedLengthArrays() {
+        FlatBufferBuilder builder = new FlatBufferBuilder(0);
+
+        float       a;
+        int[]       b = new int[15];
+        byte        c;
+        int[][]     d_a = new int[2][2];
+        byte[]      d_b = new byte[2];
+        byte[][]    d_c = new byte[2][2];
+        long[][]    d_d = new long[2][2];
+        int         e;
+        long[]      f = new long[2];
+
+        a = 0.5f;
+        for (int i = 0; i < 15; i++) b[i] = i;
+        c = 1;
+        d_a[0][0] = 1;
+        d_a[0][1] = 2;
+        d_a[1][0] = 3;
+        d_a[1][1] = 4;
+        d_b[0] = TestEnum.B;
+        d_b[1] = TestEnum.C;
+        d_c[0][0] = TestEnum.A;
+        d_c[0][1] = TestEnum.B;
+        d_c[1][0] = TestEnum.C;
+        d_c[1][1] = TestEnum.B;
+        d_d[0][0] = -1;
+        d_d[0][1] = 1;
+        d_d[1][0] = -2;
+        d_d[1][1] = 2;
+        e = 2;
+        f[0] = -1;
+        f[1] = 1;
+
+        int arrayOffset = ArrayStruct.createArrayStruct(builder,
+            a, b, c, d_a, d_b, d_c, d_d, e, f);
+
+        // Create a table with the ArrayStruct.
+        ArrayTable.startArrayTable(builder);
+        ArrayTable.addA(builder, arrayOffset);
+        int tableOffset = ArrayTable.endArrayTable(builder);
+
+        ArrayTable.finishArrayTableBuffer(builder, tableOffset);
+
+        ArrayTable table = ArrayTable.getRootAsArrayTable(builder.dataBuffer());
+        NestedStruct nested = new NestedStruct();
+
+      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);
+    }
+
+    @org.junit.Test public void testFlexBuffersTest() {
+        FlexBuffersBuilder builder = new FlexBuffersBuilder(ByteBuffer.allocate(512),
+                FlexBuffersBuilder.BUILDER_FLAG_SHARE_KEYS_AND_STRINGS);
+        testFlexBuffersTest(builder);
+        int bufferLimit1 = ((ArrayReadWriteBuf) builder.getBuffer()).limit();
+
+        // Repeat after clearing the builder to ensure the builder is reusable
+        builder.clear();
+        testFlexBuffersTest(builder);
+        int bufferLimit2 = ((ArrayReadWriteBuf) builder.getBuffer()).limit();
+      assertThat(bufferLimit1).isEqualTo(bufferLimit2);
+    }
+
+    public static void testFlexBuffersTest(FlexBuffersBuilder builder) {
+        // Write the equivalent of:
+        // { vec: [ -100, "Fred", 4.0, false ], bar: [ 1, 2, 3 ], bar3: [ 1, 2, 3 ],
+        // foo: 100, bool: true, mymap: { foo: "Fred" } }
+        // It's possible to do this without std::function support as well.
+        int map1 = builder.startMap();
+
+        int vec1 = builder.startVector();
+        builder.putInt(-100);
+        builder.putString("Fred");
+        builder.putBlob(new byte[]{(byte) 77});
+        builder.putBoolean(false);
+        builder.putInt(Long.MAX_VALUE);
+
+        int map2 = builder.startMap();
+        builder.putInt("test", 200);
+        builder.endMap(null, map2);
+
+        builder.putFloat(150.9);
+        builder.putFloat(150.9999998);
+        builder.endVector("vec", vec1, false, false);
+
+        vec1 = builder.startVector();
+        builder.putInt(1);
+        builder.putInt(2);
+        builder.putInt(3);
+        builder.endVector("bar", vec1, true, false);
+
+        vec1 = builder.startVector();
+        builder.putBoolean(true);
+        builder.putBoolean(false);
+        builder.putBoolean(true);
+        builder.putBoolean(false);
+        builder.endVector("bools", vec1, true, false);
+
+        builder.putBoolean("bool", true);
+        builder.putFloat("foo", 100);
+
+        map2 = builder.startMap();
+        builder.putString("bar", "Fred");  // Testing key and string reuse.
+        builder.putInt("int", -120);
+        builder.putFloat("float", -123.0f);
+        builder.putBlob("blob", new byte[]{ 65, 67 });
+        builder.endMap("mymap", map2);
+
+        builder.endMap(null, map1);
+        builder.finish();
+
+        FlexBuffers.Map m = FlexBuffers.getRoot(builder.getBuffer()).asMap();
+
+      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();
+      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();
+      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
+        FlexBuffers.Vector bvec = m.get("bools").asVector();
+      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();
+
+      // mymap vector
+        FlexBuffers.Map mymap = m.get("mymap").asMap();
+      // 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\"");
+    }
+
+    @org.junit.Test public void testFlexBufferVectorStrings() {
+        FlexBuffersBuilder builder = new FlexBuffersBuilder(ByteBuffer.allocate(10000000));
+
+        int size = 3000;
+        StringBuilder sb = new StringBuilder();
+        for (int i=0; i< size; i++) {
+            sb.append("a");
+        }
+
+        String text = sb.toString();
+      assertThat(text.length()).isEqualTo(size);
+
+      int pos = builder.startVector();
+
+        for (int i=0; i<size; i++) {
+            builder.putString(text);
+        }
+
+        try {
+            builder.endVector(null, pos, true, false);
+            // this should raise an exception as
+            // typed vector of string was deprecated
+            assert false;
+        } catch(FlexBufferException fb) {
+            // no op
+        }
+        // we finish the vector again as non-typed
+        builder.endVector(null, pos, false, false);
+
+        ByteBuffer b = builder.finish();
+        Vector v = FlexBuffers.getRoot(b).asVector();
+
+      assertThat(v.size()).isEqualTo(size);
+      for (int i=0; i<size; i++) {
+        assertThat(v.get(i).asString().length()).isEqualTo(size);
+        assertThat(v.get(i).asString()).isEqualTo(text);
+      }
+    }
+
+    @org.junit.Test public void testDeprecatedTypedVectorString() {
+        // tests whether we are able to support reading deprecated typed vector string
+        // data is equivalent to [ "abc", "abc", "abc", "abc"]
+        byte[] data = new byte[] {0x03, 0x61, 0x62, 0x63, 0x00, 0x03, 0x61, 0x62, 0x63, 0x00,
+            0x03, 0x61, 0x62, 0x63, 0x00, 0x03, 0x61, 0x62, 0x63, 0x00, 0x04, 0x14, 0x10,
+             0x0c, 0x08, 0x04, 0x3c, 0x01};
+        Reference ref = FlexBuffers.getRoot(ByteBuffer.wrap(data));
+      assertThat(ref.getType()).isEqualTo(FlexBuffers.FBT_VECTOR_STRING_DEPRECATED);
+      assertThat(ref.isTypedVector()).isTrue();
+      Vector vec = ref.asVector();
+        for (int i=0; i< vec.size(); i++) {
+          assertThat("abc").isEqualTo(vec.get(i).asString());
+        }
+    }
+
+    @org.junit.Test public void testSingleElementBoolean() {
+        FlexBuffersBuilder builder = new FlexBuffersBuilder(ByteBuffer.allocate(100));
+        builder.putBoolean(true);
+        ByteBuffer b = builder.finish();
+        assertThat(FlexBuffers.getRoot(b).asBoolean()).isTrue();
+    }
+
+    @org.junit.Test public void testSingleElementByte() {
+        FlexBuffersBuilder builder = new FlexBuffersBuilder();
+        builder.putInt(10);
+        ByteBuffer b = builder.finish();
+      assertThat(10).isEqualTo(FlexBuffers.getRoot(b).asInt());
+    }
+
+    @org.junit.Test public void testSingleElementShort() {
+        FlexBuffersBuilder builder = new FlexBuffersBuilder();
+        builder.putInt(Short.MAX_VALUE);
+        ByteBuffer b = builder.finish();
+      assertThat(Short.MAX_VALUE).isEqualTo((short) FlexBuffers.getRoot(b).asInt());
+    }
+
+    @org.junit.Test public void testSingleElementInt() {
+        FlexBuffersBuilder builder = new FlexBuffersBuilder();
+        builder.putInt(Integer.MIN_VALUE);
+        ByteBuffer b = builder.finish();
+      assertThat(Integer.MIN_VALUE).isEqualTo(FlexBuffers.getRoot(b).asInt());
+    }
+
+    @org.junit.Test public void testSingleElementLong() {
+        FlexBuffersBuilder builder = new FlexBuffersBuilder();
+        builder.putInt(Long.MAX_VALUE);
+        ByteBuffer b = builder.finish();
+      assertThat(Long.MAX_VALUE).isEqualTo(FlexBuffers.getRoot(b).asLong());
+    }
+
+    @org.junit.Test public void testSingleElementFloat() {
+        FlexBuffersBuilder builder = new FlexBuffersBuilder();
+        builder.putFloat(Float.MAX_VALUE);
+        ByteBuffer b = builder.finish();
+      assertThat(Float.compare(Float.MAX_VALUE, (float) FlexBuffers.getRoot(b).asFloat())).isEqualTo(
+        0);
+    }
+
+    @org.junit.Test public void testSingleElementDouble() {
+        FlexBuffersBuilder builder = new FlexBuffersBuilder();
+        builder.putFloat(Double.MAX_VALUE);
+        ByteBuffer b = builder.finish();
+      assertThat(Double.compare(Double.MAX_VALUE, FlexBuffers.getRoot(b).asFloat())).isEqualTo(0);
+    }
+
+    @org.junit.Test public void testSingleElementBigString() {
+        FlexBuffersBuilder builder = new FlexBuffersBuilder(ByteBuffer.allocate(10000));
+        StringBuilder sb = new StringBuilder();
+
+        for (int i=0; i< 3000; i++) {
+            sb.append("a");
+        }
+
+        builder.putString(sb.toString());
+        ByteBuffer b = builder.finish();
+
+        FlexBuffers.Reference r = FlexBuffers.getRoot(b);
+
+      assertThat(FlexBuffers.FBT_STRING).isEqualTo(r.getType());
+      assertThat(sb.toString()).isEqualTo(r.asString());
+    }
+
+    @org.junit.Test public void testSingleElementSmallString() {
+        FlexBuffersBuilder builder = new FlexBuffersBuilder(ByteBuffer.allocate(10000));
+
+        builder.putString("aa");
+        ByteBuffer b = builder.finish();
+        FlexBuffers.Reference r = FlexBuffers.getRoot(b);
+
+      assertThat(FlexBuffers.FBT_STRING).isEqualTo(r.getType());
+      assertThat("aa").isEqualTo(r.asString());
+    }
+
+    @org.junit.Test public void testSingleElementBlob() {
+        FlexBuffersBuilder builder = new FlexBuffersBuilder();
+        builder.putBlob(new byte[]{5, 124, 118, -1});
+        ByteBuffer b = builder.finish();
+        FlexBuffers.Reference r = FlexBuffers.getRoot(b);
+        byte[] result = r.asBlob().getBytes();
+      assertThat((byte)5).isEqualTo(result[0]);
+      assertThat((byte)124).isEqualTo(result[1]);
+      assertThat((byte)118).isEqualTo(result[2]);
+      assertThat((byte)-1).isEqualTo(result[3]);
+    }
+
+    @org.junit.Test public void testSingleElementLongBlob() {
+
+        // verifies blobs of up to 2^16 in length
+        for (int i = 2; i <= 1<<16; i = i<<1) {
+            byte[] input = new byte[i-1];
+            for (int index = 0; index < input.length; index++) {
+                input[index] = (byte)(index % 64);
+            }
+
+            FlexBuffersBuilder builder = new FlexBuffersBuilder();
+            builder.putBlob(input);
+            ByteBuffer b = builder.finish();
+            FlexBuffers.Reference r = FlexBuffers.getRoot(b);
+            byte[] result = r.asBlob().getBytes();
+            
+            for (int index = 0; index < input.length; index++) {
+              assertThat((byte)(index % 64)).isEqualTo(result[index]);
+            }
+        }
+    }
+
+    @org.junit.Test public void testSingleElementUByte() {
+        FlexBuffersBuilder builder = new FlexBuffersBuilder();
+        builder.putUInt(0xFF);
+        ByteBuffer b = builder.finish();
+        FlexBuffers.Reference r = FlexBuffers.getRoot(b);
+      assertThat(255).isEqualTo((int)r.asUInt());
+    }
+
+    @org.junit.Test public void testSingleElementUShort() {
+        FlexBuffersBuilder builder = new FlexBuffersBuilder();
+        builder.putUInt(0xFFFF);
+        ByteBuffer b = builder.finish();
+        FlexBuffers.Reference r = FlexBuffers.getRoot(b);
+      assertThat(65535).isEqualTo((int)r.asUInt());
+    }
+
+    @org.junit.Test public void testSingleElementUInt() {
+        FlexBuffersBuilder builder = new FlexBuffersBuilder();
+        builder.putUInt(0xFFFF_FFFFL);
+        ByteBuffer b = builder.finish();
+        FlexBuffers.Reference r = FlexBuffers.getRoot(b);
+      assertThat(4294967295L).isEqualTo(r.asUInt());
+    }
+
+    @org.junit.Test public void testSingleFixedTypeVector() {
+
+        int[] ints = new int[]{5, 124, 118, -1};
+        float[] floats = new float[]{5.5f, 124.124f, 118.118f, -1.1f};
+        String[] strings = new String[]{"This", "is", "a", "typed", "array"};
+        boolean[] booleans = new boolean[]{false, true, true, false};
+
+
+        FlexBuffersBuilder builder = new FlexBuffersBuilder(ByteBuffer.allocate(512),
+                FlexBuffersBuilder.BUILDER_FLAG_NONE);
+
+        int mapPos = builder.startMap();
+
+        int vecPos = builder.startVector();
+        for (final int i : ints) {
+            builder.putInt(i);
+        }
+        builder.endVector("ints", vecPos, true, false);
+
+        vecPos = builder.startVector();
+        for (final float i : floats) {
+            builder.putFloat(i);
+        }
+        builder.endVector("floats", vecPos, true, false);
+
+        vecPos = builder.startVector();
+        for (final boolean i : booleans) {
+            builder.putBoolean(i);
+        }
+        builder.endVector("booleans", vecPos, true, false);
+
+        builder.endMap(null, mapPos);
+
+
+        ByteBuffer b = builder.finish();
+        FlexBuffers.Reference r = FlexBuffers.getRoot(b);
+        assert(r.asMap().get("ints").isTypedVector());
+        assert(r.asMap().get("floats").isTypedVector());
+        assert(r.asMap().get("booleans").isTypedVector());
+    }
+
+    @org.junit.Test public void testSingleElementVector() {
+        FlexBuffersBuilder b = new FlexBuffersBuilder();
+
+        int vecPos = b.startVector();
+        b.putInt(99);
+        b.putString("wow");
+        b.putNull();
+        int vecpos2 = b.startVector();
+        b.putInt(99);
+        b.putString("wow");
+        b.putNull();
+        b.endVector(null, vecpos2, false, false);
+        b.endVector(null, vecPos, false, false);
+        b.finish();
+
+        FlexBuffers.Reference r = FlexBuffers.getRoot(b.getBuffer());
+      assertThat(FlexBuffers.FBT_VECTOR).isEqualTo(r.getType());
+      FlexBuffers.Vector vec = FlexBuffers.getRoot(b.getBuffer()).asVector();
+      assertThat(4).isEqualTo(vec.size());
+      assertThat(99).isEqualTo(vec.get(0).asInt());
+      assertThat("wow").isEqualTo(vec.get(1).asString());
+      assertThat(true).isEqualTo(vec.get(2).isNull());
+      assertThat("[ 99, \"wow\", null ]").isEqualTo(vec.get(3).toString());
+      assertThat("[ 99, \"wow\", null, [ 99, \"wow\", null ] ]").isEqualTo(
+        FlexBuffers.getRoot(b.getBuffer()).toString());
+    }
+
+    @org.junit.Test public void testSingleElementMap() {
+        FlexBuffersBuilder b = new FlexBuffersBuilder();
+
+        int mapPost = b.startMap();
+        b.putInt("myInt", 0x7fffffbbbfffffffL);
+        b.putString("myString", "wow");
+        b.putString("myString2", "incredible");
+        b.putNull("myNull");
+        int start = b.startVector();
+        b.putInt(99);
+        b.putString("wow");
+        b.endVector("myVec", start, false, false);
+
+        b.putFloat("double", 0x1.ffffbbbffffffP+1023);
+        b.endMap(null, mapPost);
+        b.finish();
+
+        FlexBuffers.Reference r = FlexBuffers.getRoot(b.getBuffer());
+      assertThat(FlexBuffers.FBT_MAP).isEqualTo(r.getType());
+      FlexBuffers.Map map = FlexBuffers.getRoot(b.getBuffer()).asMap();
+      assertThat(6).isEqualTo(map.size());
+      assertThat(0x7fffffbbbfffffffL).isEqualTo(map.get("myInt").asLong());
+      assertThat("wow").isEqualTo(map.get("myString").asString());
+      assertThat("incredible").isEqualTo(map.get("myString2").asString());
+      assertThat(true).isEqualTo(map.get("myNull").isNull());
+      assertThat(99).isEqualTo(map.get("myVec").asVector().get(0).asInt());
+      assertThat("wow").isEqualTo(map.get("myVec").asVector().get(1).asString());
+      assertThat(Double.compare(0x1.ffffbbbffffffP+1023, map.get("double").asFloat())).isEqualTo(0);
+      assertThat(
+        "{ \"double\" : 1.7976894783391937E308, \"myInt\" : 9223371743723257855, \"myNull\" : null, \"myString\" : \"wow\", \"myString2\" : \"incredible\", \"myVec\" : [ 99, \"wow\" ] }").isEqualTo(
+        FlexBuffers.getRoot(b.getBuffer()).toString());
+    }
+
+    @org.junit.Test public void testFlexBuferEmpty() {
+        FlexBuffers.Blob blob = FlexBuffers.Blob.empty();
+        FlexBuffers.Map ary = FlexBuffers.Map.empty();
+        FlexBuffers.Vector map = FlexBuffers.Vector.empty();
+        FlexBuffers.TypedVector typedAry = FlexBuffers.TypedVector.empty();
+      assertThat(blob.size()).isEqualTo(0);
+      assertThat(map.size()).isEqualTo(0);
+      assertThat(ary.size()).isEqualTo(0);
+      assertThat(typedAry.size()).isEqualTo(0);
+    }
+
+    @org.junit.Test public void testHashMapToMap() {
+        int entriesCount = 12;
+
+        HashMap<String, String> source =  new HashMap<>();
+        for (int i = 0; i < entriesCount; i++) {
+            source.put("foo_param_" + i, "foo_value_" + i);
+        }
+
+        FlexBuffersBuilder builder = new FlexBuffersBuilder(1000);
+        int mapStart = builder.startMap();
+        for (Map.Entry<String, String> entry : source.entrySet()) {
+            builder.putString(entry.getKey(), entry.getValue());
+        }
+        builder.endMap(null, mapStart);
+        ByteBuffer bb = builder.finish();
+        bb.rewind();
+
+        FlexBuffers.Reference rootReference = FlexBuffers.getRoot(bb);
+
+      assertThat(rootReference.isMap()).isTrue();
+
+      FlexBuffers.Map flexMap = rootReference.asMap();
+
+        FlexBuffers.KeyVector keys = flexMap.keys();
+        FlexBuffers.Vector values = flexMap.values();
+
+      assertThat(entriesCount).isEqualTo(keys.size());
+      assertThat(entriesCount).isEqualTo(values.size());
+
+      HashMap<String, String> result =  new HashMap<>();
+        for (int i = 0; i < keys.size(); i++) {
+            result.put(keys.get(i).toString(), values.get(i).asString());
+        }
+
+      assertThat(source).isEqualTo(result);
+    }
+
+    @org.junit.Test public void testBuilderGrowth() {
+        FlexBuffersBuilder builder = new FlexBuffersBuilder();
+        String someString = "This is a small string";
+        builder.putString(someString);
+        ByteBuffer b = builder.finish();
+      assertThat(someString).isEqualTo(FlexBuffers.getRoot(b).asString());
+
+      FlexBuffersBuilder failBuilder = new FlexBuffersBuilder(ByteBuffer.allocate(1));
+        failBuilder.putString(someString);
+    }
+
+    @org.junit.Test
+    public void testFlexBuffersUtf8Map() {
+        FlexBuffersBuilder builder = new FlexBuffersBuilder(ByteBuffer.allocate(512),
+                FlexBuffersBuilder.BUILDER_FLAG_SHARE_KEYS_AND_STRINGS);
+
+        String key0 = "😨 face1";
+        String key1 = "😩 face2";
+        String key2 = "😨 face3";
+        String key3 = "trademark ®";
+        String key4 = "€ euro";
+        String utf8keys[] = { "😨 face1", "😩 face2", "😨 face3", "trademark ®", "€ euro"};
+
+        int map = builder.startMap();
+
+        for (int i=0; i< utf8keys.length; i++) {
+            builder.putString(utf8keys[i], utf8keys[i]);  // Testing key and string reuse.
+        }
+        builder.endMap(null, map);
+        builder.finish();
+
+        FlexBuffers.Map m = FlexBuffers.getRoot(builder.getBuffer()).asMap();
+
+      assertThat(m.size()).isEqualTo(5);
+
+      KeyVector kv = m.keys();
+        for (int i=0; i< utf8keys.length; i++) {
+          assertThat(kv.get(i).toString()).isEqualTo(m.get(i).asString());
+        }
+
+      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]);
+    }
+
+    @org.junit.Test public void testFlexBuffersMapLookup() {
+        FlexBuffersBuilder builder = new FlexBuffersBuilder(ByteBuffer.allocate(512),
+                FlexBuffersBuilder.BUILDER_FLAG_SHARE_KEYS_AND_STRINGS);
+
+        String key0 = "123";
+        String key1 = "1234";
+        String key2 = "12345";
+        String[] keys = new String[]{key0, key1, key2};
+
+        int map = builder.startMap();
+
+        for (int i=0; i< keys.length; i++) {
+            builder.putString(keys[i], keys[i]);  // Testing key and string reuse.
+        }
+        builder.endMap(null, map);
+        builder.finish();
+
+        FlexBuffers.Map m = FlexBuffers.getRoot(builder.getBuffer()).asMap();
+        for (int i=0; i< keys.length; i++) {
+          assertThat(m.get(keys[i]).asString()).isEqualTo(keys[i]);
+          assertThat(m.get(keys[i].getBytes(StandardCharsets.UTF_8)).asString()).isEqualTo(keys[i]);
+        }
+    }
+
+    @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 });
+        int rootIdx = LongFloatMap.createLongFloatMap(fbb, vectorEntriesIdx);
+
+        LongFloatMap.finishLongFloatMapBuffer(fbb, rootIdx);
+        LongFloatMap map = LongFloatMap.getRootAsLongFloatMap(fbb.dataBuffer());
+      assertThat(map.entriesLength()).isEqualTo(1);
+
+      LongFloatEntry e = map.entries(0);
+      assertThat(e.key()).isEqualTo(0L);
+      assertThat(e.value()).isEqualTo(99.0f);
+
+      LongFloatEntry e2 = map.entriesByKey(0);
+      assertThat(e2.key()).isEqualTo(0L);
+      assertThat(e2.value()).isEqualTo(99.0f);
+    }
+
+    @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};
+        int offset = Monster.createInventoryVector(fbb, data);
+        Monster.startMonster(fbb);
+        Monster.addName(fbb, str);
+        Monster.addInventory(fbb, offset);
+        int monster1 = Monster.endMonster(fbb);
+        Monster.finishMonsterBuffer(fbb, monster1);
+        Monster monsterObject = Monster.getRootAsMonster(fbb.dataBuffer());
+
+      assertThat(monsterObject.inventoryLength()).isEqualTo(data.length);
+      assertThat((Integer) monsterObject.inventory(4)).isEqualTo((int) data[4]);
+      assertThat(ByteBuffer.wrap(data)).isEqualTo(monsterObject.inventoryAsByteBuffer());
+
+      fbb.clear();
+        ByteBuffer bb = ByteBuffer.wrap(data);
+        offset = fbb.createByteVector(bb);
+        str = fbb.createString("ByteMonster");
+        Monster.startMonster(fbb);
+        Monster.addName(fbb, str);
+        Monster.addInventory(fbb, offset);
+        monster1 = Monster.endMonster(fbb);
+        Monster.finishMonsterBuffer(fbb, monster1);
+        Monster monsterObject2 = Monster.getRootAsMonster(fbb.dataBuffer());
+
+      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);
+        str = fbb.createString("ByteMonster");
+        Monster.startMonster(fbb);
+        Monster.addName(fbb, str);
+        Monster.addInventory(fbb, offset);
+        monster1 = Monster.endMonster(fbb);
+        Monster.finishMonsterBuffer(fbb, monster1);
+        Monster monsterObject3 = Monster.getRootAsMonster(fbb.dataBuffer());
+
+      assertThat(monsterObject3.inventoryLength()).isEqualTo(4);
+      assertThat((Integer) monsterObject3.inventory(0)).isEqualTo((int) data[3]);
+
+      fbb.clear();
+        bb = ByteBuffer.wrap(data);
+        offset = Monster.createInventoryVector(fbb, bb);
+        str = fbb.createString("ByteMonster");
+        Monster.startMonster(fbb);
+        Monster.addName(fbb, str);
+        Monster.addInventory(fbb, offset);
+        monster1 = Monster.endMonster(fbb);
+        Monster.finishMonsterBuffer(fbb, monster1);
+        Monster monsterObject4 = Monster.getRootAsMonster(fbb.dataBuffer());
+
+      assertThat(monsterObject4.inventoryLength()).isEqualTo(data.length);
+      assertThat((Integer) monsterObject4.inventory(8)).isEqualTo((int) 8);
+
+      fbb.clear();
+        byte[] largeData = new byte[1024];
+        offset = fbb.createByteVector(largeData);
+        str = fbb.createString("ByteMonster");
+        Monster.startMonster(fbb);
+        Monster.addName(fbb, str);
+        Monster.addInventory(fbb, offset);
+        monster1 = Monster.endMonster(fbb);
+        Monster.finishMonsterBuffer(fbb, monster1);
+        Monster monsterObject5 = Monster.getRootAsMonster(fbb.dataBuffer());
+
+      assertThat(monsterObject5.inventoryLength()).isEqualTo(largeData.length);
+      assertThat((Integer) monsterObject5.inventory(25)).isEqualTo((int) largeData[25]);
+
+      fbb.clear();
+        bb = ByteBuffer.wrap(largeData);
+        bb.position(512);
+        ByteBuffer bb2 = bb.slice();
+      assertThat(bb2.arrayOffset()).isEqualTo(512);
+      offset = fbb.createByteVector(bb2);
+        str = fbb.createString("ByteMonster");
+        Monster.startMonster(fbb);
+        Monster.addName(fbb, str);
+        Monster.addInventory(fbb, offset);
+        monster1 = Monster.endMonster(fbb);
+        Monster.finishMonsterBuffer(fbb, monster1);
+        Monster monsterObject6 = Monster.getRootAsMonster(fbb.dataBuffer());
+
+      assertThat(monsterObject6.inventoryLength()).isEqualTo(512);
+      assertThat((Integer) monsterObject6.inventory(0)).isEqualTo((int) largeData[512]);
+
+      fbb.clear();
+        bb = ByteBuffer.wrap(largeData);
+        bb.limit(256);
+        offset = fbb.createByteVector(bb);
+        str = fbb.createString("ByteMonster");
+        Monster.startMonster(fbb);
+        Monster.addName(fbb, str);
+        Monster.addInventory(fbb, offset);
+        monster1 = Monster.endMonster(fbb);
+        Monster.finishMonsterBuffer(fbb, monster1);
+        Monster monsterObject7 = Monster.getRootAsMonster(fbb.dataBuffer());
+
+      assertThat(monsterObject7.inventoryLength()).isEqualTo(256);
+
+      fbb.clear();
+        bb = ByteBuffer.allocateDirect(2048);
+        offset = fbb.createByteVector(bb);
+        str = fbb.createString("ByteMonster");
+        Monster.startMonster(fbb);
+        Monster.addName(fbb, str);
+        Monster.addInventory(fbb, offset);
+        monster1 = Monster.endMonster(fbb);
+        Monster.finishMonsterBuffer(fbb, monster1);
+        Monster monsterObject8 = Monster.getRootAsMonster(fbb.dataBuffer());
+
+      assertThat(monsterObject8.inventoryLength()).isEqualTo(2048);
+    }
+
+    @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++) {
+          assertThat(offset).isEqualTo(fb.createSharedString(testString));
+        }
+    }
+
+    @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());
+      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);
+        ScalarStuff.addMaybeI8(fbb, (byte)5);
+        ScalarStuff.addDefaultI8(fbb, (byte)5);
+        ScalarStuff.addJustU8(fbb, 6);
+        ScalarStuff.addMaybeU8(fbb, 6);
+        ScalarStuff.addDefaultU8(fbb, 6);
+        ScalarStuff.addJustI16(fbb, (short)7);
+        ScalarStuff.addMaybeI16(fbb, (short)7);
+        ScalarStuff.addDefaultI16(fbb, (short)7);
+        ScalarStuff.addJustU16(fbb, 8);
+        ScalarStuff.addMaybeU16(fbb, 8);
+        ScalarStuff.addDefaultU16(fbb, 8);
+        ScalarStuff.addJustI32(fbb, 9);
+        ScalarStuff.addMaybeI32(fbb, 9);
+        ScalarStuff.addDefaultI32(fbb, 9);
+        ScalarStuff.addJustU32(fbb, (long)10);
+        ScalarStuff.addMaybeU32(fbb, (long)10);
+        ScalarStuff.addDefaultU32(fbb, (long)10);
+        ScalarStuff.addJustI64(fbb, 11L);
+        ScalarStuff.addMaybeI64(fbb, 11L);
+        ScalarStuff.addDefaultI64(fbb, 11L);
+        ScalarStuff.addJustU64(fbb, 12L);
+        ScalarStuff.addMaybeU64(fbb, 12L);
+        ScalarStuff.addDefaultU64(fbb, 12L);
+        ScalarStuff.addJustF32(fbb, 13.0f);
+        ScalarStuff.addMaybeF32(fbb, 13.0f);
+        ScalarStuff.addDefaultF32(fbb, 13.0f);
+        ScalarStuff.addJustF64(fbb, 14.0);
+        ScalarStuff.addMaybeF64(fbb, 14.0);
+        ScalarStuff.addDefaultF64(fbb, 14.0);
+        ScalarStuff.addJustBool(fbb, true);
+        ScalarStuff.addMaybeBool(fbb, true);
+        ScalarStuff.addDefaultBool(fbb, true);
+        ScalarStuff.addJustEnum(fbb, OptionalByte.Two);
+        ScalarStuff.addMaybeEnum(fbb, OptionalByte.Two);
+        ScalarStuff.addDefaultEnum(fbb, OptionalByte.Two);
+
+        pos = ScalarStuff.endScalarStuff(fbb);
+
+        fbb.finish(pos);
+
+        scalarStuff = ScalarStuff.getRootAsScalarStuff(fbb.dataBuffer());
+
+      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) {
+      assertThat(monster.getHp()).isEqualTo((short) 80);
+      // default
+      assertThat(monster.getMana()).isEqualTo((short) 150);
+
+      assertThat(monster.getName()).isEqualTo("MyMonster");
+      assertThat(monster.getColor()).isEqualTo((Integer) Color.Blue);
+      // monster.friendly() // can't access, deprecated
+
+        Vec3T pos = monster.getPos();
+      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++)
+          assertThat(expInv[i]).isEqualTo(inv[i]);
+
+        TestT[] test4 = monster.getTest4();
+        TestT test_0 = test4[0];
+        TestT test_1 = test4[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++) {
+          assertThat(vectorOfLongs[i]).isEqualTo(l);
+          l *= 100;
+        }
+
+        double[] vectorOfDoubles = monster.getVectorOfDoubles();
+      assertThat(vectorOfDoubles.length).isEqualTo(3);
+      assertThat(vectorOfDoubles[0]).isEqualTo(-1.7976931348623157E308);
+      assertThat(vectorOfDoubles[1]).isEqualTo(0.0);
+      assertThat(vectorOfDoubles[2]).isEqualTo(1.7976931348623157E308);
+
+      assertThat(monster.getParentNamespaceTest() == null).isTrue();
+      ReferrableT[] vectorOfReferrables = monster.getVectorOfReferrables();
+      assertThat(vectorOfReferrables.length).isEqualTo(0);
+
+      assertThat(monster.getSignedEnum()).isEqualTo((byte) -1);
+    }
+
+    static void TestPackUnpack(ByteBuffer bb) {
+        Monster m = Monster.getRootAsMonster(bb);
+        MonsterT mObject = m.unpack();
+        TestObject(mObject);
+        FlatBufferBuilder fbb = new FlatBufferBuilder();
+        int monster = Monster.pack(fbb, mObject);
+        Monster.finishMonsterBuffer(fbb, monster);
+        TestBuffer(fbb.dataBuffer());
+
+        byte[] bytes = mObject.serializeToBinary();
+        MonsterT newMonsterT = MonsterT.deserializeFromBinary(bytes);
+        TestObject(newMonsterT);
+    }
+}
diff --git a/java/src/test/java/MyGame b/java/src/test/java/MyGame
new file mode 120000
index 0000000..0ba918e
--- /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 0000000..37a8d89
--- /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 0000000..c1e44a8
--- /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 0000000..44a35f9
--- /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 0000000..cc82221
--- /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 0000000..da0ed86
--- /dev/null
+++ b/java/src/test/resources/monsterdata_test.mon
Binary files differ