From 681a73ebc554597ef5c9830f7a9bd95e41ae25d1 Mon Sep 17 00:00:00 2001 From: Clemente Date: Fri, 8 Dec 2023 18:02:28 +0100 Subject: [PATCH] More tests --- .../kotlin/entities/adapters/AllTypes.kt | 410 ++++++++++++++++++ .../kotlin/test/common/TypeAdapterTests.kt | 34 +- .../kotlin/test/compiler/TypeAdaptersTests.kt | 6 +- 3 files changed, 436 insertions(+), 14 deletions(-) create mode 100644 packages/test-base/src/commonMain/kotlin/io/realm/kotlin/entities/adapters/AllTypes.kt diff --git a/packages/test-base/src/commonMain/kotlin/io/realm/kotlin/entities/adapters/AllTypes.kt b/packages/test-base/src/commonMain/kotlin/io/realm/kotlin/entities/adapters/AllTypes.kt new file mode 100644 index 0000000000..308df35156 --- /dev/null +++ b/packages/test-base/src/commonMain/kotlin/io/realm/kotlin/entities/adapters/AllTypes.kt @@ -0,0 +1,410 @@ +package io.realm.kotlin.entities.adapters + +import io.realm.kotlin.ext.asBsonObjectId +import io.realm.kotlin.ext.asRealmObject +import io.realm.kotlin.types.ObjectId +import io.realm.kotlin.types.RealmAny +import io.realm.kotlin.types.RealmInstant +import io.realm.kotlin.types.RealmObject +import io.realm.kotlin.types.RealmTypeAdapter +import io.realm.kotlin.types.RealmUUID +import io.realm.kotlin.types.annotations.TypeAdapter +import org.mongodb.kbson.BsonDecimal128 +import org.mongodb.kbson.BsonObjectId +import org.mongodb.kbson.Decimal128 + + +@Suppress("MagicNumber") +class AllTypes : RealmObject { + + @TypeAdapter(StringAdapter::class) + var stringField: String = "Realm" + + @TypeAdapter(BooleanAdapter::class) + var booleanField: Boolean = true + + @TypeAdapter(FloatAdapter::class) + var floatField: Float = 3.14f + + @TypeAdapter(DoubleAdapter::class) + var doubleField: Double = 1.19840122 + + @TypeAdapter(Decimal128Adapter::class) + var decimal128Field: Decimal128 = BsonDecimal128("1.8446744073709551618E-6157") + + @TypeAdapter(TimestampAdapter::class) + var timestampField: RealmInstant = RealmInstant.from(100, 1000) + + @TypeAdapter(ObjectIdAdapter::class) + var objectIdField: ObjectId = ObjectId.from("507f1f77bcf86cd799439011") + + @TypeAdapter(BsonObjectIdAdapter::class) + var bsonObjectIdField: BsonObjectId = BsonObjectId("507f1f77bcf86cd799439011") + + @TypeAdapter(UuidAdapter::class) + var uuidField: RealmUUID = RealmUUID.from("46423f1b-ce3e-4a7e-812f-004cf9c42d76") + + @TypeAdapter(BinaryAdapter::class) + var binaryField: ByteArray = byteArrayOf(42) + + @TypeAdapter(NullableStringAdapter::class) + var nullableStringField: String? = null + + @TypeAdapter(NullableBooleanAdapter::class) + var nullableBooleanField: Boolean? = null + + @TypeAdapter(NullableFloatAdapter::class) + var nullableFloatField: Float? = null + + @TypeAdapter(NullableDoubleAdapter::class) + var nullableDoubleField: Double? = null + + @TypeAdapter(NullableDecimal128Adapter::class) + var nullableDecimal128Field: Decimal128? = null + + @TypeAdapter(NullableTimestampAdapter::class) + var nullableTimestampField: RealmInstant? = null + + @TypeAdapter(NullableObjectIdAdapter::class) + var nullableObjectIdField: ObjectId? = null + + @TypeAdapter(NullableBsonObjectIdAdapter::class) + var nullableBsonObjectIdField: BsonObjectId? = null + + @TypeAdapter(NullableUuidAdapter::class) + var nullableUuidField: RealmUUID? = null + + @TypeAdapter(NullableBinaryAdapter::class) + var nullableBinaryField: ByteArray? = null + + @TypeAdapter(RealmAnyAdapter::class) + var nullableRealmAnyField: RealmAny? = null + +// var nullableObject: Sample? = null +// +// var stringListField: RealmList = realmListOf() +// var byteListField: RealmList = realmListOf() +// var charListField: RealmList = realmListOf() +// var shortListField: RealmList = realmListOf() +// var intListField: RealmList = realmListOf() +// var longListField: RealmList = realmListOf() +// var booleanListField: RealmList = realmListOf() +// var floatListField: RealmList = realmListOf() +// var doubleListField: RealmList = realmListOf() +// var timestampListField: RealmList = realmListOf() +// var objectIdListField: RealmList = realmListOf() +// var bsonObjectIdListField: RealmList = realmListOf() +// var uuidListField: RealmList = realmListOf() +// var binaryListField: RealmList = realmListOf() +// var decimal128ListField: RealmList = realmListOf() +// var objectListField: RealmList = realmListOf() +// +// var nullableStringListField: RealmList = realmListOf() +// var nullableByteListField: RealmList = realmListOf() +// var nullableCharListField: RealmList = realmListOf() +// var nullableShortListField: RealmList = realmListOf() +// var nullableIntListField: RealmList = realmListOf() +// var nullableLongListField: RealmList = realmListOf() +// var nullableBooleanListField: RealmList = realmListOf() +// var nullableFloatListField: RealmList = realmListOf() +// var nullableDoubleListField: RealmList = realmListOf() +// var nullableTimestampListField: RealmList = realmListOf() +// var nullableObjectIdListField: RealmList = realmListOf() +// var nullableBsonObjectIdListField: RealmList = realmListOf() +// var nullableUUIDListField: RealmList = realmListOf() +// var nullableBinaryListField: RealmList = realmListOf() +// var nullableDecimal128ListField: RealmList = realmListOf() +// var nullableRealmAnyListField: RealmList = realmListOf() +// +// var stringSetField: RealmSet = realmSetOf() +// var byteSetField: RealmSet = realmSetOf() +// var charSetField: RealmSet = realmSetOf() +// var shortSetField: RealmSet = realmSetOf() +// var intSetField: RealmSet = realmSetOf() +// var longSetField: RealmSet = realmSetOf() +// var booleanSetField: RealmSet = realmSetOf() +// var floatSetField: RealmSet = realmSetOf() +// var doubleSetField: RealmSet = realmSetOf() +// var timestampSetField: RealmSet = realmSetOf() +// var objectIdSetField: RealmSet = realmSetOf() +// var bsonObjectIdSetField: RealmSet = realmSetOf() +// var uuidSetField: RealmSet = realmSetOf() +// var binarySetField: RealmSet = realmSetOf() +// var decimal128SetField: RealmSet = realmSetOf() +// var objectSetField: RealmSet = realmSetOf() +// +// var nullableStringSetField: RealmSet = realmSetOf() +// var nullableByteSetField: RealmSet = realmSetOf() +// var nullableCharSetField: RealmSet = realmSetOf() +// var nullableShortSetField: RealmSet = realmSetOf() +// var nullableIntSetField: RealmSet = realmSetOf() +// var nullableLongSetField: RealmSet = realmSetOf() +// var nullableBooleanSetField: RealmSet = realmSetOf() +// var nullableFloatSetField: RealmSet = realmSetOf() +// var nullableDoubleSetField: RealmSet = realmSetOf() +// var nullableTimestampSetField: RealmSet = realmSetOf() +// var nullableObjectIdSetField: RealmSet = realmSetOf() +// var nullableBsonObjectIdSetField: RealmSet = realmSetOf() +// var nullableUUIDSetField: RealmSet = realmSetOf() +// var nullableBinarySetField: RealmSet = realmSetOf() +// var nullableDecimal128SetField: RealmSet = realmSetOf() +// var nullableRealmAnySetField: RealmSet = realmSetOf() +// +// var stringDictionaryField: RealmDictionary = realmDictionaryOf() +// var byteDictionaryField: RealmDictionary = realmDictionaryOf() +// var charDictionaryField: RealmDictionary = realmDictionaryOf() +// var shortDictionaryField: RealmDictionary = realmDictionaryOf() +// var intDictionaryField: RealmDictionary = realmDictionaryOf() +// var longDictionaryField: RealmDictionary = realmDictionaryOf() +// var booleanDictionaryField: RealmDictionary = realmDictionaryOf() +// var floatDictionaryField: RealmDictionary = realmDictionaryOf() +// var doubleDictionaryField: RealmDictionary = realmDictionaryOf() +// var timestampDictionaryField: RealmDictionary = realmDictionaryOf() +// var objectIdDictionaryField: RealmDictionary = realmDictionaryOf() +// var bsonObjectIdDictionaryField: RealmDictionary = realmDictionaryOf() +// var uuidDictionaryField: RealmDictionary = realmDictionaryOf() +// var binaryDictionaryField: RealmDictionary = realmDictionaryOf() +// var decimal128DictionaryField: RealmDictionary = realmDictionaryOf() +// +// var nullableStringDictionaryField: RealmDictionary = realmDictionaryOf() +// var nullableByteDictionaryField: RealmDictionary = realmDictionaryOf() +// var nullableCharDictionaryField: RealmDictionary = realmDictionaryOf() +// var nullableShortDictionaryField: RealmDictionary = realmDictionaryOf() +// var nullableIntDictionaryField: RealmDictionary = realmDictionaryOf() +// var nullableLongDictionaryField: RealmDictionary = realmDictionaryOf() +// var nullableBooleanDictionaryField: RealmDictionary = realmDictionaryOf() +// var nullableFloatDictionaryField: RealmDictionary = realmDictionaryOf() +// var nullableDoubleDictionaryField: RealmDictionary = realmDictionaryOf() +// var nullableTimestampDictionaryField: RealmDictionary = realmDictionaryOf() +// var nullableObjectIdDictionaryField: RealmDictionary = realmDictionaryOf() +// var nullableBsonObjectIdDictionaryField: RealmDictionary = realmDictionaryOf() +// var nullableUUIDDictionaryField: RealmDictionary = realmDictionaryOf() +// var nullableBinaryDictionaryField: RealmDictionary = realmDictionaryOf() +// var nullableDecimal128DictionaryField: RealmDictionary = realmDictionaryOf() +// var nullableRealmAnyDictionaryField: RealmDictionary = realmDictionaryOf() +// var nullableObjectDictionaryFieldNotNull: RealmDictionary = realmDictionaryOf() +// var nullableObjectDictionaryFieldNull: RealmDictionary = realmDictionaryOf() +// +// val objectBacklinks by backlinks(Sample::nullableObject) +// val listBacklinks by backlinks(Sample::objectListField) +// val setBacklinks by backlinks(Sample::objectSetField) +// +// @PersistedName("persistedStringField") +// var publicStringField = "Realm" +// +// // For verification that references inside class is also using our modified accessors and are +// // not optimized to use the backing field directly. +// fun stringFieldGetter(): String { +// return stringField +// } +// +// fun stringFieldSetter(s: String) { +// stringField = s +// } + + companion object { + // Empty object required by SampleTests + } + + override fun equals(other: Any?): Boolean { + if (this === other) return true + if (other == null || this::class != other::class) return false + + other as AllTypes + + if (stringField != other.stringField) return false + if (booleanField != other.booleanField) return false + if (floatField != other.floatField) return false + if (doubleField != other.doubleField) return false + if (decimal128Field != other.decimal128Field) return false + if (timestampField != other.timestampField) return false + if (objectIdField != other.objectIdField) return false + if (bsonObjectIdField != other.bsonObjectIdField) return false + if (uuidField != other.uuidField) return false + if (!binaryField.contentEquals(other.binaryField)) return false + if (nullableStringField != other.nullableStringField) return false + if (nullableBooleanField != other.nullableBooleanField) return false + if (nullableFloatField != other.nullableFloatField) return false + if (nullableDoubleField != other.nullableDoubleField) return false + if (nullableDecimal128Field != other.nullableDecimal128Field) return false + if (nullableTimestampField != other.nullableTimestampField) return false + if (nullableObjectIdField != other.nullableObjectIdField) return false + if (nullableBsonObjectIdField != other.nullableBsonObjectIdField) return false + if (nullableUuidField != other.nullableUuidField) return false + if (nullableBinaryField != null) { + if (other.nullableBinaryField == null) return false + if (!nullableBinaryField.contentEquals(other.nullableBinaryField)) return false + } else if (other.nullableBinaryField != null) return false + if (nullableRealmAnyField != other.nullableRealmAnyField) return false + + return true + } + + override fun hashCode(): Int { + var result = stringField.hashCode() + result = 31 * result + booleanField.hashCode() + result = 31 * result + floatField.hashCode() + result = 31 * result + doubleField.hashCode() + result = 31 * result + decimal128Field.hashCode() + result = 31 * result + timestampField.hashCode() + result = 31 * result + objectIdField.hashCode() + result = 31 * result + bsonObjectIdField.hashCode() + result = 31 * result + uuidField.hashCode() + result = 31 * result + binaryField.contentHashCode() + result = 31 * result + (nullableStringField?.hashCode() ?: 0) + result = 31 * result + (nullableBooleanField?.hashCode() ?: 0) + result = 31 * result + (nullableFloatField?.hashCode() ?: 0) + result = 31 * result + (nullableDoubleField?.hashCode() ?: 0) + result = 31 * result + (nullableDecimal128Field?.hashCode() ?: 0) + result = 31 * result + (nullableTimestampField?.hashCode() ?: 0) + result = 31 * result + (nullableObjectIdField?.hashCode() ?: 0) + result = 31 * result + (nullableBsonObjectIdField?.hashCode() ?: 0) + result = 31 * result + (nullableUuidField?.hashCode() ?: 0) + result = 31 * result + (nullableBinaryField?.contentHashCode() ?: 0) + result = 31 * result + (nullableRealmAnyField?.hashCode() ?: 0) + return result + } + +} + +// Passthrough converters +object StringAdapter : RealmTypeAdapter { + override fun fromRealm(realmValue: String): String = realmValue.toString() + + override fun toRealm(value: String): String = value.toString() +} + +object BooleanAdapter : RealmTypeAdapter { + override fun fromRealm(realmValue: Boolean): Boolean = realmValue.not().not() + + override fun toRealm(value: Boolean): Boolean = value.not().not() +} + +object FloatAdapter : RealmTypeAdapter { + override fun fromRealm(realmValue: Float): Float = realmValue.toFloat() + + override fun toRealm(value: Float): Float = value.toFloat() +} + +object DoubleAdapter : RealmTypeAdapter { + override fun fromRealm(realmValue: Double): Double = realmValue.toDouble() + + override fun toRealm(value: Double): Double = value.toDouble() +} + +object Decimal128Adapter : RealmTypeAdapter { + override fun fromRealm(realmValue: Decimal128): Decimal128 = Decimal128.fromIEEE754BIDEncoding(realmValue.high, realmValue.low) + + override fun toRealm(value: Decimal128): Decimal128 = Decimal128.fromIEEE754BIDEncoding(value.high, value.low) +} + +object TimestampAdapter : RealmTypeAdapter { + override fun fromRealm(realmValue: RealmInstant): RealmInstant = RealmInstant.from(realmValue.epochSeconds, realmValue.nanosecondsOfSecond) + + override fun toRealm(value: RealmInstant): RealmInstant = RealmInstant.from(value.epochSeconds, value.nanosecondsOfSecond) +} + +object ObjectIdAdapter : RealmTypeAdapter { + override fun fromRealm(realmValue: ObjectId): ObjectId = ObjectId.from(realmValue.asBsonObjectId().toHexString()) + + override fun toRealm(value: ObjectId): ObjectId = ObjectId.from(value.asBsonObjectId().toHexString()) +} + +object BsonObjectIdAdapter : RealmTypeAdapter { + override fun fromRealm(realmValue: BsonObjectId): BsonObjectId = BsonObjectId(realmValue.toHexString()) + + override fun toRealm(value: BsonObjectId): BsonObjectId = BsonObjectId(value.toHexString()) +} + +object UuidAdapter : RealmTypeAdapter { + override fun fromRealm(realmValue: RealmUUID): RealmUUID = RealmUUID.from(realmValue.bytes) + + override fun toRealm(value: RealmUUID): RealmUUID = RealmUUID.from(value.bytes) +} + +object BinaryAdapter : RealmTypeAdapter { + override fun fromRealm(realmValue: ByteArray): ByteArray = realmValue.copyOf() + + override fun toRealm(value: ByteArray): ByteArray = value.copyOf() +} + + +object NullableStringAdapter : RealmTypeAdapter { + override fun fromRealm(realmValue: String?): String? = realmValue?.toString() + + override fun toRealm(value: String?): String? = value?.toString() +} + +object NullableBooleanAdapter : RealmTypeAdapter { + override fun fromRealm(realmValue: Boolean?): Boolean? = realmValue?.not()?.not() + + override fun toRealm(value: Boolean?): Boolean? = value?.not()?.not() +} + +object NullableFloatAdapter : RealmTypeAdapter { + override fun fromRealm(realmValue: Float?): Float? = realmValue?.toFloat() + + override fun toRealm(value: Float?): Float? = value?.toFloat() +} + +object NullableDoubleAdapter : RealmTypeAdapter { + override fun fromRealm(realmValue: Double?): Double? = realmValue?.toDouble() + + override fun toRealm(value: Double?): Double? = value?.toDouble() +} + +object NullableDecimal128Adapter : RealmTypeAdapter { + override fun fromRealm(realmValue: Decimal128?): Decimal128? = realmValue?.let { Decimal128.fromIEEE754BIDEncoding(realmValue.high, realmValue.low) } + + override fun toRealm(value: Decimal128?): Decimal128? = value?.let { Decimal128.fromIEEE754BIDEncoding(value.high, value.low) } +} + +object NullableTimestampAdapter : RealmTypeAdapter { + override fun fromRealm(realmValue: RealmInstant?): RealmInstant? = realmValue?.let { RealmInstant.from(realmValue.epochSeconds, realmValue.nanosecondsOfSecond) } + + override fun toRealm(value: RealmInstant?): RealmInstant? = value?.let { RealmInstant.from(value.epochSeconds, value.nanosecondsOfSecond) } +} + +object NullableObjectIdAdapter : RealmTypeAdapter { + override fun fromRealm(realmValue: ObjectId?): ObjectId? = realmValue?.let { ObjectId.from(realmValue.asBsonObjectId().toHexString()) } + + override fun toRealm(value: ObjectId?): ObjectId? = value?.let { ObjectId.from(value.asBsonObjectId().toHexString()) } +} + +object NullableBsonObjectIdAdapter : RealmTypeAdapter { + override fun fromRealm(realmValue: BsonObjectId?): BsonObjectId? = realmValue?.let { BsonObjectId(realmValue.toHexString()) } + + override fun toRealm(value: BsonObjectId?): BsonObjectId? = value?.let { BsonObjectId(value.toHexString()) } +} + +object NullableUuidAdapter : RealmTypeAdapter { + override fun fromRealm(realmValue: RealmUUID?): RealmUUID? = realmValue?.let { RealmUUID.from(realmValue.bytes) } + + override fun toRealm(value: RealmUUID?): RealmUUID? = value?.let { RealmUUID.from(value.bytes) } +} + +object NullableBinaryAdapter : RealmTypeAdapter { + override fun fromRealm(realmValue: ByteArray?): ByteArray? = realmValue?.let { realmValue.copyOf() } + + override fun toRealm(value: ByteArray?): ByteArray? = value?.let { value.copyOf() } +} + +object RealmAnyAdapter : RealmTypeAdapter { + override fun fromRealm(realmValue: RealmAny?): RealmAny? = realmValue?.let { realmValue.clone() } + + override fun toRealm(value: RealmAny?): RealmAny? = value?.let { value.clone() } +} + +internal fun RealmAny.clone() = when(type) { + RealmAny.Type.INT -> RealmAny.create(asInt()) + RealmAny.Type.BOOL -> RealmAny.create(asBoolean()) + RealmAny.Type.STRING -> RealmAny.create(asString()) + RealmAny.Type.BINARY -> RealmAny.create(asByteArray()) + RealmAny.Type.TIMESTAMP -> RealmAny.create(asRealmInstant()) + RealmAny.Type.FLOAT -> RealmAny.create(asFloat()) + RealmAny.Type.DOUBLE -> RealmAny.create(asDouble()) + RealmAny.Type.DECIMAL128 -> RealmAny.create(asDecimal128()) + RealmAny.Type.OBJECT_ID -> RealmAny.create(asObjectId()) + RealmAny.Type.UUID -> RealmAny.create(asRealmUUID()) + RealmAny.Type.OBJECT -> RealmAny.create(asRealmObject()) +} diff --git a/packages/test-base/src/commonTest/kotlin/io/realm/kotlin/test/common/TypeAdapterTests.kt b/packages/test-base/src/commonTest/kotlin/io/realm/kotlin/test/common/TypeAdapterTests.kt index 9812865ac5..9c047b0dd6 100644 --- a/packages/test-base/src/commonTest/kotlin/io/realm/kotlin/test/common/TypeAdapterTests.kt +++ b/packages/test-base/src/commonTest/kotlin/io/realm/kotlin/test/common/TypeAdapterTests.kt @@ -17,6 +17,7 @@ package io.realm.kotlin.test.common import io.realm.kotlin.Realm import io.realm.kotlin.RealmConfiguration +import io.realm.kotlin.entities.adapters.AllTypes import io.realm.kotlin.entities.adapters.RealmInstantBsonDateTimeAdapterInstanced import io.realm.kotlin.entities.adapters.UsingInstancedAdapter //import io.realm.kotlin.entities.adapters.UsingInstancedAdapter @@ -55,7 +56,7 @@ class TypeAdapterTests { @BeforeTest fun setup() { tmpDir = PlatformUtils.createTempDir() - configuration = RealmConfiguration.Builder(setOf(UsingSingletonAdapter::class, UsingInstancedAdapter::class)) + configuration = RealmConfiguration.Builder(setOf(UsingSingletonAdapter::class, UsingInstancedAdapter::class, AllTypes::class)) .directory(tmpDir) .typeAdapters { add(RealmInstantBsonDateTimeAdapterInstanced()) @@ -76,32 +77,43 @@ class TypeAdapterTests { fun useSingletonAdapter() { val expectedDate = BsonDateTime() - val adapted = UsingSingletonAdapter().apply { + val unmanagedObject = UsingSingletonAdapter().apply { this.date = expectedDate } - assertEquals(expectedDate, adapted.date) + assertEquals(expectedDate, unmanagedObject.date) - val storedAdapted = realm.writeBlocking { - copyToRealm(adapted) + val managedObject = realm.writeBlocking { + copyToRealm(unmanagedObject) } - assertEquals(expectedDate, storedAdapted.date) + assertEquals(expectedDate, managedObject.date) } @Test fun useInstancedAdapter() { val expectedDate = BsonDateTime() - val adapted = UsingInstancedAdapter().apply { + val unmanagedObject = UsingInstancedAdapter().apply { this.date = expectedDate } - assertEquals(expectedDate, adapted.date) + assertEquals(expectedDate, unmanagedObject.date) - val storedAdapted = realm.writeBlocking { - copyToRealm(adapted) + val managedObject = realm.writeBlocking { + copyToRealm(unmanagedObject) } - assertEquals(expectedDate, storedAdapted.date) + assertEquals(expectedDate, managedObject.date) + } + + @Test + fun allTypes() { + val unmanagedObject = AllTypes() + + val managedObject = realm.writeBlocking { + copyToRealm(unmanagedObject) + } + + assertEquals(unmanagedObject, managedObject) } } diff --git a/packages/test-base/src/jvmTest/kotlin/io/realm/kotlin/test/compiler/TypeAdaptersTests.kt b/packages/test-base/src/jvmTest/kotlin/io/realm/kotlin/test/compiler/TypeAdaptersTests.kt index 921ba8cc17..4a1a627f37 100644 --- a/packages/test-base/src/jvmTest/kotlin/io/realm/kotlin/test/compiler/TypeAdaptersTests.kt +++ b/packages/test-base/src/jvmTest/kotlin/io/realm/kotlin/test/compiler/TypeAdaptersTests.kt @@ -20,11 +20,9 @@ import com.tschuchort.compiletesting.KotlinCompilation import com.tschuchort.compiletesting.SourceFile import io.realm.kotlin.internal.interop.CollectionType import io.realm.kotlin.test.util.Compiler.compileFromSource -import io.realm.kotlin.test.util.TypeDescriptor import io.realm.kotlin.test.util.TypeDescriptor.allFieldTypes import io.realm.kotlin.types.MutableRealmInt import io.realm.kotlin.types.ObjectId -import io.realm.kotlin.types.RealmAny import io.realm.kotlin.types.RealmInstant import io.realm.kotlin.types.RealmObject import io.realm.kotlin.types.RealmUUID @@ -39,7 +37,9 @@ import kotlin.test.assertTrue * These tests should validate: * - [x] Adapter with a non-realm type should fail * - [x] Adapter annotation on unsupported types: delegate, function etc - * - [ ] Adapters type supportness + * - [ ] Adapter on wrong type + * - [x] Adapters type supportness + * - [ ] Adapters type unsupportness * - [ ] Instanced and singleton adapters * - [ ] Other annotations Ignore, Index etc */