diff --git a/core/src/main/kotlin/org/utbot/jcdb/impl/types/ArrayClassIdImpl.kt b/core/src/main/kotlin/org/utbot/jcdb/impl/types/ArrayClassIdImpl.kt index bf2d56fd6..a58933981 100644 --- a/core/src/main/kotlin/org/utbot/jcdb/impl/types/ArrayClassIdImpl.kt +++ b/core/src/main/kotlin/org/utbot/jcdb/impl/types/ArrayClassIdImpl.kt @@ -8,7 +8,7 @@ import org.utbot.jcdb.impl.signature.Raw class ArrayClassIdImpl(override val elementClass: ClassId) : ArrayClassId { - override val name = elementClass.simpleName + "[]" + override val name = elementClass.name + "[]" override val simpleName = elementClass.simpleName + "[]" override val location: ByteCodeLocation? diff --git a/core/src/main/kotlin/org/utbot/jcdb/impl/types/Objects.kt b/core/src/main/kotlin/org/utbot/jcdb/impl/types/Objects.kt index b532693e7..0292c0541 100644 --- a/core/src/main/kotlin/org/utbot/jcdb/impl/types/Objects.kt +++ b/core/src/main/kotlin/org/utbot/jcdb/impl/types/Objects.kt @@ -2,6 +2,9 @@ package org.utbot.jcdb.impl.types import kotlinx.serialization.Serializable +@Serializable +sealed class ClassInfoContainer + @Serializable class ClassInfo( val name: String, @@ -20,7 +23,7 @@ class ClassInfo( val innerClasses: List, val interfaces: List, val annotations: List -) +) : ClassInfoContainer() @Serializable class OuterClassRef( @@ -56,4 +59,12 @@ class AnnotationInfo( @Serializable class LocationClasses( val classes: List -) \ No newline at end of file +) + +@Serializable +class PredefinedClassInfo(val name: String): ClassInfoContainer() + +@Serializable +class ArrayClassInfo( + val elementInfo: ClassInfoContainer +) : ClassInfoContainer() \ No newline at end of file diff --git a/core/src/main/kotlin/org/utbot/jcdb/impl/types/PredefinedPrimitive.kt b/core/src/main/kotlin/org/utbot/jcdb/impl/types/PredefinedPrimitive.kt index 5b33d0b9a..d510874c5 100644 --- a/core/src/main/kotlin/org/utbot/jcdb/impl/types/PredefinedPrimitive.kt +++ b/core/src/main/kotlin/org/utbot/jcdb/impl/types/PredefinedPrimitive.kt @@ -67,6 +67,8 @@ class PredefinedPrimitive(override val classpath: ClasspathSet, override val sim override suspend fun access() = Opcodes.ACC_PUBLIC + val info = PredefinedClassInfo(name = name) + override fun equals(other: Any?): Boolean { if (this === other) return true if (javaClass != other?.javaClass) return false diff --git a/remote-rd/src/main/kotlin/org/utbot/jcdb/remote/rd/InternalApi.kt b/remote-rd/src/main/kotlin/org/utbot/jcdb/remote/rd/InternalApi.kt index 42fc3ac35..8a21d997e 100644 --- a/remote-rd/src/main/kotlin/org/utbot/jcdb/remote/rd/InternalApi.kt +++ b/remote-rd/src/main/kotlin/org/utbot/jcdb/remote/rd/InternalApi.kt @@ -52,7 +52,7 @@ class GetClassReq(val cpKey: String, val className: String) { } } -class GetClassRes(val location: String, val bytes: ByteArray) { +class GetClassRes(val location: String?, val serializedClassInfo: ByteArray) { companion object : IMarshaller { @@ -60,14 +60,14 @@ class GetClassRes(val location: String, val bytes: ByteArray) { override fun read(ctx: SerializationCtx, buffer: AbstractBuffer): GetClassRes { return GetClassRes( - buffer.readString(), + buffer.readNullableString(), buffer.readByteArray() ) } override fun write(ctx: SerializationCtx, buffer: AbstractBuffer, value: GetClassRes) { - buffer.writeString(value.location) - buffer.writeByteArray(value.bytes) + buffer.writeNullableString(value.location) + buffer.writeByteArray(value.serializedClassInfo) } } } \ No newline at end of file diff --git a/remote-rd/src/main/kotlin/org/utbot/jcdb/remote/rd/RDServer.kt b/remote-rd/src/main/kotlin/org/utbot/jcdb/remote/rd/RDServer.kt index 7c4d90e57..ebbb0bb79 100644 --- a/remote-rd/src/main/kotlin/org/utbot/jcdb/remote/rd/RDServer.kt +++ b/remote-rd/src/main/kotlin/org/utbot/jcdb/remote/rd/RDServer.kt @@ -9,11 +9,12 @@ import com.jetbrains.rd.util.threading.SingleThreadScheduler import kotlinx.coroutines.runBlocking import kotlinx.serialization.cbor.Cbor import kotlinx.serialization.encodeToByteArray +import org.utbot.jcdb.api.ClassId import org.utbot.jcdb.api.ClasspathSet import org.utbot.jcdb.api.Hook import org.utbot.jcdb.compilationDatabase import org.utbot.jcdb.impl.CompilationDatabaseImpl -import org.utbot.jcdb.impl.types.ClassIdImpl +import org.utbot.jcdb.impl.types.* import org.utbot.jcdb.remote.rd.client.RemoteCompilationDatabase import java.io.File import java.util.concurrent.ConcurrentHashMap @@ -53,13 +54,13 @@ class RDServer(port: Int, val db: CompilationDatabaseImpl) : Hook { val key = req.cpKey val cp = classpaths[key] ?: throw IllegalStateException("No classpath found by key $key. \n Create it first") runBlocking { - val classId = cp.findClassOrNull(req.className) as? ClassIdImpl - if (classId != null) { - val bytes = Cbor.encodeToByteArray(classId.info()) - val url = classId.location.locationURL - GetClassRes(url.toString(), bytes) - } else { - null + when (val classId = cp.findClassOrNull(req.className)) { + is ClassId -> { + val bytes = Cbor.encodeToByteArray(classId.convertToContainer()) + val url = classId.location?.locationURL + GetClassRes(url?.toString(), bytes) + } + else -> null } } }.makeAsync() @@ -86,6 +87,15 @@ class RDServer(port: Int, val db: CompilationDatabaseImpl) : Hook { return x } + private suspend fun ClassId.convertToContainer(): ClassInfoContainer { + return when (this) { + is ArrayClassIdImpl -> ArrayClassInfo(elementClass.convertToContainer()) + is ClassIdImpl -> info() + is PredefinedPrimitive -> info + else -> throw IllegalStateException("Can't convert class ${name} to serializable class info") + } + } + } fun RdCall.makeAsync(): RdCall { diff --git a/remote-rd/src/main/kotlin/org/utbot/jcdb/remote/rd/client/RemoteClassId.kt b/remote-rd/src/main/kotlin/org/utbot/jcdb/remote/rd/client/RemoteClassId.kt index 4e5327f0e..dd8b07750 100644 --- a/remote-rd/src/main/kotlin/org/utbot/jcdb/remote/rd/client/RemoteClassId.kt +++ b/remote-rd/src/main/kotlin/org/utbot/jcdb/remote/rd/client/RemoteClassId.kt @@ -13,7 +13,7 @@ import java.net.URL import java.nio.file.Paths class RemoteClassId( - private val locationURL: String, + private val locationURL: String?, private val classInfo: ClassInfo, override val classpath: ClasspathSet ) : ClassId, ByteCodeConverter { @@ -24,11 +24,12 @@ class RemoteClassId( override suspend fun access() = classInfo.access override val location: ByteCodeLocation? by lazy(LazyThreadSafetyMode.NONE) { - Paths.get(URL(locationURL).toURI()).toFile().asByteCodeLocation(isRuntime = false) + locationURL?.let { + Paths.get(URL(it).toURI()).toFile().asByteCodeLocation(isRuntime = false) + } } - override val simpleName: String - get() = classInfo.name + override val simpleName = classInfo.name.substringAfterLast(".") private val lazyInterfaces = suspendableLazy { classInfo.interfaces.map { diff --git a/remote-rd/src/main/kotlin/org/utbot/jcdb/remote/rd/client/RemoteClasspathSet.kt b/remote-rd/src/main/kotlin/org/utbot/jcdb/remote/rd/client/RemoteClasspathSet.kt index 1ea8f0e59..5c203056c 100644 --- a/remote-rd/src/main/kotlin/org/utbot/jcdb/remote/rd/client/RemoteClasspathSet.kt +++ b/remote-rd/src/main/kotlin/org/utbot/jcdb/remote/rd/client/RemoteClasspathSet.kt @@ -7,7 +7,7 @@ import org.utbot.jcdb.api.ByteCodeLocation import org.utbot.jcdb.api.ClassId import org.utbot.jcdb.api.ClasspathSet import org.utbot.jcdb.api.CompilationDatabase -import org.utbot.jcdb.impl.types.ClassInfo +import org.utbot.jcdb.impl.types.* import org.utbot.jcdb.remote.rd.GetClassReq import org.utbot.jcdb.remote.rd.GetClassRes @@ -27,8 +27,8 @@ class RemoteClasspathSet( override suspend fun findClassOrNull(name: String): ClassId? { val res = getClass.startSuspending(GetClassReq(key, name)) ?: return null - val info = Cbor.decodeFromByteArray(res.bytes) - return RemoteClassId(res.location, info, this) + val info = Cbor.decodeFromByteArray(res.serializedClassInfo) + return info.asClassId(res.location) } override suspend fun findSubClasses(name: String, allHierarchy: Boolean): List { @@ -51,4 +51,13 @@ class RemoteClasspathSet( close.start(key) } + private fun ClassInfoContainer.asClassId(location: String?): ClassId { + return when (this) { + is ArrayClassInfo -> ArrayClassIdImpl(elementInfo.asClassId(location)) + is ClassInfo -> RemoteClassId(location, this, this@RemoteClasspathSet) + is PredefinedClassInfo -> PredefinedPrimitives.of(name, this@RemoteClasspathSet) ?: throw IllegalStateException("unsupported predefined name $name") + else -> throw IllegalStateException("unsupported class info container type ${this.javaClass.name}") + } + } + } \ No newline at end of file diff --git a/remote-rd/src/test/kotlin/org/utbot/jcdb/remote/rd/RemoteClientTest.kt b/remote-rd/src/test/kotlin/org/utbot/jcdb/remote/rd/RemoteClientTest.kt index 8d7f6049d..912df9071 100644 --- a/remote-rd/src/test/kotlin/org/utbot/jcdb/remote/rd/RemoteClientTest.kt +++ b/remote-rd/src/test/kotlin/org/utbot/jcdb/remote/rd/RemoteClientTest.kt @@ -1,7 +1,11 @@ package org.utbot.jcdb.remote.rd import kotlinx.coroutines.runBlocking -import org.junit.jupiter.api.* +import org.junit.jupiter.api.AfterAll +import org.junit.jupiter.api.Assertions +import org.junit.jupiter.api.Assertions.* +import org.junit.jupiter.api.Nested +import org.junit.jupiter.api.Test import org.utbot.jcdb.api.* import org.utbot.jcdb.compilationDatabase import org.utbot.jcdb.impl.* @@ -20,10 +24,9 @@ import org.w3c.dom.DocumentType import java.util.* import java.util.concurrent.ConcurrentHashMap -@Disabled class RemoteClientTest { companion object : LibrariesMixin { - var serverDB: CompilationDatabase? = runBlocking { + private var serverDB: CompilationDatabase? = runBlocking { compilationDatabase { predefinedDirOrJars = allClasspath useProcessJavaRuntime() @@ -33,99 +36,95 @@ class RemoteClientTest { } } + private val db = rdDatabase(8080) + + private val cp = runBlocking { db.classpathSet(allClasspath) } + @AfterAll @JvmStatic fun cleanup() { serverDB?.close() serverDB = null + cp.close() + db.close() } } - private val db = rdDatabase(8080) - - private val cp = runBlocking { db.classpathSet(allClasspath) } - - @AfterEach - fun close() { - cp.close() - db.close() - } - @Test fun `find class from build dir folder`() = runBlocking { val clazz = cp.findClass() - Assertions.assertEquals(Foo::class.java.name, clazz.name) - Assertions.assertTrue(clazz.isFinal()) - Assertions.assertTrue(clazz.isPublic()) + assertEquals(Foo::class.java.name, clazz.name) + assertTrue(clazz.isFinal()) + assertTrue(clazz.isPublic()) Assertions.assertFalse(clazz.isInterface()) val annotations = clazz.annotations() - Assertions.assertTrue(annotations.size > 1) - Assertions.assertNotNull(annotations.firstOrNull { it.name == Nested::class.java.name }) + assertTrue(annotations.size > 1) + assertNotNull(annotations.firstOrNull { it.name == Nested::class.java.name }) val fields = clazz.fields() - Assertions.assertEquals(2, fields.size) + assertEquals(2, fields.size) with(fields.first()) { - Assertions.assertEquals("foo", name) - Assertions.assertEquals("int", type().name) + assertEquals("foo", name) + assertEquals("int", type().name) } with(fields[1]) { - Assertions.assertEquals("bar", name) - Assertions.assertEquals(String::class.java.name, type().name) + assertEquals("bar", name) + assertEquals(String::class.java.name, type().name) } val methods = clazz.methods() - Assertions.assertEquals(5, methods.size) + assertEquals(5, methods.size) with(methods.first { it.name == "smthPublic" }) { - Assertions.assertEquals(1, parameters().size) - Assertions.assertEquals("int", parameters().first().name) - Assertions.assertTrue(isPublic()) + assertEquals(1, parameters().size) + assertEquals("int", parameters().first().name) + assertTrue(isPublic()) } with(methods.first { it.name == "smthPrivate" }) { - Assertions.assertTrue(parameters().isEmpty()) - Assertions.assertTrue(isPrivate()) + assertTrue(parameters().isEmpty()) + assertTrue(isPrivate()) } } @Test fun `array types`() = runBlocking { val clazz = cp.findClass() - Assertions.assertEquals(Bar::class.java.name, clazz.name) + assertEquals(Bar::class.java.name, clazz.name) val fields = clazz.fields() - Assertions.assertEquals(3, fields.size) + assertEquals(3, fields.size) with(fields.first()) { - Assertions.assertEquals("byteArray", name) - Assertions.assertEquals("byte[]", type().name) - Assertions.assertEquals(cp.byte, (type() as ArrayClassIdImpl).elementClass) + assertEquals("byteArray", name) + assertEquals("byte[]", type().name) + assertEquals(cp.byte, (type() as ArrayClassIdImpl).elementClass) } with(fields.get(1)) { - Assertions.assertEquals("objectArray", name) - Assertions.assertEquals("Object[]", type().name) - Assertions.assertEquals(cp.findClass(), (type() as ArrayClassIdImpl).elementClass) + assertEquals("objectArray", name) + assertEquals("java.lang.Object[]", type().name) + assertEquals(cp.findClass(), (type() as ArrayClassIdImpl).elementClass) } with(fields.get(2)) { - Assertions.assertEquals("objectObjectArray", name) - Assertions.assertEquals("Object[][]", type().name) - Assertions.assertEquals( + assertEquals("objectObjectArray", name) + assertEquals("java.lang.Object[][]", type().name) + assertEquals( cp.findClass(), ((type() as ArrayClassIdImpl).elementClass as ArrayClassIdImpl).elementClass ) } val methods = clazz.methods() - Assertions.assertEquals(2, methods.size) + assertEquals(2, methods.size) with(methods.first { it.name == "smth" }) { val parameters = parameters() - Assertions.assertEquals(1, parameters.size) - Assertions.assertEquals("byte[]", parameters.first().name) - Assertions.assertEquals("byte[]", returnType().name) + assertEquals(1, parameters.size) + assertEquals("byte[]", parameters.first().name) + assertEquals("byte[]", returnType().name) } } @@ -137,10 +136,10 @@ class RemoteClientTest { val anon = cp.findClass("org.utbot.jcdb.impl.usages.WithInner$1") - Assertions.assertEquals(withInner, anon.outerClass()) - Assertions.assertEquals(withInner, inner.outerClass()) - Assertions.assertEquals(withInner, staticInner.outerClass()) - Assertions.assertEquals(withInner.findMethodOrNull("sayHello", "()V"), anon.outerMethod()) + assertEquals(withInner, anon.outerClass()) + assertEquals(withInner, inner.outerClass()) + assertEquals(withInner, staticInner.outerClass()) + assertEquals(withInner.findMethodOrNull("sayHello", "()V"), anon.outerMethod()) Assertions.assertNull(staticInner.outerMethod()) } @@ -152,7 +151,7 @@ class RemoteClientTest { with(classSignature) { this as TypeResolutionImpl - Assertions.assertEquals("java.lang.Object", (superClass as RawType).name) + assertEquals("java.lang.Object", (superClass as RawType).name) } } @@ -161,61 +160,61 @@ class RemoteClientTest { val a = cp.findClass>() val methodSignatures = a.methods().map { it.name to it.signature() } - Assertions.assertEquals(3, methodSignatures.size) + assertEquals(3, methodSignatures.size) with(methodSignatures[0]) { val (name, signature) = this - Assertions.assertEquals("", name) - Assertions.assertEquals(Raw, signature) + assertEquals("", name) + assertEquals(Raw, signature) } with(methodSignatures[1]) { val (name, signature) = this - Assertions.assertEquals("merge", name) + assertEquals("merge", name) signature as MethodResolutionImpl - Assertions.assertEquals("void", (signature.returnType as PrimitiveType).ref.name) - Assertions.assertEquals(1, signature.parameterTypes.size) + assertEquals("void", (signature.returnType as PrimitiveType).ref.name) + assertEquals(1, signature.parameterTypes.size) with(signature.parameterTypes.first()) { this as ParameterizedType - Assertions.assertEquals(Generics::class.java.name, this.name) - Assertions.assertEquals(1, parameterTypes.size) + assertEquals(Generics::class.java.name, this.name) + assertEquals(1, parameterTypes.size) with(parameterTypes.first()) { this as TypeVariable - Assertions.assertEquals("T", this.symbol) + assertEquals("T", this.symbol) } } - Assertions.assertEquals(1, signature.parameterTypes.size) + assertEquals(1, signature.parameterTypes.size) val parameterizedType = signature.parameterTypes.first() as ParameterizedType - Assertions.assertEquals(1, parameterizedType.parameterTypes.size) - Assertions.assertEquals(Generics::class.java.name, parameterizedType.name) + assertEquals(1, parameterizedType.parameterTypes.size) + assertEquals(Generics::class.java.name, parameterizedType.name) val typeVariable = parameterizedType.parameterTypes.first() as TypeVariable - Assertions.assertEquals("T", typeVariable.symbol) + assertEquals("T", typeVariable.symbol) } with(methodSignatures[2]) { val (name, signature) = this - Assertions.assertEquals("merge1", name) + assertEquals("merge1", name) signature as MethodResolutionImpl - Assertions.assertEquals("W", (signature.returnType as TypeVariable).symbol) + assertEquals("W", (signature.returnType as TypeVariable).symbol) - Assertions.assertEquals(1, signature.typeVariables.size) + assertEquals(1, signature.typeVariables.size) with(signature.typeVariables.first()) { this as Formal - Assertions.assertEquals("W", symbol) - Assertions.assertEquals(1, boundTypeTokens?.size) + assertEquals("W", symbol) + assertEquals(1, boundTypeTokens?.size) with(boundTypeTokens!!.first()) { this as ParameterizedType - Assertions.assertEquals("java.util.Collection", this.name) - Assertions.assertEquals(1, parameterTypes.size) + assertEquals("java.util.Collection", this.name) + assertEquals(1, parameterTypes.size) with(parameterTypes.first()) { this as TypeVariable - Assertions.assertEquals("T", symbol) + assertEquals("T", symbol) } } } - Assertions.assertEquals(1, signature.parameterTypes.size) + assertEquals(1, signature.parameterTypes.size) val parameterizedType = signature.parameterTypes.first() as ParameterizedType - Assertions.assertEquals(1, parameterizedType.parameterTypes.size) - Assertions.assertEquals(Generics::class.java.name, parameterizedType.name) + assertEquals(1, parameterizedType.parameterTypes.size) + assertEquals(Generics::class.java.name, parameterizedType.name) val typeVariable = parameterizedType.parameterTypes.first() as TypeVariable - Assertions.assertEquals("T", typeVariable.symbol) + assertEquals("T", typeVariable.symbol) } } @@ -225,30 +224,30 @@ class RemoteClientTest { val fieldSignatures = a.fields().map { it.name to it.signature() } - Assertions.assertEquals(2, fieldSignatures.size) + assertEquals(2, fieldSignatures.size) with(fieldSignatures.first()) { val (name, signature) = this signature as FieldResolutionImpl val fieldType = signature.fieldType as TypeVariable - Assertions.assertEquals("niceField", name) - Assertions.assertEquals("T", fieldType.symbol) + assertEquals("niceField", name) + assertEquals("T", fieldType.symbol) } with(fieldSignatures.get(1)) { val (name, signature) = this signature as FieldResolutionImpl val fieldType = signature.fieldType as ParameterizedType - Assertions.assertEquals("niceList", name) - Assertions.assertEquals("java.util.List", fieldType.name) + assertEquals("niceList", name) + assertEquals("java.util.List", fieldType.name) with(fieldType.parameterTypes) { - Assertions.assertEquals(1, size) + assertEquals(1, size) with(first()) { this as BoundWildcard.UpperBoundWildcard val bondType = boundType as TypeVariable - Assertions.assertEquals("T", bondType.symbol) + assertEquals("T", bondType.symbol) } } - Assertions.assertEquals("java.util.List", fieldType.name) + assertEquals("java.util.List", fieldType.name) } } @@ -257,18 +256,18 @@ class RemoteClientTest { val withAnonymous = cp.findClass() val helloWorld = cp.findClass() - Assertions.assertTrue(helloWorld.isMemberClass()) + assertTrue(helloWorld.isMemberClass()) val innerClasses = withAnonymous.innerClasses() - Assertions.assertEquals(4, innerClasses.size) + assertEquals(4, innerClasses.size) val notHelloWorld = innerClasses.filterNot { it.name.contains("\$HelloWorld") } val englishGreetings = notHelloWorld.first { it.name.contains("EnglishGreeting") } - Assertions.assertTrue(englishGreetings.isLocal()) + assertTrue(englishGreetings.isLocal()) Assertions.assertFalse(englishGreetings.isAnonymous()) (notHelloWorld - englishGreetings).forEach { Assertions.assertFalse(it.isLocal()) - Assertions.assertTrue(it.isAnonymous()) + assertTrue(it.isAnonymous()) Assertions.assertFalse(it.isMemberClass()) } } @@ -277,34 +276,34 @@ class RemoteClientTest { fun `find lazy-loaded class`() = runBlocking { val domClass = cp.findClass() - Assertions.assertTrue(domClass.isPublic()) - Assertions.assertTrue(domClass.isInterface()) + assertTrue(domClass.isPublic()) + assertTrue(domClass.isInterface()) val methods = domClass.methods() - Assertions.assertTrue(methods.isNotEmpty()) + assertTrue(methods.isNotEmpty()) with(methods.first { it.name == "getDoctype" }) { - Assertions.assertTrue(parameters().isEmpty()) - Assertions.assertEquals(DocumentType::class.java.name, returnType().name) - Assertions.assertTrue(isPublic()) + assertTrue(parameters().isEmpty()) + assertEquals(DocumentType::class.java.name, returnType().name) + assertTrue(isPublic()) } } @Test fun `find sub-types from lazy loaded classes`() = runBlocking { with(cp.findSubClasses>()) { - Assertions.assertTrue(size > 10) { + assertTrue(size > 10) { "expected more then 10 but got only: ${joinToString { it.name }}" } - Assertions.assertNotNull(firstOrNull { it.name == EnumMap::class.java.name }) - Assertions.assertNotNull(firstOrNull { it.name == HashMap::class.java.name }) - Assertions.assertNotNull(firstOrNull { it.name == WeakHashMap::class.java.name }) - Assertions.assertNotNull(firstOrNull { it.name == TreeMap::class.java.name }) - Assertions.assertNotNull(firstOrNull { it.name == ConcurrentHashMap::class.java.name }) + assertNotNull(firstOrNull { it.name == EnumMap::class.java.name }) + assertNotNull(firstOrNull { it.name == HashMap::class.java.name }) + assertNotNull(firstOrNull { it.name == WeakHashMap::class.java.name }) + assertNotNull(firstOrNull { it.name == TreeMap::class.java.name }) + assertNotNull(firstOrNull { it.name == ConcurrentHashMap::class.java.name }) } with(cp.findSubClasses(Document::class.java.name)) { - Assertions.assertTrue(isNotEmpty()) + assertTrue(isNotEmpty()) } } @@ -313,24 +312,24 @@ class RemoteClientTest { val stringArray = cp.findClass("java.lang.String[]") with(cp.findSubClasses(stringArray, true)) { - Assertions.assertTrue(isEmpty()) + assertTrue(isEmpty()) } } @Test fun `find sub-types with all hierarchy`() = runBlocking { val clazz = cp.findClassOrNull() - Assertions.assertNotNull(clazz!!) + assertNotNull(clazz!!) with(cp.findSubClasses(clazz, allHierarchy = true)) { - Assertions.assertEquals(4, size) { + assertEquals(4, size) { "expected more then 10 but got only: ${joinToString { it.name }}" } - Assertions.assertNotNull(firstOrNull { it.name == A::class.java.name }) - Assertions.assertNotNull(firstOrNull { it.name == B::class.java.name }) - Assertions.assertNotNull(firstOrNull { it.name == C::class.java.name }) - Assertions.assertNotNull(firstOrNull { it.name == D::class.java.name }) + assertNotNull(firstOrNull { it.name == A::class.java.name }) + assertNotNull(firstOrNull { it.name == B::class.java.name }) + assertNotNull(firstOrNull { it.name == C::class.java.name }) + assertNotNull(firstOrNull { it.name == D::class.java.name }) } } @@ -338,25 +337,25 @@ class RemoteClientTest { fun `find method overrides`() = runBlocking { val creatureClass = cp.findClass() - Assertions.assertEquals(2, creatureClass.methods().size) + assertEquals(2, creatureClass.methods().size) val sayMethod = creatureClass.methods().first { it.name == "say" } val helloMethod = creatureClass.methods().first { it.name == "hello" } var overrides = cp.hierarchyExt.findOverrides(sayMethod) with(overrides) { - Assertions.assertEquals(4, size) + assertEquals(4, size) - Assertions.assertNotNull(firstOrNull { it.classId == cp.findClass() }) - Assertions.assertNotNull(firstOrNull { it.classId == cp.findClass() }) - Assertions.assertNotNull(firstOrNull { it.classId == cp.findClass() }) - Assertions.assertNotNull(firstOrNull { it.classId == cp.findClass() }) + assertNotNull(firstOrNull { it.classId == cp.findClass() }) + assertNotNull(firstOrNull { it.classId == cp.findClass() }) + assertNotNull(firstOrNull { it.classId == cp.findClass() }) + assertNotNull(firstOrNull { it.classId == cp.findClass() }) } overrides = cp.hierarchyExt.findOverrides(helloMethod) with(overrides) { - Assertions.assertEquals(1, size) + assertEquals(1, size) - Assertions.assertNotNull(firstOrNull { it.classId == cp.findClass() }) + assertNotNull(firstOrNull { it.classId == cp.findClass() }) } }