/*
 * Copyright 2020 The Android Open Source Project
 *
 * 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.
 */

package androidx.room.compiler.processing

import androidx.room.compiler.codegen.XClassName
import androidx.room.compiler.codegen.XTypeName
import androidx.room.compiler.codegen.asClassName
import androidx.room.compiler.processing.javac.JavacType
import androidx.room.compiler.processing.util.Source
import androidx.room.compiler.processing.util.XTestInvocation
import androidx.room.compiler.processing.util.asKClassName
import androidx.room.compiler.processing.util.asMutableKClassName
import androidx.room.compiler.processing.util.compileFiles
import androidx.room.compiler.processing.util.createXTypeVariableName
import androidx.room.compiler.processing.util.getAllFieldNames
import androidx.room.compiler.processing.util.getDeclaredField
import androidx.room.compiler.processing.util.getField
import androidx.room.compiler.processing.util.getMethodByJvmName
import androidx.room.compiler.processing.util.runProcessorTest
import com.google.common.truth.Truth.assertThat
import com.google.common.truth.Truth.assertWithMessage
import com.squareup.kotlinpoet.INT
import com.squareup.kotlinpoet.ParameterizedTypeName.Companion.parameterizedBy
import com.squareup.kotlinpoet.javapoet.JClassName
import com.squareup.kotlinpoet.javapoet.JParameterizedTypeName
import com.squareup.kotlinpoet.javapoet.JTypeName
import com.squareup.kotlinpoet.javapoet.JTypeVariableName
import com.squareup.kotlinpoet.javapoet.KClassName
import com.squareup.kotlinpoet.javapoet.KTypeVariableName
import org.junit.Test
import org.junit.runner.RunWith
import org.junit.runners.Parameterized

@RunWith(Parameterized::class)
class XTypeElementTest(
    private val isPreCompiled: Boolean,
) {
    private fun runTest(
        sources: List<Source>,
        handler: (XTestInvocation) -> Unit
    ) {
        if (isPreCompiled) {
            val compiled = compileFiles(sources)
            val hasKotlinSources = sources.any {
                it is Source.KotlinSource
            }
            val kotlinSources = if (hasKotlinSources) {
                listOf(
                    Source.kotlin("placeholder.kt", "class PlaceholderKotlin")
                )
            } else {
                emptyList()
            }
            val newSources = kotlinSources + Source.java(
                "PlaceholderJava",
                "public class " +
                    "PlaceholderJava {}"
            )
            runProcessorTest(
                sources = newSources,
                handler = handler,
                classpath = compiled
            )
        } else {
            runProcessorTest(
                sources = sources,
                handler = handler
            )
        }
    }

    @Test
    fun qualifiedNames() {
        val src1 = Source.kotlin(
            "Foo.kt",
            """
            class TopLevel
            """.trimIndent()
        )
        val src2 = Source.kotlin(
            "Bar.kt",
            """
            package foo.bar
            class InFooBar
            """.trimIndent()
        )
        val src3 = Source.java(
            "foo.bar.Outer",
            """
            package foo.bar;
            public class Outer {
                public static class Nested {
                }
            }
            """
        )
        runTest(
            sources = listOf(src1, src2, src3)
        ) { invocation ->
            invocation.processingEnv.requireTypeElement("TopLevel").let {
                assertThat(it.packageName).isEqualTo("")
                assertThat(it.name).isEqualTo("TopLevel")
                assertThat(it.qualifiedName).isEqualTo("TopLevel")
                assertThat(it.asClassName().java)
                    .isEqualTo(JClassName.get("", "TopLevel"))
                if (invocation.isKsp) {
                    assertThat(it.asClassName().kotlin)
                        .isEqualTo(KClassName("", "TopLevel"))
                } else {
                    // In javac / kapt we don't have KotlinPoet names
                    assertThat(it.asClassName().kotlin)
                        .isEqualTo(XTypeName.UNAVAILABLE_KTYPE_NAME)
                }
            }
            invocation.processingEnv.requireTypeElement("foo.bar.InFooBar").let {
                assertThat(it.packageName).isEqualTo("foo.bar")
                assertThat(it.name).isEqualTo("InFooBar")
                assertThat(it.qualifiedName).isEqualTo("foo.bar.InFooBar")
                assertThat(it.asClassName()).isEqualTo(XClassName.get("foo.bar", "InFooBar"))
            }
            invocation.processingEnv.requireTypeElement("foo.bar.Outer").let {
                assertThat(it.packageName).isEqualTo("foo.bar")
                assertThat(it.name).isEqualTo("Outer")
                assertThat(it.qualifiedName).isEqualTo("foo.bar.Outer")
                assertThat(it.asClassName()).isEqualTo(XClassName.get("foo.bar", "Outer"))
            }
            invocation.processingEnv.requireTypeElement("foo.bar.Outer.Nested").let {
                assertThat(it.packageName).isEqualTo("foo.bar")
                assertThat(it.name).isEqualTo("Nested")
                assertThat(it.qualifiedName).isEqualTo("foo.bar.Outer.Nested")
                assertThat(it.asClassName())
                    .isEqualTo(XClassName.get("foo.bar", "Outer", "Nested"))
            }
            if (invocation.isKsp) {
                // these are KSP specific tests, typenames are tested elsewhere
                invocation.processingEnv.requireTypeElement("java.lang.Integer").let {
                    // always return kotlin types, this is what compiler does
                    assertThat(it.packageName).isEqualTo("kotlin")
                    assertThat(it.name).isEqualTo("Int")
                    assertThat(it.qualifiedName).isEqualTo("kotlin.Int")
                    assertThat(it.asClassName().java).isEqualTo(JTypeName.INT.box())
                    assertThat(it.asClassName().kotlin).isEqualTo(INT)
                }
                invocation.processingEnv.requireTypeElement("kotlin.Int").let {
                    assertThat(it.packageName).isEqualTo("kotlin")
                    assertThat(it.name).isEqualTo("Int")
                    assertThat(it.qualifiedName).isEqualTo("kotlin.Int")
                    assertThat(it.asClassName().java).isEqualTo(JTypeName.INT.box())
                    assertThat(it.asClassName().kotlin).isEqualTo(INT)
                }
            }
        }
    }

    @Test
    fun typeAndSuperType() {
        val src = Source.kotlin(
            "foo.kt",
            """
            package foo.bar
            class Baz : MyInterface, AbstractClass()
            abstract class AbstractClass
            interface MyInterface
            interface AnotherInterface : MyInterface
            """.trimIndent()
        )
        runTest(sources = listOf(src)) { invocation ->
            invocation.processingEnv.requireTypeElement("foo.bar.Baz").let {
                assertThat(it.superClass!!.asTypeName()).isEqualTo(
                    invocation.processingEnv.requireType("foo.bar.AbstractClass").asTypeName()
                )
                assertThat(it.type.superTypes.map(XType::asTypeName)).containsExactly(
                    invocation.processingEnv.requireType("foo.bar.AbstractClass").asTypeName(),
                    invocation.processingEnv.requireType("foo.bar.MyInterface").asTypeName()
                )
                assertThat(it.type.asTypeName()).isEqualTo(
                    invocation.processingEnv.requireType("foo.bar.Baz").asTypeName()
                )
                assertThat(it.isInterface()).isFalse()
                assertThat(it.isKotlinObject()).isFalse()
                assertThat(it.isAbstract()).isFalse()
            }
            invocation.processingEnv.requireTypeElement("foo.bar.AbstractClass").let {
                assertThat(it.superClass!!.asTypeName()).isEqualTo(
                    invocation.processingEnv.requireType(JTypeName.OBJECT).asTypeName()
                )
                assertThat(it.type.superTypes.map(XType::asTypeName)).containsExactly(
                    invocation.processingEnv.requireType(JTypeName.OBJECT).asTypeName()
                )
                assertThat(it.isAbstract()).isTrue()
                assertThat(it.isInterface()).isFalse()
                assertThat(it.type.asTypeName()).isEqualTo(
                    invocation.processingEnv.requireType("foo.bar.AbstractClass").asTypeName()
                )
            }
            invocation.processingEnv.requireTypeElement("foo.bar.MyInterface").let {
                assertThat(it.superClass).isNull()
                assertThat(it.type.superTypes.map(XType::asTypeName)).containsExactly(
                    invocation.processingEnv.requireType(JTypeName.OBJECT).asTypeName()
                )
                assertThat(it.isInterface()).isTrue()
                assertThat(it.type.asTypeName()).isEqualTo(
                    invocation.processingEnv.requireType("foo.bar.MyInterface").asTypeName()
                )
            }
            invocation.processingEnv.requireTypeElement("foo.bar.AnotherInterface").let {
                assertThat(it.superClass).isNull()
                assertThat(it.type.superTypes.map(XType::asTypeName)).containsExactly(
                    invocation.processingEnv.requireType("java.lang.Object").asTypeName(),
                    invocation.processingEnv.requireType("foo.bar.MyInterface").asTypeName()
                )
                assertThat(it.isInterface()).isTrue()
                assertThat(it.type.asTypeName()).isEqualTo(
                    invocation.processingEnv.requireType("foo.bar.AnotherInterface").asTypeName()
                )
            }
        }
    }

    @Test
    fun superInterfaces() {
        val src = Source.kotlin(
            "foo.kt",
            """
            package foo.bar
            class Baz : MyInterface<String>, AbstractClass()
            abstract class AbstractClass
            interface MyInterface<E>
            """.trimIndent()
        )
        runTest(sources = listOf(src)) { invocation ->
            invocation.processingEnv.requireTypeElement("foo.bar.Baz").let {
                assertThat(it.superInterfaces).hasSize(1)
                val superInterface = it.superInterfaces.first { type ->
                    type.rawType.toString() == "foo.bar.MyInterface"
                }
                assertThat(superInterface.typeArguments).hasSize(1)
                assertThat(superInterface.typeArguments[0].asTypeName().java)
                    .isEqualTo(JClassName.get("java.lang", "String"))
                if (invocation.isKsp) {
                    assertThat(superInterface.typeArguments[0].asTypeName().kotlin)
                        .isEqualTo(KClassName("kotlin", "String"))
                }
                if (! invocation.isKsp) {
                    assertThat((superInterface as JavacType).kotlinType).isNotNull()
                }
            }
        }
    }

    @Test
    fun nestedClassName() {
        val src = Source.kotlin(
            "Foo.kt",
            """
            package foo.bar
            class Outer {
                class Inner
            }
            """.trimIndent()
        )
        runTest(sources = listOf(src)) { invocation ->
            invocation.processingEnv.requireTypeElement("foo.bar.Outer").let {
                assertThat(it.asClassName())
                    .isEqualTo(XClassName.get("foo.bar", "Outer"))
                assertThat(it.isNested()).isFalse()
                assertThat(it.enclosingTypeElement).isNull()
            }
            invocation.processingEnv.requireTypeElement("foo.bar.Outer.Inner").let {
                assertThat(it.asClassName())
                    .isEqualTo(XClassName.get("foo.bar", "Outer", "Inner"))
                assertThat(it.packageName).isEqualTo("foo.bar")
                assertThat(it.name).isEqualTo("Inner")
                assertThat(it.isNested()).isTrue()
                assertThat(it.enclosingTypeElement).isEqualTo(
                    invocation.processingEnv.requireTypeElement("foo.bar.Outer")
                )
            }
        }
    }

    @Test
    fun modifiers() {
        val kotlinSrc = Source.kotlin(
            "Foo.kt",
            """
            open class OpenClass
            abstract class AbstractClass
            object MyObject
            interface MyInterface
            class Final
            private class PrivateClass
            class OuterKotlinClass {
                inner class InnerKotlinClass
                class NestedKotlinClass
            }
            annotation class KotlinAnnotation
            data class DataClass(val foo: Int)
            inline class InlineClass(val foo: Int)
            fun interface FunInterface {
               fun foo()
            }
            """.trimIndent()
        )
        val javaSrc = Source.java(
            "OuterJavaClass",
            """
            public class OuterJavaClass {
                public class InnerJavaClass {}
                public static class NestedJavaClass {}
            }
            """.trimIndent()
        )
        val javaAnnotationSrc = Source.java(
            "JavaAnnotation",
            """
            public @interface JavaAnnotation {
            }
            """.trimIndent()
        )
        runTest(
            sources = listOf(kotlinSrc, javaSrc, javaAnnotationSrc)
        ) { invocation ->
            fun getModifiers(element: XTypeElement): Set<String> {
                val result = mutableSetOf<String>()
                if (element.isAbstract()) result.add("abstract")
                if (element.isFinal()) result.add("final")
                if (element.isPrivate()) result.add("private")
                if (element.isProtected()) result.add("protected")
                if (element.isPublic()) result.add("public")
                if (element.isKotlinObject()) result.add("object")
                if (element.isCompanionObject()) result.add("companion")
                if (element.isFunctionalInterface()) result.add("fun")
                if (element.isClass()) result.add("class")
                if (element.isDataClass()) result.add("data")
                if (element.isValueClass()) result.add("value")
                if (element.isExpect()) result.add("expect")
                if (element.isInterface()) result.add("interface")
                if (element.isStatic()) result.add("static")
                if (element.isAnnotationClass()) result.add("annotation")
                return result
            }

            fun getModifiers(qName: String): Set<String> = getModifiers(
                invocation.processingEnv
                    .requireTypeElement(qName)
            )

            assertThat(getModifiers("OpenClass"))
                .containsExactly("public", "class")
            assertThat(getModifiers("AbstractClass"))
                .containsExactly("abstract", "public", "class")
            assertThat(getModifiers("MyObject"))
                .containsExactly("final", "public", "object")
            assertThat(getModifiers("MyInterface"))
                .containsExactly("abstract", "interface", "public")
            assertThat(getModifiers("Final"))
                .containsExactly("final", "public", "class")
            assertThat(getModifiers("PrivateClass"))
                .containsExactlyElementsIn(
                    if (invocation.isKsp) {
                        listOf("private", "final", "class")
                    } else {
                        // java does not support top level private classes.
                        listOf("final", "class")
                    }
                )
            assertThat(getModifiers("OuterKotlinClass.InnerKotlinClass"))
                .containsExactly("final", "public", "class")
            assertThat(getModifiers("OuterKotlinClass.NestedKotlinClass"))
                .containsExactly("final", "public", "static", "class")
            assertThat(getModifiers("OuterJavaClass.InnerJavaClass"))
                .containsExactly("public", "class")
            assertThat(getModifiers("OuterJavaClass.NestedJavaClass"))
                .containsExactly("public", "static", "class")
            assertThat(getModifiers("JavaAnnotation")).apply {
                // KSP vs KAPT metadata have a difference in final vs abstract modifiers
                // for annotation types.
                if (isPreCompiled && invocation.isKsp) {
                    containsExactly("final", "public", "annotation")
                } else {
                    containsExactly("abstract", "public", "annotation")
                }
            }
            assertThat(getModifiers("KotlinAnnotation")).apply {
                // KSP vs KAPT metadata have a difference in final vs abstract modifiers
                // for annotation types.
                if (invocation.isKsp) {
                    containsExactly("final", "public", "annotation")
                } else {
                    containsExactly("abstract", "public", "annotation")
                }
            }
            assertThat(getModifiers("DataClass"))
                .containsExactly("public", "final", "class", "data")
            assertThat(getModifiers("InlineClass")).apply {
                containsExactly("public", "final", "class", "value")
            }
            assertThat(getModifiers("FunInterface"))
                .containsExactly("public", "abstract", "interface", "fun")
        }
    }

    @Test
    fun kindName() {
        val kotlinSrc = Source.kotlin(
            "Foo.kt",
            """
            class KotlinClass
            interface KotlinInterface
            annotation class KotlinAnnotation
            """.trimIndent()
        )
        val javaSrc = Source.java(
            "Bar.java",
            """
            class JavaClass {}
            interface JavaInterface {}
            @interface JavaAnnotation {}
            """.trimIndent()
        )
        runTest(sources = listOf(kotlinSrc, javaSrc)) { invocation ->
            invocation.processingEnv.requireTypeElement("KotlinClass").let {
                assertThat(it.kindName()).isEqualTo("class")
            }
            invocation.processingEnv.requireTypeElement("KotlinInterface").let {
                assertThat(it.kindName()).isEqualTo("interface")
            }
            invocation.processingEnv.requireTypeElement("KotlinAnnotation").let {
                // TODO(b/270557392): make the result consistent between KSP and JavaAP
                if (invocation.isKsp) {
                    assertThat(it.kindName()).isEqualTo("annotation_class")
                } else {
                    assertThat(it.kindName()).isEqualTo("annotation_type")
                }
            }

            invocation.processingEnv.requireTypeElement("JavaClass").let {
                assertThat(it.kindName()).isEqualTo("class")
            }
            invocation.processingEnv.requireTypeElement("JavaInterface").let {
                assertThat(it.kindName()).isEqualTo("interface")
            }
            invocation.processingEnv.requireTypeElement("JavaAnnotation").let {
                // TODO(b/270557392): make the result consistent between KSP and JavaAP
                if (invocation.isKsp) {
                    assertThat(it.kindName()).isEqualTo("annotation_class")
                } else {
                    assertThat(it.kindName()).isEqualTo("annotation_type")
                }
            }
        }
    }

    @Test
    fun fieldBasic() {
        val src = Source.kotlin(
            "Foo.kt",
            """
            open class BaseClass<T>(val genericProp : T) {
                fun baseMethod(input: T) {}
            }
            class SubClass(x : Int) : BaseClass<Int>(x) {
                val subClassProp : String = "abc"
            }
            """.trimIndent()
        )
        runTest(sources = listOf(src)) { invocation ->
            val baseClass = invocation.processingEnv.requireTypeElement("BaseClass")
            assertThat(baseClass.getAllFieldNames()).containsExactly("genericProp")
            assertThat(baseClass.getDeclaredFields().map { it.name })
                .containsExactly("genericProp")
            val subClass = invocation.processingEnv.requireTypeElement("SubClass")
            assertThat(subClass.getAllFieldNames()).containsExactly("genericProp", "subClassProp")
            assertThat(subClass.getDeclaredFields().map { it.name })
                .containsExactly("subClassProp")

            val baseMethod = baseClass.getMethodByJvmName("baseMethod")
            baseMethod.asMemberOf(subClass.type).let { methodType ->
                val genericArg = methodType.parameterTypes.first()
                assertThat(genericArg.asTypeName()).isEqualTo(Int::class.asClassName())
            }

            baseClass.getField("genericProp").let { field ->
                assertThat(field.type.asTypeName()).isEqualTo(createXTypeVariableName("T"))
            }

            subClass.getField("genericProp").let { field ->
                // this is tricky because even though it is non-null it, it should still be boxed
                assertThat(field.asMemberOf(subClass.type).asTypeName())
                    .isEqualTo(Int::class.asClassName())
            }
        }
    }

    @Test
    fun fieldsOverride() {
        val src = Source.kotlin(
            "Foo.kt",
            """
            open class BaseClass(
                open val value : List<Int>
            )
            class SubClass(
                override val value : MutableList<Int>
            ) : BaseClass(value)
            """.trimIndent()
        )
        runTest(sources = listOf(src)) { invocation ->
            val baseClass = invocation.processingEnv.requireTypeElement("BaseClass")
            assertThat(baseClass.getAllFieldNames()).containsExactly("value")
            val subClass = invocation.processingEnv.requireTypeElement("SubClass")
            assertThat(subClass.getAllFieldNames()).containsExactly("value")
            val baseFieldType = baseClass.getField("value").type
            val subFieldType = subClass.getField("value").type
            assertThat(baseFieldType.asTypeName().java).isEqualTo(
                JParameterizedTypeName.get(List::class.java, Integer::class.java)
            )
            assertThat(subFieldType.asTypeName().java).isEqualTo(
                JParameterizedTypeName.get(List::class.java, Integer::class.java)
            )
            if (invocation.isKsp) {
                assertThat(baseFieldType.asTypeName().kotlin).isEqualTo(
                    List::class.asKClassName().parameterizedBy(INT)
                )
                assertThat(subFieldType.asTypeName().kotlin).isEqualTo(
                    List::class.asMutableKClassName().parameterizedBy(INT)
                )
            }
        }
    }

    @Test
    fun fieldsMethodsWithoutBacking() {
        runTest(
            sources = listOf(Source.kotlin(
                "Foo.kt",
                """
            package test
            class Subject {
                val realField: String = ""
                    get() = field
                val noBackingVal: String
                    get() = ""
                var noBackingVar: String
                    get() = ""
                    set(value) {}

                companion object {
                    @JvmStatic
                    val staticRealField: String = ""
                    get() = field
                    @JvmStatic
                    val staticNoBackingVal: String
                        get() = ""
                    @JvmStatic
                    var staticNoBackingVar: String
                        get() = ""
                        set(value) {}
                }
            }
            """.trimIndent()
            )),
        ) { invocation ->
            val subject = invocation.processingEnv.requireTypeElement("test.Subject")
            val declaredFields = subject.getDeclaredFields().map { it.name } -
                listOf("Companion") // skip Companion, KAPT generates it
            val expectedFields = listOf("realField", "staticRealField")
            assertWithMessage(subject.qualifiedName)
                .that(declaredFields)
                .containsExactlyElementsIn(expectedFields)
            val allFields = subject.getAllFieldsIncludingPrivateSupers().map { it.name } -
                listOf("Companion") // skip Companion, KAPT generates it
            assertWithMessage(subject.qualifiedName)
                .that(allFields.toList())
                .containsExactlyElementsIn(expectedFields)
            val methodNames = subject.getDeclaredMethods().map { it.jvmName }
            assertWithMessage(subject.qualifiedName)
                .that(methodNames)
                .containsAtLeast("getNoBackingVal", "getNoBackingVar", "setNoBackingVar")
            assertWithMessage(subject.qualifiedName)
                .that(methodNames)
                .doesNotContain("setNoBackingVal")
        }
    }

    @Test
    fun abstractFields() {
        runTest(
            sources = listOf(Source.kotlin(
                "Foo.kt",
                """
            package test
            abstract class Subject {
                val value: String = ""
                abstract val abstractValue: String
                companion object {
                    var realCompanion: String = ""
                    @JvmStatic
                    var jvmStatic: String = ""
                }
            }
            """.trimIndent()
            )),
        ) { invocation ->
            val subject = invocation.processingEnv.requireTypeElement("test.Subject")
            val declaredFields = subject.getDeclaredFields().map { it.name } -
                listOf("Companion")
            val expectedFields = listOf("value", "realCompanion", "jvmStatic")
            assertWithMessage(subject.qualifiedName)
                .that(declaredFields)
                .containsExactlyElementsIn(expectedFields)
        }
    }

    @Test
    fun lateinitFields() {
        runTest(
            sources = listOf(Source.kotlin(
                "Foo.kt",
                """
            package test
            class Subject {
                lateinit var x:String
                var y:String = "abc"
            }
            """.trimIndent()
            )),
        ) { invocation ->
            val subject = invocation.processingEnv.requireTypeElement("test.Subject")
            assertWithMessage(subject.fallbackLocationText)
                .that(subject.getDeclaredFields().map { it.name })
                .containsExactly(
                    "x", "y"
                )
            assertWithMessage(subject.fallbackLocationText)
                .that(subject.getDeclaredMethods().map { it.jvmName })
                .containsExactly(
                    "getX", "setX", "getY", "setY"
                )
            subject.getField("x").let { field ->
                assertThat(field.isFinal()).isFalse()
                assertThat(field.isPrivate()).isFalse()
            }
        }
    }

    @Test
    fun fieldsInInterfaces() {
        val src = Source.kotlin(
            "Foo.kt",
            """
            interface MyInterface {
                var x:Int
            }
            """.trimIndent()
        )
        runTest(sources = listOf(src)) { invocation ->
            val element = invocation.processingEnv.requireTypeElement("MyInterface")
            assertThat(element.getAllFieldsIncludingPrivateSupers().toList()).isEmpty()
            element.getMethodByJvmName("getX").let {
                assertThat(it.isAbstract()).isTrue()
            }
            element.getMethodByJvmName("setX").let {
                assertThat(it.isAbstract()).isTrue()
            }
        }
    }

    @Test
    fun fieldsInAbstractClass() {
        val src = Source.kotlin(
            "Foo.kt",
            """
            abstract class MyAbstractClass {
                @JvmField
                var jvmVar: Int = 0
                abstract var abstractVar: Int
                var nonAbstractVar: Int = 0
            }
            """.trimIndent()
        )
        runTest(sources = listOf(src)) { invocation ->
            val element = invocation.processingEnv.requireTypeElement("MyAbstractClass")
            assertThat(
                element.getAllFieldNames()
            ).containsExactly(
                "nonAbstractVar", "jvmVar"
            )
            assertThat(
                element.getDeclaredMethods().map { it.jvmName }
            ).containsExactly(
                "getAbstractVar", "setAbstractVar",
                "getNonAbstractVar", "setNonAbstractVar"
            )
            element.getMethodByJvmName("getAbstractVar").let {
                assertThat(it.isAbstract()).isTrue()
            }
            element.getMethodByJvmName("setAbstractVar").let {
                assertThat(it.isAbstract()).isTrue()
            }

            element.getMethodByJvmName("getNonAbstractVar").let {
                assertThat(it.isAbstract()).isFalse()
            }
            element.getMethodByJvmName("setNonAbstractVar").let {
                assertThat(it.isAbstract()).isFalse()
            }
        }
    }

    @Test
    fun propertyGettersSetters() {
        runTest(
            listOf(
                Source.java(
                    "JavaSubject.java",
                    """
                    class JavaSubject {
                        int myField;
                        private int mutable;
                        int immutable;
                        int getMutable() {return 3;}
                        void setMutable(int x) {}
                        int getImmutable() {return 3;}
                    }
                    """.trimIndent()
                ),
                Source.kotlin(
                    "KotlinSubject.kt",
                    """
                    class KotlinSubject {
                        private val myField = 0
                        var mutable: Int = 0
                        val immutable:Int = 0
                    }
                    """.trimIndent()
                )
            ),
        ) { invocation ->
            listOf("JavaSubject", "KotlinSubject",).map {
                invocation.processingEnv.requireTypeElement(it)
            }.forEach { subject ->
                val methods = subject.getDeclaredMethods()
                assertWithMessage(subject.qualifiedName)
                    .that(
                        methods.map {
                            it.jvmName
                        }
                    ).containsExactly(
                        "getMutable", "setMutable", "getImmutable"
                    )
                methods.forEach {
                    assertWithMessage("${subject.qualifiedName}.${it.jvmName}()")
                        .that(it.isKotlinPropertyMethod())
                        .apply {
                            if (subject.name.contains("Kotlin")) {
                                isTrue()
                            } else {
                                isFalse()
                            }
                        }
                }
            }
        }
    }

    @Test
    fun declaredAndInstanceMethods() {
        val src = Source.kotlin(
            "Foo.kt",
            """
            open class Base(x:Int) {
                open fun baseFun(): Int = TODO()
                suspend fun suspendFun(): Int = TODO()
                private fun privateBaseFun(): Int = TODO()
                companion object {
                    @JvmStatic
                    fun staticBaseFun(): Int = TODO()
                    fun companionMethod(): Int = TODO()
                }
            }
            open class SubClass : Base {
                constructor(y:Int): super(y) {
                }
                constructor(x:Int, y:Int): super(y) {
                }
                override fun baseFun(): Int = TODO()
                fun subFun(): Int = TODO()
                private fun privateSubFun(): Int = TODO()
                companion object {
                    @JvmStatic
                    fun staticFun(): Int = TODO()
                }
            }
            """.trimIndent()
        )
        runTest(sources = listOf(src)) { invocation ->
            val base = invocation.processingEnv.requireTypeElement("Base")
            val objectMethodNames = invocation.objectMethodNames()
            assertThat(base.getDeclaredMethods().jvmNames()).containsExactly(
                "baseFun", "suspendFun", "privateBaseFun", "staticBaseFun"
            )

            val sub = invocation.processingEnv.requireTypeElement("SubClass")
            assertThat(sub.getDeclaredMethods().jvmNames()).containsExactly(
                "baseFun", "subFun", "privateSubFun", "staticFun"
            )
            assertThat(
                sub.getAllNonPrivateInstanceMethods().jvmNames() - objectMethodNames
            ).containsExactly(
                "baseFun", "suspendFun", "subFun"
            )
        }
    }

    @Test
    fun diamondOverride() {
        runTest(
            sources = listOf(Source.kotlin(
                "Foo.kt",
                """
            package test
            interface Parent<T> {
                fun parent(t: T)
            }

            interface Child1<T> : Parent<T> {
                fun child1(t: T)
            }

            interface Child2<T> : Parent<T> {
                fun child2(t: T)
            }

            abstract class Subject1 : Child1<String>, Child2<String>, Parent<String>
            abstract class Subject2 : Child1<String>, Parent<String>
            abstract class Subject3 : Child1<String>, Parent<String> {
                abstract override fun parent(t: String)
            }
            """.trimIndent()
            )),
        ) { invocation ->
            invocation.processingEnv.requireTypeElement("test.Subject1").let { subject ->
                assertWithMessage(subject.qualifiedName).that(
                    invocation.nonObjectMethodSignatures(subject)
                ).containsExactly(
                    "child1(java.lang.String):void",
                    "child2(java.lang.String):void",
                    "parent(java.lang.String):void",
                )
            }
            invocation.processingEnv.requireTypeElement("test.Subject2").let { subject ->
                assertWithMessage(subject.qualifiedName).that(
                    invocation.nonObjectMethodSignatures(subject)
                ).containsExactly(
                    "child1(java.lang.String):void",
                    "parent(java.lang.String):void",
                )
            }
            invocation.processingEnv.requireTypeElement("test.Subject3").let { subject ->
                assertWithMessage(subject.qualifiedName).that(
                    invocation.nonObjectMethodSignatures(subject)
                ).containsExactly(
                    "child1(java.lang.String):void",
                    "parent(java.lang.String):void",
                )
            }
        }
    }

    @Test
    fun suspendOverride() {
        val src = Source.kotlin(
            "Foo.kt",
            """
            interface Base<T> {
                suspend fun get(): T
                suspend fun getAll(): List<T>
                suspend fun putAll(input: List<T>)
                suspend fun getAllWithDefault(): List<T>
            }

            interface DerivedInterface : Base<String> {
                override suspend fun get(): String
                override suspend fun getAll(): List<String>
                override suspend fun putAll(input: List<String>)
                override suspend fun getAllWithDefault(): List<String> {
                    return emptyList()
                }
            }
            """.trimIndent()
        )
        runTest(sources = listOf(src)) { invocation ->
            val base = invocation.processingEnv.requireTypeElement("DerivedInterface")
            val methodNames = base.getAllMethods().toList().jvmNames()
            assertThat(methodNames).containsExactly(
                "get", "getAll", "putAll", "getAllWithDefault"
            )
        }
    }

    @Test
    fun suspendOverride_abstractClass() {
        val src = Source.kotlin(
            "Foo.kt",
            """
            abstract class Base<T> {
                abstract suspend fun get(): T
                abstract suspend fun getAll(): List<T>
                abstract suspend fun putAll(input: List<T>)
            }

            abstract class DerivedClass : Base<Int>() {
                abstract override suspend fun get(): Int
                abstract override suspend fun getAll(): List<Int>
                override suspend fun putAll(input: List<Int>) {
                }
            }
            """.trimIndent()
        )
        runTest(sources = listOf(src)) { invocation ->
            val base = invocation.processingEnv.requireTypeElement("DerivedClass")
            val methodNamesCount =
                base.getAllMethods().toList().jvmNames().groupingBy { it }.eachCount()
            assertThat(methodNamesCount["get"]).isEqualTo(1)
            assertThat(methodNamesCount["getAll"]).isEqualTo(1)
            assertThat(methodNamesCount["putAll"]).isEqualTo(1)
        }
    }

    @Test
    fun overrideMethodWithCovariantReturnType() {
        val src = Source.kotlin(
            "ParentWithExplicitOverride.kt",
            """
            interface ParentWithExplicitOverride: ChildInterface, Child {
                override fun child(): Child
            }

            interface ParentWithoutExplicitOverride: ChildInterface, Child

            interface Child: ChildInterface {
                override fun child(): Child
            }

            interface ChildInterface {
                fun child(): ChildInterface
            }
            """.trimIndent()
        )

        runTest(sources = listOf(src)) { invocation ->
            invocation.processingEnv.requireTypeElement(
                "ParentWithExplicitOverride"
            ).let { parent ->
                assertWithMessage(parent.qualifiedName).that(
                    invocation.nonObjectMethodSignatures(parent)
                ).containsExactly(
                    "child():Child"
                )
            }

            invocation.processingEnv.requireTypeElement(
                "ParentWithoutExplicitOverride"
            ).let { parent ->
                assertWithMessage(parent.qualifiedName).that(
                    invocation.nonObjectMethodSignatures(parent)
                ).containsExactly(
                    "child():Child"
                )
            }
        }
    }

    @Test
    fun allMethodsFiltersInAccessibleMethods() {
        val srcs = listOf(
            Source.java(
        "foo.Foo",
                """
                package foo;
                public interface Foo {
                    void foo_Public();
                }
                """.trimIndent()
            ),
            Source.java(
                "foo.parent.FooParent",
                """
                package foo.parent;
                public abstract class FooParent implements foo.Foo {
                    public void fooParent_Public() {}
                    protected void fooParent_Protected() {}
                    private void fooParent_Private() {}
                    void fooParent_PackagePrivate() {}
                }
                """.trimIndent()
            ),
            Source.java(
                "foo.child.FooChild",
                """
                package foo.child;
                public abstract class FooChild extends foo.parent.FooParent {
                    public void fooChild_Public() {}
                    protected void fooChild_Protected() {}
                    private void fooChild_Private() {}
                    void fooChild_PackagePrivate() {}
                }
                """.trimIndent()
            ),
        )
        runTest(sources = srcs) { invocation ->
            invocation.processingEnv.requireTypeElement("foo.child.FooChild")
                .let { fooChild ->
                    assertWithMessage(fooChild.qualifiedName).that(
                        invocation.nonObjectMethodSignatures(fooChild)
                    ).containsExactly(
                        "foo_Public():void",
                        "fooParent_Public():void",
                        "fooParent_Protected():void",
                        "fooChild_Public():void",
                        "fooChild_Protected():void",
                        "fooChild_Private():void",
                        "fooChild_PackagePrivate():void"
                    )
                }
        }
    }

    @Test
    fun allMethods() {
        val src = Source.kotlin(
            "Foo.kt",
            """
            open class Base(x:Int) {
                constructor(x:Int, y:Int): this(x) {
                }
                fun baseMethod(): Int = TODO()
                open fun overriddenMethod(): Int = TODO()
                private fun privateBaseMethod(): Int = TODO()
                companion object {
                    @JvmStatic
                    private fun privateBaseCompanionMethod(): Int = TODO()
                    @JvmStatic
                    fun baseCompanionMethod(): Int = TODO()
                }
            }
            interface MyInterface {
                fun interfaceMethod(): Int = TODO()
            }
            class SubClass : Base, MyInterface {
                constructor(x:Int): super(x) {
                }
                constructor(x:Int, y:Int): super(y) {
                }
                fun subMethod(): Int = TODO()
                fun privateSubMethod(): Int = TODO()
                override fun overriddenMethod(): Int = TODO()
                override fun interfaceMethod(): Int = TODO()
                companion object {
                    fun dontSeeThisOne(): Int = TODO()
                    @JvmStatic
                    fun subCompanionMethod(): Int = TODO()
                }
            }
            """.trimIndent()
        )
        runTest(sources = listOf(src)) { invocation ->
            val objectMethodNames = invocation.objectMethodNames()
            val klass = invocation.processingEnv.requireTypeElement("SubClass")
            assertThat(
                klass.getAllMethods().jvmNames() - objectMethodNames
            ).containsExactly(
                "baseMethod", "overriddenMethod", "baseCompanionMethod",
                "interfaceMethod", "subMethod", "privateSubMethod", "subCompanionMethod"
            )
        }
    }

    /**
     * When JvmNames is used along with a suppression over the error, the behavior becomes
     * complicated. Normally, JvmName annotation is not allowed in overrides and open methods, yet
     * developers can still use it by putting a suppression over it. The compiler will generate a
     * delegating method in these cases in the .class file, yet in KSP, we don't really see that
     * method (also shouldn't ideally).
     *
     * This test is here to acknowledge that the behavior is inconsistent yet working as intended
     * from XProcessing's perspective.
     *
     * Also see: https://youtrack.jetbrains.com/issue/KT-50782 as a sign why this suppression is
     * not worth supporting :).
     */
    @Test
    fun allMethods_withJvmNames() {
        runTest(
            sources = listOf(
                Source.kotlin(
                    "Foo.kt",
                    """
                package test
                interface Interface {
                    fun f1()
                    @JvmName("notF2")
                    @Suppress("INAPPLICABLE_JVM_NAME")
                    fun f2()
                }
                abstract class Subject : Interface {
                    @JvmName("notF1")
                    @Suppress("INAPPLICABLE_JVM_NAME")
                    override fun f1() {
                    }
                }
            """.trimIndent()
                )
            ),
        ) { invocation ->
            val appSubject = invocation.processingEnv.requireTypeElement("test.Subject")
            val methodNames = appSubject.getAllMethods().map { it.name }.toList()
            val methodJvmNames = appSubject.getAllMethods().map { it.jvmName }.toList()
            val objectMethodNames = invocation.objectMethodNames()
            if (invocation.isKsp) {
                assertThat(methodNames - objectMethodNames).containsExactly(
                    "f1", "f2"
                )
                assertThat(methodJvmNames - objectMethodNames).containsExactly(
                    "notF1", "notF2"
                )
            } else {
                assertThat(methodNames - objectMethodNames).containsExactly(
                    "f1", "f1", "f2"
                )
                assertThat(methodJvmNames - objectMethodNames).containsExactly(
                    "f1", "notF1", "notF2"
                )
            }
        }
    }

    @Test
    fun gettersSetters() {
        val src = Source.kotlin(
            "Foo.kt",
            """
            open class JustGetter(val x:Int) {
                private val invisible:Int = TODO()
                private var invisibleMutable:Int = TODO()
            }
            class GetterSetter(var y:Int) : JustGetter(y) {
                private val subInvisible:Int = TODO()
                private var subInvisibleMutable:Int = TODO()
            }
            """.trimIndent()
        )
        runTest(sources = listOf(src)) { invocation ->
            val objectMethodNames = invocation.objectMethodNames()
            invocation.processingEnv.requireTypeElement("JustGetter").let { base ->
                assertThat(base.getDeclaredMethods().jvmNames()).containsExactly(
                    "getX"
                )
                assertThat(base.getAllMethods().jvmNames() - objectMethodNames).containsExactly(
                    "getX"
                )
                assertThat(
                    base.getAllNonPrivateInstanceMethods().jvmNames() - objectMethodNames
                ).containsExactly(
                    "getX"
                )
            }
            invocation.processingEnv.requireTypeElement("GetterSetter").let { sub ->
                assertThat(sub.getDeclaredMethods().jvmNames()).containsExactly(
                    "getY", "setY"
                )
                assertThat(sub.getAllMethods().jvmNames() - objectMethodNames).containsExactly(
                    "getX", "getY", "setY"
                )
                assertThat(
                    sub.getAllNonPrivateInstanceMethods().jvmNames() - objectMethodNames
                ).containsExactly(
                    "getX", "getY", "setY"
                )
            }
        }
    }

    @Test
    fun companion() {
        val src = Source.kotlin(
            "Foo.kt",
            """
            open class CompanionSubject {
                companion object {
                    @JvmStatic
                    var mutableStatic: String = "a"
                    @JvmStatic
                    val immutableStatic: String = "bar"
                    val companionProp: Int = 3
                    @get:JvmStatic
                    var companionProp_getterJvmStatic:Int =3
                    @set:JvmStatic
                    var companionProp_setterJvmStatic:Int =3

                    fun companionMethod() {
                    }

                    @JvmStatic
                    fun companionMethodWithJvmStatic() {}
                }
            }
            class SubClass : CompanionSubject()
            """.trimIndent()
        )
        runTest(sources = listOf(src)) { invocation ->
            val objectMethodNames = invocation.processingEnv.requireTypeElement(
                Any::class
            ).getAllMethods().jvmNames()
            val subject = invocation.processingEnv.requireTypeElement("CompanionSubject")
            assertThat(subject.getAllFieldNames() - "Companion").containsExactly(
                "mutableStatic", "immutableStatic", "companionProp",
                "companionProp_getterJvmStatic", "companionProp_setterJvmStatic"
            )
            val expectedMethodNames = listOf(
                "getMutableStatic", "setMutableStatic", "getImmutableStatic",
                "getCompanionProp_getterJvmStatic", "setCompanionProp_setterJvmStatic",
                "companionMethodWithJvmStatic"
            )
            assertThat(
                subject.getDeclaredMethods().jvmNames()
            ).containsExactlyElementsIn(
                expectedMethodNames
            )
            assertThat(
                subject.getAllMethods().jvmNames() - objectMethodNames
            ).containsExactlyElementsIn(
                expectedMethodNames
            )
            assertThat(
                subject.getAllNonPrivateInstanceMethods().jvmNames() - objectMethodNames
            ).isEmpty()
            val subClass = invocation.processingEnv.requireTypeElement("SubClass")
            assertThat(subClass.getDeclaredMethods()).isEmpty()
            assertThat(
                subClass.getAllMethods().jvmNames() - objectMethodNames
            ).containsExactlyElementsIn(
                expectedMethodNames
            )

            // make sure everything coming from companion is marked as static
            subject.getDeclaredFields().forEach {
                assertWithMessage(it.name).that(it.isStatic()).isTrue()
            }
            subject.getDeclaredMethods().forEach {
                assertWithMessage(it.jvmName).that(it.isStatic()).isTrue()
            }

            // make sure asMemberOf works fine for statics
            val subClassType = subClass.type
            subject.getDeclaredFields().forEach {
                try {
                    it.asMemberOf(subClassType)
                } catch (th: Throwable) {
                    throw AssertionError("Couldn't run asMemberOf for ${it.name}")
                }
            }
            subject.getDeclaredMethods().forEach {
                try {
                    it.asMemberOf(subClassType)
                } catch (th: Throwable) {
                    throw AssertionError("Couldn't run asMemberOf for ${it.jvmName}")
                }
            }
        }
    }

    @Test
    fun gettersSetters_interface() {
        val src = Source.kotlin(
            "Foo.kt",
            """
            interface JustGetter {
                val x:Int
            }
            interface GetterSetter : JustGetter {
                var y:Int
            }
            """.trimIndent()
        )
        runTest(sources = listOf(src)) { invocation ->
            invocation.processingEnv.requireTypeElement("JustGetter").let { base ->
                assertThat(base.getDeclaredMethods().jvmNames()).containsExactly(
                    "getX"
                )
                assertThat(base.getAllMethods().jvmNames()).containsExactly(
                    "getX"
                )
                assertThat(base.getAllNonPrivateInstanceMethods().jvmNames()).containsExactly(
                    "getX"
                )
            }
            invocation.processingEnv.requireTypeElement("GetterSetter").let { sub ->
                assertThat(sub.getDeclaredMethods().jvmNames()).containsExactly(
                    "getY", "setY"
                )
                assertThat(sub.getAllMethods().jvmNames()).containsExactly(
                    "getX", "getY", "setY"
                )
                assertThat(sub.getAllNonPrivateInstanceMethods().jvmNames()).containsExactly(
                    "getX", "getY", "setY"
                )
            }
        }
    }

    @Test
    fun constructors() {
        val src = Source.kotlin(
            "Foo.kt",
            """
            interface MyInterface
            class NoExplicitConstructor
            open class Base(x:Int)
            open class ExplicitConstructor {
                constructor(x:Int)
            }
            open class BaseWithSecondary(x:Int) {
                constructor(y:String):this(3)
            }
            class Sub(x:Int) : Base(x)
            class SubWith3Constructors() : BaseWithSecondary("abc") {
                constructor(list:List<String>): this()
                constructor(list:List<String>, x:Int): this()
            }
            abstract class AbstractNoExplicit
            abstract class AbstractExplicit(x:Int)
            """.trimIndent()
        )
        runTest(sources = listOf(src)) { invocation ->
            val subjects = listOf(
                "MyInterface", "NoExplicitConstructor", "Base", "ExplicitConstructor",
                "BaseWithSecondary", "Sub", "SubWith3Constructors",
                "AbstractNoExplicit", "AbstractExplicit"
            )
            val constructorCounts = subjects.map {
                it to invocation.processingEnv.requireTypeElement(it).getConstructors().size
            }
            assertThat(constructorCounts)
                .containsExactly(
                    "MyInterface" to 0,
                    "NoExplicitConstructor" to 1,
                    "Base" to 1,
                    "ExplicitConstructor" to 1,
                    "BaseWithSecondary" to 2,
                    "Sub" to 1,
                    "SubWith3Constructors" to 3,
                    "AbstractNoExplicit" to 1,
                    "AbstractExplicit" to 1
                )

            val primaryConstructorParameterNames = subjects.map {
                it to invocation.processingEnv.requireTypeElement(it)
                    .findPrimaryConstructor()
                    ?.parameters?.map {
                        it.name
                    }
            }
            assertThat(primaryConstructorParameterNames)
                .containsExactly(
                    "MyInterface" to null,
                    "NoExplicitConstructor" to emptyList<String>(),
                    "Base" to listOf("x"),
                    "ExplicitConstructor" to null,
                    "BaseWithSecondary" to listOf("x"),
                    "Sub" to listOf("x"),
                    "SubWith3Constructors" to emptyList<String>(),
                    "AbstractNoExplicit" to emptyList<String>(),
                    "AbstractExplicit" to listOf("x")
                )
        }
    }

    @Test
    fun jvmDefault() {
        val src = Source.kotlin(
            "Foo.kt",
            """
            interface MyInterface {
                fun notJvmDefault()
                @JvmDefault
                fun jvmDefault() {}
            }
            """.trimIndent()
        )
        runTest(sources = listOf(src)) { invocation ->
            val subject = invocation.processingEnv.requireTypeElement("MyInterface")
            assertThat(subject.getMethodByJvmName("notJvmDefault").isJavaDefault()).isFalse()
            assertThat(subject.getMethodByJvmName("jvmDefault").isJavaDefault()).isTrue()
        }
    }

    @Test
    fun constructors_java() {
        val src = Source.java(
            "Source",
            """
            import java.util.List;
            interface MyInterface {}
            class NoExplicitConstructor{}
            class Base {
                Base(int x){}
            }
            class ExplicitConstructor {
                ExplicitConstructor(int x){}
            }
            class BaseWithSecondary {
                BaseWithSecondary(int x){}
                BaseWithSecondary(String y){}
            }
            class Sub extends Base {
                Sub(int x) {
                    super(x);
                }
            }
            class SubWith3Constructors extends BaseWithSecondary {
                SubWith3Constructors() {
                    super(3);
                }
                SubWith3Constructors(List<String> list) {
                    super(3);
                }
                SubWith3Constructors(List<String> list, int x) {
                    super(3);
                }
            }
            abstract class AbstractNoExplicit {}
            abstract class AbstractExplicit {
                AbstractExplicit(int x) {}
            }
            """.trimIndent()
        )
        runTest(sources = listOf(src)) { invocation ->
            val subjects = listOf(
                "MyInterface", "NoExplicitConstructor", "Base", "ExplicitConstructor",
                "BaseWithSecondary", "Sub", "SubWith3Constructors",
                "AbstractNoExplicit", "AbstractExplicit"
            )
            val constructorCounts = subjects.map {
                it to invocation.processingEnv.requireTypeElement(it).getConstructors().size
            }
            assertThat(constructorCounts)
                .containsExactly(
                    "MyInterface" to 0,
                    "NoExplicitConstructor" to 1,
                    "Base" to 1,
                    "ExplicitConstructor" to 1,
                    "BaseWithSecondary" to 2,
                    "Sub" to 1,
                    "SubWith3Constructors" to 3,
                    "AbstractNoExplicit" to 1,
                    "AbstractExplicit" to 1
                )

            subjects.forEach {
                assertWithMessage(it)
                    .that(invocation.processingEnv.requireTypeElement(it).findPrimaryConstructor())
                    .isNull()
            }
        }
    }

    @Test
    fun enumTypeElement() {
        runTest(
            sources = listOf(
                Source.kotlin(
                    "test/KotlinEnum.kt",
                    """
                    package test
                    enum class KotlinEnum(private val x:Int) {
                        VAL1(1),
                        VAL2(2);

                        fun enumMethod(): Unit {}
                    }
                    """.trimIndent()
                ),
                Source.java(
                    "test.JavaEnum",
                    """
                    package test;
                    public enum JavaEnum {
                        VAL1(1),
                        VAL2(2);

                        private int x;

                        JavaEnum(int x) {
                            this.x = x;
                        }
                        void enumMethod() {}
                    }
                    """.trimIndent()
                )
            ),
        ) { invocation ->
            listOf(
                "test.KotlinEnum", "test.JavaEnum",
            ).forEach { qName ->
                val typeElement = invocation.processingEnv.requireTypeElement(qName)
                assertWithMessage("$qName is enum")
                    .that(typeElement.isEnum())
                    .isTrue()
                assertWithMessage("$qName does not report enum constants in methods")
                    .that(typeElement.getDeclaredMethods().map { it.jvmName })
                    .run {
                        contains("enumMethod")
                        containsNoneOf("VAL1", "VAL2")
                    }
                assertWithMessage("$qName can return enum constants")
                    .that((typeElement as XEnumTypeElement).entries.map { it.name })
                    .containsExactly("VAL1", "VAL2")
                assertWithMessage("$qName  does not report enum constants in fields")
                    .that(typeElement.getAllFieldNames())
                    .run {
                        contains("x")
                        containsNoneOf("VAL1", "VAL2")
                    }
                assertWithMessage("$qName does not report enum constants in declared fields")
                    .that(typeElement.getDeclaredFields().map { it.name })
                    .containsExactly("x")
                assertWithMessage("$qName enum entries are XEnumEntry")
                    .that(typeElement.getEnclosedElements().filter { it.isEnumEntry() })
                    .hasSize(2)
                assertWithMessage("$qName  enum entries are not type elements")
                    .that(typeElement.getEnclosedElements().filter { it.isTypeElement() })
                    .isEmpty()
            }
        }
    }

    @Test
    fun enclosedTypes() {
        val src = Source.kotlin(
            "Foo.kt",
            """
            class TopLevelClass {
                class NestedClass
                object NestedObject
                interface NestedInterface
                enum class NestedEnum {
                    A, B
                }
                companion object {
                    val foo = 1
                }
            }
            """.trimIndent()
        )
        runTest(sources = listOf(src)) { invocation ->
            val topLevelClass = invocation.processingEnv.requireTypeElement("TopLevelClass")
            val enclosedTypeElements = topLevelClass.getEnclosedTypeElements()

            assertThat(enclosedTypeElements)
                .containsExactly(
                    invocation.processingEnv.requireTypeElement("TopLevelClass.NestedClass"),
                    invocation.processingEnv.requireTypeElement("TopLevelClass.NestedObject"),
                    invocation.processingEnv.requireTypeElement("TopLevelClass.NestedInterface"),
                    invocation.processingEnv.requireTypeElement("TopLevelClass.NestedEnum"),
                    invocation.processingEnv.requireTypeElement("TopLevelClass.Companion"),
                )
        }
    }

    @Test
    fun enclosedTypes_java() {
        val src = Source.java(
            "Source",
            """
            class TopLevelClass {
                class InnerClass { }
                static class NestedClass { }
                interface NestedInterface { }
                enum NestedEnum {
                    A, B
                }
            }
            """.trimIndent()
        )
        runTest(sources = listOf(src)) { invocation ->
            val topLevelClass = invocation.processingEnv.requireTypeElement("TopLevelClass")
            val enclosedTypeElements = topLevelClass.getEnclosedTypeElements()

            assertThat(enclosedTypeElements)
                .containsExactly(
                    invocation.processingEnv.requireTypeElement("TopLevelClass.InnerClass"),
                    invocation.processingEnv.requireTypeElement("TopLevelClass.NestedClass"),
                    invocation.processingEnv.requireTypeElement("TopLevelClass.NestedInterface"),
                    invocation.processingEnv.requireTypeElement("TopLevelClass.NestedEnum"),
                )
        }
    }

    @Test
    fun kotlinObjects() {
        val kotlinSrc = Source.kotlin(
            "Test.kt",
            """
            package foo.bar
            class KotlinClass {
                companion object
                object NestedObject
            }
            """.trimIndent()
        )
        runTest(listOf(kotlinSrc)) { invocation ->
            val kotlinClass = invocation.processingEnv.requireTypeElement(
                "foo.bar.KotlinClass")
            val companionObjects = kotlinClass.getEnclosedTypeElements().filter {
                it.isCompanionObject()
            }
            assertThat(companionObjects.size).isEqualTo(1)
            val companionObj = companionObjects.first()
            assertThat(companionObj.isKotlinObject()).isTrue()
        }
    }

    @Test
    fun inheritedGenericMethod() {
        runTest(
            sources = listOf(
                Source.kotlin(
                    "test.ConcreteClass.kt",
                    """
                    package test
                    class ConcreteClass: AbstractClass<Foo, Bar>() {}
                    abstract class AbstractClass<T1, T2> {
                        fun method(t1: T1, t2: T2): T2 {
                          return t2
                        }
                    }
                    class Foo
                    class Bar
                    """.trimIndent()
                )
            )
        ) { invocation ->
            val concreteClass = invocation.processingEnv.requireTypeElement("test.ConcreteClass")
            val abstractClass = invocation.processingEnv.requireTypeElement("test.AbstractClass")
            val concreteClassMethod = concreteClass.getMethodByJvmName("method")
            val abstractClassMethod = abstractClass.getMethodByJvmName("method")
            val fooType = invocation.processingEnv.requireType("test.Foo")
            val barType = invocation.processingEnv.requireType("test.Bar")

            fun checkMethodElement(method: XMethodElement) {
                checkMethodElement(
                    method = method,
                    name = "method",
                    enclosingElement = abstractClass,
                    returnType = createXTypeVariableName("T2"),
                    parameterTypes = arrayOf(
                        createXTypeVariableName("T1"),
                        createXTypeVariableName("T2")
                    )
                )
                checkMethodType(
                    methodType = method.executableType,
                    returnType = createXTypeVariableName("T2"),
                    parameterTypes = arrayOf(
                        createXTypeVariableName("T1"),
                        createXTypeVariableName("T2")
                    )
                )
                checkMethodType(
                    methodType = method.asMemberOf(abstractClass.type),
                    returnType = createXTypeVariableName("T2"),
                    parameterTypes = arrayOf(
                        createXTypeVariableName("T1"),
                        createXTypeVariableName("T2")
                    )
                )
                checkMethodType(
                    methodType = method.asMemberOf(concreteClass.type),
                    returnType = barType.asTypeName(),
                    parameterTypes = arrayOf(fooType.asTypeName(), barType.asTypeName())
                )
            }

            assertThat(concreteClassMethod).isEqualTo(abstractClassMethod)
            checkMethodElement(concreteClassMethod)
            checkMethodElement(abstractClassMethod)
        }
    }

    @Test
    fun overriddenGenericMethod() {
        runTest(
            sources = listOf(
                Source.kotlin(
                    "test.ConcreteClass.kt",
                    """
                    package test
                    class ConcreteClass: AbstractClass<Foo, Bar>() {
                        override fun method(t1: Foo, t2: Bar): Bar {
                          return t2
                        }
                    }
                    abstract class AbstractClass<T1, T2> {
                        abstract fun method(t1: T1, t2: T2): T2
                    }
                    class Foo
                    class Bar
                    """.trimIndent()
                )
            )
        ) { invocation ->
            val concreteClass = invocation.processingEnv.requireTypeElement("test.ConcreteClass")
            val abstractClass = invocation.processingEnv.requireTypeElement("test.AbstractClass")
            val concreteClassMethod = concreteClass.getMethodByJvmName("method")
            val abstractClassMethod = abstractClass.getMethodByJvmName("method")
            val fooType = invocation.processingEnv.requireType("test.Foo")
            val barType = invocation.processingEnv.requireType("test.Bar")

            assertThat(concreteClassMethod).isNotEqualTo(abstractClassMethod)
            assertThat(concreteClassMethod.overrides(abstractClassMethod, concreteClass)).isTrue()

            // Check the abstract method and method type
            checkMethodElement(
                method = abstractClassMethod,
                name = "method",
                enclosingElement = abstractClass,
                returnType = createXTypeVariableName("T2"),
                parameterTypes = arrayOf(
                    createXTypeVariableName("T1"),
                    createXTypeVariableName("T2")
                )
            )
            checkMethodType(
                methodType = abstractClassMethod.executableType,
                returnType = createXTypeVariableName("T2"),
                parameterTypes = arrayOf(
                    createXTypeVariableName("T1"),
                    createXTypeVariableName("T2")
                )
            )
            checkMethodType(
                methodType = abstractClassMethod.asMemberOf(abstractClass.type),
                returnType = createXTypeVariableName("T2"),
                parameterTypes = arrayOf(
                    createXTypeVariableName("T1"),
                    createXTypeVariableName("T2"),
                )
            )
            checkMethodType(
                methodType = abstractClassMethod.asMemberOf(concreteClass.type),
                returnType = barType.asTypeName(),
                parameterTypes = arrayOf(fooType.asTypeName(), barType.asTypeName())
            )

            // Check the concrete method and method type
            checkMethodElement(
                method = concreteClassMethod,
                name = "method",
                enclosingElement = concreteClass,
                returnType = barType.asTypeName(),
                parameterTypes = arrayOf(fooType.asTypeName(), barType.asTypeName())
            )
            checkMethodType(
                methodType = concreteClassMethod.executableType,
                returnType = barType.asTypeName(),
                parameterTypes = arrayOf(fooType.asTypeName(), barType.asTypeName())
            )
            checkMethodType(
                methodType = concreteClassMethod.asMemberOf(concreteClass.type),
                returnType = barType.asTypeName(),
                parameterTypes = arrayOf(fooType.asTypeName(), barType.asTypeName())
            )
        }
    }

    private fun checkMethodElement(
        method: XMethodElement,
        name: String,
        enclosingElement: XTypeElement,
        returnType: XTypeName,
        parameterTypes: Array<XTypeName>
    ) {
        assertThat(method.name).isEqualTo(name)
        assertThat(method.enclosingElement).isEqualTo(enclosingElement)
        assertThat(method.returnType.asTypeName()).isEqualTo(returnType)
        assertThat(method.parameters.map { it.type.asTypeName() })
            .containsExactly(*parameterTypes)
            .inOrder()
    }
    private fun checkMethodType(
        methodType: XMethodType,
        returnType: XTypeName,
        parameterTypes: Array<XTypeName>
    ) {
        assertThat(methodType.returnType.asTypeName()).isEqualTo(returnType)
        assertThat(methodType.parameterTypes.map { it.asTypeName() })
            .containsExactly(*parameterTypes)
            .inOrder()
    }

    @Test
    fun overriddenGenericConstructor() {
        runTest(
            sources = listOf(
                Source.kotlin(
                    "test.ConcreteClass.kt",
                    """
                    package test
                    class ConcreteClass(foo: Foo): AbstractClass<Foo>(foo) {}
                    abstract class AbstractClass<T>(t: T)
                    class Foo
                    """.trimIndent()
                )
            )
        ) { invocation ->
            val concreteClass = invocation.processingEnv.requireTypeElement("test.ConcreteClass")
            val abstractClass = invocation.processingEnv.requireTypeElement("test.AbstractClass")
            val fooType = invocation.processingEnv.requireType("test.Foo")

            fun checkConstructorParameters(
                typeElement: XTypeElement,
                expectedParameters: Array<XTypeName>
            ) {
                assertThat(typeElement.getConstructors()).hasSize(1)
                val constructor = typeElement.getConstructors()[0]
                assertThat(constructor.parameters.map { it.type.asTypeName() })
                    .containsExactly(*expectedParameters)
                    .inOrder()
            }

            checkConstructorParameters(
                typeElement = abstractClass,
                expectedParameters = arrayOf(
                    createXTypeVariableName("T")
                )
            )
            checkConstructorParameters(
                typeElement = concreteClass,
                expectedParameters = arrayOf(fooType.asTypeName())
            )
        }
    }

    @Test
    fun inheritedGenericField() {
        runTest(
            sources = listOf(
                Source.kotlin(
                    "test.ConcreteClass.kt",
                    """
                    package test
                    class ConcreteClass: AbstractClass<Foo>()
                    abstract class AbstractClass<T> {
                        val field: T = TODO()
                    }
                    class Foo
                    """.trimIndent()
                )
            )
        ) { invocation ->
            val concreteClass = invocation.processingEnv.requireTypeElement("test.ConcreteClass")
            val abstractClass = invocation.processingEnv.requireTypeElement("test.AbstractClass")
            val concreteClassField = concreteClass.getField("field")
            val abstractClassField = abstractClass.getField("field")
            val fooType = invocation.processingEnv.requireType("test.Foo")

            fun checkFieldElement(field: XFieldElement) {
                assertThat(field.name).isEqualTo("field")
                assertThat(field.type.asTypeName().java).isEqualTo(JTypeVariableName.get("T"))
                assertThat(field.asMemberOf(abstractClass.type).asTypeName().java)
                    .isEqualTo(JTypeVariableName.get("T"))
                assertThat(field.asMemberOf(concreteClass.type).asTypeName().java)
                    .isEqualTo(fooType.asTypeName().java)
                if (invocation.isKsp) {
                    assertThat(field.type.asTypeName().kotlin).isEqualTo(KTypeVariableName("T"))
                    assertThat(field.asMemberOf(abstractClass.type).asTypeName().kotlin)
                        .isEqualTo(KTypeVariableName("T"))
                    assertThat(field.asMemberOf(concreteClass.type).asTypeName().kotlin)
                        .isEqualTo(fooType.asTypeName().kotlin)
                }
            }

            assertThat(concreteClassField).isEqualTo(abstractClassField)
            checkFieldElement(abstractClassField)
            checkFieldElement(concreteClassField)
        }
    }

    @Test
    fun internalModifier() {
        runTest(
            sources = listOf(
                Source.kotlin(
                    "test.Foo.kt",
                    """
                    package test
                    internal class InternalClass internal constructor() {
                      internal val valField: String = TODO()
                      internal var varField: String = TODO()
                      internal fun method(): String = TODO()
                      internal lateinit var lateinitVarField: String
                    }
                    class PublicClass constructor() {
                      val valField: String = TODO()
                      var varField: String = TODO()
                      fun method(): String = TODO()
                      lateinit var lateinitVarField: String
                    }
                    """.trimIndent()
                )
            )
        ) { invocation ->
            // Matches by name rather than jvmName to avoid dealing with name mangling.
            fun XTypeElement.getDeclaredMethod(name: String): XMethodElement {
                return getDeclaredMethods().filter { it.name == name }.single()
            }

            val internalClass = invocation.processingEnv.requireTypeElement("test.InternalClass")
            assertThat(internalClass.isInternal()).isTrue()
            assertThat(internalClass.getConstructors().single().isInternal()).isTrue()
            assertThat(internalClass.getDeclaredField("valField").isInternal()).isTrue()
            assertThat(internalClass.getDeclaredField("varField").isInternal()).isTrue()
            assertThat(internalClass.getDeclaredField("lateinitVarField").isInternal()).isTrue()
            assertThat(internalClass.getDeclaredMethod("method").isInternal()).isTrue()
            assertThat(internalClass.getDeclaredMethod("getValField").isInternal()).isTrue()
            assertThat(internalClass.getDeclaredMethod("getVarField").isInternal()).isTrue()
            assertThat(internalClass.getDeclaredMethod("getLateinitVarField").isInternal()).isTrue()
            assertThat(internalClass.getDeclaredMethod("setVarField").isInternal()).isTrue()
            assertThat(internalClass.getDeclaredMethod("setLateinitVarField").isInternal()).isTrue()

            val publicClass = invocation.processingEnv.requireTypeElement("test.PublicClass")
            assertThat(publicClass.isInternal()).isFalse()
            assertThat(publicClass.getConstructors().single().isInternal()).isFalse()
            assertThat(publicClass.getDeclaredField("valField").isInternal()).isFalse()
            assertThat(publicClass.getDeclaredField("varField").isInternal()).isFalse()
            assertThat(publicClass.getDeclaredField("lateinitVarField").isInternal()).isFalse()
            assertThat(publicClass.getDeclaredMethod("method").isInternal()).isFalse()
            assertThat(publicClass.getDeclaredMethod("getValField").isInternal()).isFalse()
            assertThat(publicClass.getDeclaredMethod("getVarField").isInternal()).isFalse()
            assertThat(publicClass.getDeclaredMethod("getLateinitVarField").isInternal()).isFalse()
            assertThat(publicClass.getDeclaredMethod("setVarField").isInternal()).isFalse()
            assertThat(publicClass.getDeclaredMethod("setLateinitVarField").isInternal()).isFalse()
        }
    }

    @Test
    fun sameMethodNameOrder() {
        runTest(
            sources = listOf(
                Source.kotlin(
                    "test.Foo.kt",
                    """
                    package test
                    class Foo<T1: Bar, T2: Baz> {
                        fun method(): String = TODO()
                        fun method(param: String): String = TODO()
                        fun method(param: Any): String = TODO()
                        fun method(param: T1): T2 = TODO()
                        fun method(param: T2): T1 = TODO()
                        fun <U1: Baz, U2> method(param1: U1, param2: U2) {}
                        fun <U1: Baz, U2: U1> method(param1: U1, param2: U2): T1 = TODO()
                    }
                    interface Bar
                    interface Baz
                    """.trimIndent()
                )
            )
        ) { invocation ->
            val foo = invocation.processingEnv.requireTypeElement("test.Foo")
            assertThat(foo.getDeclaredMethods().map { it.jvmDescriptor }.toList())
                .containsExactly(
                    "method()Ljava/lang/String;",
                    "method(Ljava/lang/String;)Ljava/lang/String;",
                    "method(Ljava/lang/Object;)Ljava/lang/String;",
                    "method(Ltest/Bar;)Ltest/Baz;",
                    "method(Ltest/Baz;)Ltest/Bar;",
                    "method(Ltest/Baz;Ljava/lang/Object;)V",
                    "method(Ltest/Baz;Ltest/Baz;)Ltest/Bar;"
                ).inOrder()
        }
    }

    @Test
    fun jvmDescriptors() {
        runTest(
            sources = listOf(
                Source.kotlin(
                    "test.Foo.kt",
                    """
                    package test
                    class Foo<T1: Bar, T2: Baz> {
                        val field1: String = TODO()
                        var field2: String? = TODO()
                        val field3: T1 = TODO()
                        fun method(): String = TODO()
                        fun method(param: String): String = TODO()
                        fun method(param: Any): String = TODO()
                        fun method(param: T1): T2 = TODO()
                    }
                    interface Bar
                    interface Baz
                    """.trimIndent()
                )
            )
        ) { invocation ->
            val foo = invocation.processingEnv.requireTypeElement("test.Foo")
            assertThat(foo.getEnclosedElements().map {
                when {
                    it.isField() -> it.jvmDescriptor
                    it.isMethod() -> it.jvmDescriptor
                    it.isConstructor() -> it.jvmDescriptor
                    else -> error("Unsupported element to describe.")
                }
            }.toList())
                .containsExactly(
                    "<init>()V",
                    "field1:Ljava/lang/String;",
                    "field2:Ljava/lang/String;",
                    "field3:Ltest/Bar;",
                    "getField1()Ljava/lang/String;",
                    "getField2()Ljava/lang/String;",
                    "setField2(Ljava/lang/String;)V",
                    "getField3()Ltest/Bar;",
                    "method()Ljava/lang/String;",
                    "method(Ljava/lang/String;)Ljava/lang/String;",
                    "method(Ljava/lang/Object;)Ljava/lang/String;",
                    "method(Ltest/Bar;)Ltest/Baz;",
                )
        }
    }

    /**
     * it is good to exclude methods coming from Object when testing as they differ between KSP
     * and KAPT but irrelevant for Room.
     */
    private fun XTestInvocation.objectMethodNames() = processingEnv
        .requireTypeElement("java.lang.Object")
        .getAllMethods()
        .jvmNames()

    private fun Sequence<XMethodElement>.jvmNames() = map {
        it.jvmName
    }.toList()

    private fun List<XMethodElement>.jvmNames() = map {
        it.jvmName
    }.toList()

    private fun XMethodElement.signature(owner: XType): String {
        val methodType = this.asMemberOf(owner)
        val params = methodType.parameterTypes.joinToString(",") {
            it.asTypeName().java.toString()
        }
        return "$jvmName($params):${returnType.asTypeName().java}"
    }

    private fun XTestInvocation.nonObjectMethodSignatures(typeElement: XTypeElement): List<String> =
        typeElement.getAllMethods()
            .filterNot { it.jvmName in objectMethodNames() }
            .map { it.signature(typeElement.type) }.toList()

    companion object {
        @JvmStatic
        @Parameterized.Parameters(name = "isPreCompiled_{0}")
        fun params(): List<Array<Any>> {
            return listOf(arrayOf(false), arrayOf(true))
        }
    }
}