Examples with MappedAllJavaTypes io.realm.entities.MappedAllJavaTypes used on opensource projects

Example 1 with MappedAllJavaTypes

use of io.realm.entities.MappedAllJavaTypes in project realm-java by realm.

the class RealmResultsTests method setValue_specificType_modelClassNameOnTypedRealms.

@Test
public void setValue_specificType_modelClassNameOnTypedRealms() {
    populateMappedAllJavaTypes(5);
    RealmResults<MappedAllJavaTypes> collection = realm.where(MappedAllJavaTypes.class).findAll();
    realm.beginTransaction();
    for (BulkSetMethods type : BulkSetMethods.values()) {
        switch(type) {
            case STRING:
                collection.setString("fieldString", "foo");
                assertElements(collection, obj -> assertEquals("foo", obj.fieldString));
                break;
            case BOOLEAN:
                collection.setBoolean("fieldBoolean", true);
                assertElements(collection, obj -> assertTrue(obj.fieldBoolean));
                break;
            case BYTE:
                collection.setByte("fieldByte", (byte) 1);
                assertElements(collection, obj -> assertEquals((byte) 1, obj.fieldByte));
                break;
            case SHORT:
                collection.setShort("fieldShort", (short) 2);
                assertElements(collection, obj -> assertEquals((short) 2, obj.fieldShort));
                break;
            case INTEGER:
                collection.setInt("fieldInt", 3);
                assertElements(collection, obj -> assertEquals(3, obj.fieldInt));
                break;
            case LONG:
                collection.setLong("fieldLong", 4L);
                assertElements(collection, obj -> assertEquals(4L, obj.fieldLong));
                break;
            case FLOAT:
                collection.setFloat("fieldFloat", 1.23F);
                assertElements(collection, obj -> assertEquals(1.23F, obj.fieldFloat, 0F));
                break;
            case DOUBLE:
                collection.setDouble("fieldDouble", 1.234);
                assertElements(collection, obj -> assertEquals(1.234, obj.fieldDouble, 0F));
                break;
            case BINARY:
                collection.setBlob("fieldBinary", new byte[] { 1, 2, 3 });
                assertElements(collection, obj -> assertArrayEquals(new byte[] { 1, 2, 3 }, obj.fieldBinary));
                break;
            case DATE:
                collection.setDate("fieldDate", new Date(1000));
                assertElements(collection, obj -> assertEquals(new Date(1000), obj.fieldDate));
                break;
            case DECIMAL128:
                collection.setDecimal128("fieldDecimal128", new Decimal128(1000));
                assertElements(collection, obj -> assertEquals(new Decimal128(1000), obj.fieldDecimal128));
                break;
            case OBJECT_ID:
                {
                    String hex = TestHelper.randomObjectIdHexString();
                    collection.setObjectId("fieldObjectId", new ObjectId(hex));
                    assertElements(collection, obj -> assertEquals(new ObjectId(hex), obj.fieldObjectId));
                    break;
                }
            case UUID:
                {
                    String uuid = UUID.randomUUID().toString();
                    collection.setUUID("fieldUUID", UUID.fromString(uuid));
                    assertElements(collection, obj -> assertEquals(UUID.fromString(uuid), obj.fieldUUID));
                    break;
                }
            case OBJECT:
                {
                    MappedAllJavaTypes childObj = realm.createObject(MappedAllJavaTypes.class, 42);
                    collection.setObject("fieldObject", childObj);
                    assertElements(collection, obj -> assertEquals(childObj, obj.fieldObject));
                    break;
                }
            case MODEL_LIST:
                {
                    MappedAllJavaTypes childObj = realm.createObject(MappedAllJavaTypes.class, 43);
                    collection.setList("fieldList", new RealmList<>(childObj));
                    assertElements(collection, obj -> {
                        assertEquals(1, obj.fieldList.size());
                        assertEquals(childObj, obj.fieldList.first());
                    });
                    break;
                }
            case STRING_VALUE_LIST:
                collection.setList("fieldStringList", new RealmList<>("Foo"));
                assertElements(collection, obj -> {
                    assertEquals(1, obj.fieldStringList.size());
                    assertEquals("Foo", obj.fieldStringList.first());
                });
                break;
            case BOOLEAN_VALUE_LIST:
                collection.setList("fieldBooleanList", new RealmList<>(true));
                assertElements(collection, obj -> {
                    assertEquals(1, obj.fieldBooleanList.size());
                    assertEquals(true, obj.fieldBooleanList.first());
                });
                break;
            case BYTE_VALUE_LIST:
                collection.setList("fieldByteList", new RealmList<>((byte) 1));
                assertElements(collection, obj -> {
                    assertEquals(1, obj.fieldByteList.size());
                    assertEquals(Byte.valueOf((byte) 1), obj.fieldByteList.first());
                });
                break;
            case SHORT_VALUE_LIST:
                collection.setList("fieldShortList", new RealmList<>((short) 1));
                assertElements(collection, obj -> {
                    assertEquals(1, obj.fieldShortList.size());
                    assertEquals(Short.valueOf((short) 1), obj.fieldShortList.first());
                });
                break;
            case INTEGER_VALUE_LIST:
                collection.setList("fieldIntegerList", new RealmList<>(1));
                assertElements(collection, obj -> {
                    assertEquals(1, obj.fieldIntegerList.size());
                    assertEquals(Integer.valueOf(1), obj.fieldIntegerList.first());
                });
                break;
            case LONG_VALUE_LIST:
                collection.setList("fieldLongList", new RealmList<>(1L));
                assertElements(collection, obj -> {
                    assertEquals(1, obj.fieldLongList.size());
                    assertEquals(Long.valueOf((byte) 1), obj.fieldLongList.first());
                });
                break;
            case FLOAT_VALUE_LIST:
                collection.setList("fieldFloatList", new RealmList<>(1.1F));
                assertElements(collection, obj -> {
                    assertEquals(1, obj.fieldFloatList.size());
                    assertEquals(1.1F, obj.fieldFloatList.first(), 0F);
                });
                break;
            case DOUBLE_VALUE_LIST:
                collection.setList("fieldDoubleList", new RealmList<>(1.1D));
                assertElements(collection, obj -> {
                    assertEquals(1, obj.fieldDoubleList.size());
                    assertEquals(1.1D, obj.fieldDoubleList.first(), 0F);
                });
                break;
            case BINARY_VALUE_LIST:
                collection.setList("fieldBinaryList", new RealmList<>(new byte[] { 1, 2, 3 }));
                assertElements(collection, obj -> {
                    assertEquals(1, obj.fieldBinaryList.size());
                    assertArrayEquals(new byte[] { 1, 2, 3 }, obj.fieldBinaryList.first());
                });
                break;
            case DATE_VALUE_LIST:
                collection.setList("fieldDateList", new RealmList<>(new Date(1000)));
                assertElements(collection, obj -> {
                    assertEquals(1, obj.fieldDateList.size());
                    assertEquals(new Date(1000), obj.fieldDateList.first());
                });
                break;
            case DECIMAL128_VALUE_LIST:
                collection.setList("fieldDecimalList", new RealmList<>(new Decimal128(1000)));
                assertElements(collection, obj -> {
                    assertEquals(1, obj.fieldDecimalList.size());
                    assertEquals(new Decimal128(1000), obj.fieldDecimalList.first());
                });
                break;
            case OBJECT_ID_VALUE_LIST:
                {
                    String hex = TestHelper.randomObjectIdHexString();
                    collection.setList("fieldObjectIdList", new RealmList<>(new ObjectId(hex)));
                    assertElements(collection, obj -> {
                        assertEquals(1, obj.fieldObjectIdList.size());
                        assertEquals(new ObjectId(hex), obj.fieldObjectIdList.first());
                    });
                    break;
                }
            case UUID_VALUE_LIST:
                {
                    String uuid = UUID.randomUUID().toString();
                    collection.setList("fieldUUIDList", new RealmList<>(UUID.fromString(uuid)));
                    assertElements(collection, obj -> {
                        assertEquals(1, obj.fieldUUIDList.size());
                        assertEquals(UUID.fromString(uuid), obj.fieldUUIDList.first());
                    });
                    break;
                }
            default:
                fail("Unknown type: " + type);
        }
    }
}

Example 2 with MappedAllJavaTypes

use of io.realm.entities.MappedAllJavaTypes in project realm-java by realm.

the class RealmResultsTests method populateMappedAllJavaTypes.

private void populateMappedAllJavaTypes(int objects) {
    realm.beginTransaction();
    realm.deleteAll();
    for (int i = 0; i < objects; ++i) {
        MappedAllJavaTypes obj = realm.createObject(MappedAllJavaTypes.class, i);
        obj.fieldBoolean = ((i % 2) == 0);
        obj.fieldBinary = (new byte[] { 1, 2, 3 });
        obj.fieldDate = (new Date(YEAR_MILLIS * (i - objects / 2)));
        obj.fieldDouble = (Math.PI + i);
        obj.fieldFloat = (1.234567f + i);
        obj.fieldString = ("test data " + i);
        obj.fieldLong = i;
        obj.fieldObject = obj;
        obj.fieldDecimal128 = new Decimal128(i);
        obj.fieldObjectId = new ObjectId(TestHelper.generateObjectIdHexString(i));
        obj.fieldUUID = UUID.fromString(TestHelper.generateUUIDString(i));
        obj.fieldList.add(obj);
    }
    realm.commitTransaction();
}

Example 3 with MappedAllJavaTypes

use of io.realm.entities.MappedAllJavaTypes in project realm-java by realm.

the class RealmResultsTests method setValue_specificType_internalNameOnDynamicRealms.

@Test
public void setValue_specificType_internalNameOnDynamicRealms() {
    populateMappedAllJavaTypes(5);
    DynamicRealm dynamicRealm = DynamicRealm.getInstance(realm.getConfiguration());
    dynamicRealm.beginTransaction();
    try {
        RealmResults<DynamicRealmObject> collection = dynamicRealm.where("MappedAllJavaTypes").findAll();
        for (BulkSetMethods type : BulkSetMethods.values()) {
            switch(type) {
                case STRING:
                    collection.setString("field_string", "foo");
                    assertElements(collection, obj -> assertEquals("foo", obj.getString("field_string")));
                    break;
                case BOOLEAN:
                    collection.setBoolean("field_boolean", true);
                    assertElements(collection, obj -> assertTrue(obj.getBoolean("field_boolean")));
                    break;
                case BYTE:
                    collection.setByte("field_byte", (byte) 1);
                    assertElements(collection, obj -> assertEquals((byte) 1, obj.getByte("field_byte")));
                    break;
                case SHORT:
                    collection.setShort("field_short", (short) 2);
                    assertElements(collection, obj -> assertEquals((short) 2, obj.getShort("field_short")));
                    break;
                case INTEGER:
                    collection.setInt("field_int", 3);
                    assertElements(collection, obj -> assertEquals(3, obj.getInt("field_int")));
                    break;
                case LONG:
                    collection.setLong("field_long", 4L);
                    assertElements(collection, obj -> assertEquals(4L, obj.getLong("field_long")));
                    break;
                case FLOAT:
                    collection.setFloat("field_float", 1.23F);
                    assertElements(collection, obj -> assertEquals(1.23F, obj.getFloat("field_float"), 0F));
                    break;
                case DOUBLE:
                    collection.setDouble("field_double", 1.234);
                    assertElements(collection, obj -> assertEquals(1.234, obj.getDouble("field_double"), 0F));
                    break;
                case BINARY:
                    collection.setBlob("field_binary", new byte[] { 1, 2, 3 });
                    assertElements(collection, obj -> assertArrayEquals(new byte[] { 1, 2, 3 }, obj.getBlob("field_binary")));
                    break;
                case DATE:
                    collection.setDate("field_date", new Date(1000));
                    assertElements(collection, obj -> assertEquals(new Date(1000), obj.getDate("field_date")));
                    break;
                case DECIMAL128:
                    collection.setDecimal128("field_decimal128", new Decimal128(1000));
                    assertElements(collection, obj -> assertEquals(new Decimal128(1000), obj.getDecimal128("field_decimal128")));
                    break;
                case OBJECT_ID:
                    {
                        String hex = TestHelper.randomObjectIdHexString();
                        collection.setObjectId("field_object_id", new ObjectId(hex));
                        assertElements(collection, obj -> assertEquals(new ObjectId(hex), obj.getObjectId("field_object_id")));
                        break;
                    }
                case UUID:
                    {
                        String uuid = UUID.randomUUID().toString();
                        collection.setUUID("field_uuid", UUID.fromString(uuid));
                        assertElements(collection, obj -> assertEquals(UUID.fromString(uuid), obj.getUUID("field_uuid")));
                        break;
                    }
                case OBJECT:
                    {
                        DynamicRealmObject childObj = dynamicRealm.createObject("MappedAllJavaTypes", 42);
                        collection.setObject("field_object", childObj);
                        assertElements(collection, obj -> assertEquals(childObj, obj.getObject("field_object")));
                        break;
                    }
                case MODEL_LIST:
                    {
                        DynamicRealmObject childObj = dynamicRealm.createObject("MappedAllJavaTypes", 43);
                        collection.setList("field_list", new RealmList<>(childObj));
                        assertElements(collection, obj -> {
                            RealmList<DynamicRealmObject> list = obj.getList("field_list");
                            assertEquals(1, list.size());
                            assertEquals(childObj, list.first());
                        });
                        break;
                    }
                case STRING_VALUE_LIST:
                    collection.setList("field_string_list", new RealmList<>("Foo"));
                    assertElements(collection, obj -> {
                        RealmList<String> list = obj.getList("field_string_list", String.class);
                        assertEquals(1, list.size());
                        assertEquals("Foo", list.first());
                    });
                    break;
                case BOOLEAN_VALUE_LIST:
                    collection.setList("field_boolean_list", new RealmList<>(true));
                    assertElements(collection, obj -> {
                        RealmList<Boolean> list = obj.getList("field_boolean_list", Boolean.class);
                        assertEquals(1, list.size());
                        assertEquals(true, list.first());
                    });
                    break;
                case BYTE_VALUE_LIST:
                    collection.setList("field_byte_list", new RealmList<>((byte) 1));
                    assertElements(collection, obj -> {
                        RealmList<Byte> list = obj.getList("field_byte_list", Byte.class);
                        assertEquals(1, list.size());
                        assertEquals(Byte.valueOf((byte) 1), list.first());
                    });
                    break;
                case SHORT_VALUE_LIST:
                    collection.setList("field_short_list", new RealmList<>((short) 1));
                    assertElements(collection, obj -> {
                        RealmList<Short> list = obj.getList("field_short_list", Short.class);
                        assertEquals(1, list.size());
                        assertEquals(Short.valueOf((short) 1), list.first());
                    });
                    break;
                case INTEGER_VALUE_LIST:
                    collection.setList("field_integer_list", new RealmList<>(1));
                    assertElements(collection, obj -> {
                        RealmList<Integer> list = obj.getList("field_integer_list", Integer.class);
                        assertEquals(1, list.size());
                        assertEquals(Integer.valueOf(1), list.first());
                    });
                    break;
                case LONG_VALUE_LIST:
                    collection.setList("field_long_list", new RealmList<>(1L));
                    assertElements(collection, obj -> {
                        RealmList<Long> list = obj.getList("field_long_list", Long.class);
                        assertEquals(1, list.size());
                        assertEquals(Long.valueOf((byte) 1), list.first());
                    });
                    break;
                case FLOAT_VALUE_LIST:
                    collection.setList("field_float_list", new RealmList<>(1.1F));
                    assertElements(collection, obj -> {
                        RealmList<Float> list = obj.getList("field_float_list", Float.class);
                        assertEquals(1, list.size());
                        assertEquals(1.1F, list.first(), 0F);
                    });
                    break;
                case DOUBLE_VALUE_LIST:
                    collection.setList("field_double_list", new RealmList<>(1.1D));
                    assertElements(collection, obj -> {
                        RealmList<Double> list = obj.getList("field_double_list", Double.class);
                        assertEquals(1, list.size());
                        assertEquals(1.1D, list.first(), 0F);
                    });
                    break;
                case BINARY_VALUE_LIST:
                    collection.setList("field_binary_list", new RealmList<>(new byte[] { 1, 2, 3 }));
                    assertElements(collection, obj -> {
                        RealmList<byte[]> list = obj.getList("field_binary_list", byte[].class);
                        assertEquals(1, list.size());
                        assertArrayEquals(new byte[] { 1, 2, 3 }, list.first());
                    });
                    break;
                case DATE_VALUE_LIST:
                    collection.setList("field_date_list", new RealmList<>(new Date(1000)));
                    assertElements(collection, obj -> {
                        RealmList<Date> list = obj.getList("field_date_list", Date.class);
                        assertEquals(1, list.size());
                        assertEquals(new Date(1000), list.first());
                    });
                    break;
                case DECIMAL128_VALUE_LIST:
                    collection.setList("field_decimal_list", new RealmList<>(new Decimal128(1000)));
                    assertElements(collection, obj -> {
                        RealmList<Decimal128> list = obj.getList("field_decimal_list", Decimal128.class);
                        assertEquals(1, list.size());
                        assertEquals(new Decimal128(1000), list.first());
                    });
                    break;
                case OBJECT_ID_VALUE_LIST:
                    {
                        String hex = TestHelper.randomObjectIdHexString();
                        collection.setList("field_object_id_list", new RealmList<>(new ObjectId(hex)));
                        assertElements(collection, obj -> {
                            RealmList<ObjectId> list = obj.getList("field_object_id_list", ObjectId.class);
                            assertEquals(1, list.size());
                            assertEquals(new ObjectId(hex), list.first());
                        });
                        break;
                    }
                case UUID_VALUE_LIST:
                    {
                        String uuid = UUID.randomUUID().toString();
                        collection.setList("field_uuid_list", new RealmList<>(UUID.fromString(uuid)));
                        assertElements(collection, obj -> {
                            RealmList<UUID> list = obj.getList("field_uuid_list", UUID.class);
                            assertEquals(1, list.size());
                            assertEquals(UUID.fromString(uuid), list.first());
                        });
                        break;
                    }
                default:
                    fail("Unknown type: " + type);
            }
        }
    } finally {
        dynamicRealm.close();
    }
}