Flex: support Java Byte and Short.

Author: greenrobot-team

objectbox-java/src/main/java/io/objectbox/converter/FlexObjectConverter.java

@@ -73,6 +73,12 @@ private void addValue(FlexBuffersBuilder builder, Object value) {
             builder.putString((String) value);
         } else if (value instanceof Boolean) {
             builder.putBoolean((Boolean) value);
+        } else if (value instanceof Byte) {
+            // Will always be restored as Integer.
+            builder.putInt(((Byte) value).intValue());
+        } else if (value instanceof Short) {
+            // Will always be restored as Integer.
+            builder.putInt(((Short) value).intValue());
         } else if (value instanceof Integer) {
             builder.putInt((Integer) value);
         } else if (value instanceof Long) {
@@ -119,6 +125,12 @@ private void addMap(FlexBuffersBuilder builder, String mapKey, Map<Object, Objec
                 builder.putString(key, (String) value);
             } else if (value instanceof Boolean) {
                 builder.putBoolean(key, (Boolean) value);
+            } else if (value instanceof Byte) {
+                // Will always be restored as Integer.
+                builder.putInt(key, ((Byte) value).intValue());
+            } else if (value instanceof Short) {
+                // Will always be restored as Integer.
+                builder.putInt(key, ((Short) value).intValue());
             } else if (value instanceof Integer) {
                 builder.putInt(key, (Integer) value);
             } else if (value instanceof Long) {
@@ -155,6 +167,12 @@ private void addVector(FlexBuffersBuilder builder, String vectorKey, List<Object
                 builder.putString((String) item);
             } else if (item instanceof Boolean) {
                 builder.putBoolean((Boolean) item);
+            } else if (item instanceof Byte) {
+                // Will always be restored as Integer.
+                builder.putInt(((Byte) item).intValue());
+            } else if (item instanceof Short) {
+                // Will always be restored as Integer.
+                builder.putInt(((Short) item).intValue());
             } else if (item instanceof Integer) {
                 builder.putInt((Integer) item);
             } else if (item instanceof Long) {

tests/objectbox-java-test/src/test/java/io/objectbox/converter/FlexMapConverterTest.java

@@ -31,10 +31,17 @@ public void keysString_valsSupportedTypes_works() {
 
         map.put("string", "Grüezi");
         map.put("boolean", true);
+        map.put("byte", (byte) 1);
+        map.put("short", (short) 1);
+        map.put("int", 1);
         map.put("long", 1L);
         map.put("float", 1.3f);
         map.put("double", -1.4d);
         Map<String, Object> restoredMap = convertAndBack(map, converter);
+        // Java integers are returned as Long if one value is larger than 32 bits, so expect Long.
+        map.put("byte", 1L);
+        map.put("short", 1L);
+        map.put("int", 1L);
         // Java float is returned as double, so expect double.
         map.put("float", (double) 1.3f);
         assertEquals(map, restoredMap);

tests/objectbox-java-test/src/test/java/io/objectbox/converter/FlexObjectConverterTest.java

@@ -3,10 +3,8 @@
 import org.junit.Test;
 
 import javax.annotation.Nullable;
-import java.util.HashMap;
 import java.util.LinkedList;
 import java.util.List;
-import java.util.Map;
 
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertThrows;
@@ -25,9 +23,15 @@ public void supportedBasicTypes_works() {
 
         convertAndBackThenAssert("Grüezi", converter);
         convertAndBackThenAssert(true, converter);
-        // Java Long is returned as Integer if it fits, so expect Integer.
+        // Java integers are returned as Integer if no value is larger than 32 bits, so expect Integer.
+        Object restoredByte = convertAndBack((byte) 1, converter);
+        assertEquals(1, restoredByte);
+        Object restoredShort = convertAndBack((short) 1, converter);
+        assertEquals(1, restoredShort);
+        Object restoredInteger = convertAndBack(1, converter);
+        assertEquals(1, restoredInteger);
         Object restoredLong = convertAndBack(1L, converter);
-        assertEquals((int) 1L, restoredLong);
+        assertEquals(1, restoredLong);
         // Java Float is returned as Double, so expect Double.
         Object restoredFloat = convertAndBack(1.3f, converter);
         assertEquals((double) 1.3f, restoredFloat);
@@ -45,12 +49,19 @@ public void list_works() {
         // list with supported types
         list.add("Grüezi");
         list.add(true);
+        list.add((byte) 1);
+        list.add((short) 1);
+        list.add(1);
         list.add(-2L);
         list.add(1.3f);
         list.add(-1.4d);
         List<Object> restoredList = convertAndBack(list, converter);
+        // Java integers are returned as Long as one element is larger than 32 bits, so expect Long.
+        list.set(2, 1L);
+        list.set(3, 1L);
+        list.set(4, 1L);
         // Java Float is returned as Double, so expect Double.
-        list.set(3, (double) 1.3f);
+        list.set(6, (double) 1.3f);
         assertEquals(list, restoredList);
 
         // list with null element